说三道四技术文摘-感悟人生的经典句子
说三道四 > 文档快照

ART运行时Foreground GC和Background GC切换过程分析

HTML文档下载 WORD文档下载 PDF文档下载
ART运行时支持Mark-Sweep GC和Compacting GC。前者执行效率更高,但存在内存碎片问题;后者则与之相反。ART运行时通过引入Foreground GC和Background GC来对这两种GC扬长避短,本文分析它们的执行过程以及切换过程。

通过前面一系列文章的学习,我们知道了ART运行时既支持Mark-Sweep GC,又支持Compacting GC。其中,Mark-Sweep GC执行效率更高,但是存在内存碎片问题;而Compacting GC执行效率较低,但是不存在内存碎片问题。ART运行时通过引入Foreground GC和Background GC的概念来对这两种GC进行扬长避短。本文就详细分析它们的执行过程以及切换过程。

在前面 ART运行时Compacting GC简要介绍和学习计划以及 ART运行时Compacting GC堆创建过程分析这两篇文章中,我们都有提到ART运行时的Foreground GC和Background GC。它们是在ART运行时启动通过-Xgc和-XX:BackgroundGC指定的。但是在某同一段时间,ART运行时只会执行Foreground GC或者Background GC。也就是说,Foreground GC和Background GC在整个应用程序的生命周期中是交替执行的。这就涉及到从Foreground GC切换到Background GC,或者从Background GC切换到Foreground GC的问题。

现在两个问题就来了:什么时候执行Foreground GC,什么时候执行Background GC?什么GC作为Foreground GC最合适,什么GC作为Background GC最合适?

顾名思义,Foreground指的就是应用程序在前台运行时,而Background就是应用程序在后台运行时。因此,Foreground GC就是应用程序在前台运行时执行的GC,而Background就是应用程序在后台运行时执行的GC。

应用程序在前台运行时,响应性是最重要的,因此也要求执行的GC是高效的。相反,应用程序在后台运行时,响应性不是最重要的,这时候就适合用来解决堆的内存碎片问题。因此,Mark-Sweep GC适合作为Foreground GC,而Compacting GC适合作为Background GC。

但是,ART运行时又是怎么知道应用程序目前是运行在前台还是后台呢?这就需要负责管理应用程序组件的系统服务ActivityManagerService闪亮登场了。因为ActivityManagerService清楚地知道应用程序的每一个组件的运行状态,也就是它们当前是在前台运行还是后台运行,从而得到应用程序是前台运行还是后台运行的结论。

我们通过图1来描述应用程序的运行状态与Foreground GC和Background GC的时序关系,如下所示:


图1 应用程序运行状态与Foreground GC和Background GC的时序关系

从图1还可以看到,当从Foreground GC切换到Background GC,或者从Background GC切换到Foreground GC,会发生一次Compacting GC的行为。这是由于Foreground GC和Background GC的底层堆空间结构是一样的,因此发生Foreground GC和Background GC切换时,需要将当前存活的对象从一个Space转移到另外一个Space上去。这个刚好就是Semi-Space GC和Generational Semi-Space GC合适干的事情。

图1中的显示了应用程序的两个状态:kProcessStateJankPerceptible和kProcessStateJankImperceptible。其中,kProcessStateJankPerceptible说的就是应用程序处于用户可感知的状态,这就相当于是前台状态;而kProcessStateJankImperceptible说的就是应用程序处于用户不可感知的状态,这就相当于是后台状态。

接下来,我们就结合ActivityManagerService来分析Foreground GC和Background GC的切换过程。

从前面 Android应用程序的Activity启动过程简要介绍和学习计划这个系列的文章可以知道,应用程序组件是通过ActivityManagerService进行启动的。例如,当我们从Launcher启动一个应用程序时,实际的是在这个应用程序中Action和Category分别被配置为MAIN和LAUNCHER的Activity。这个Activity最终由ActivityManagerService通知其所在的进程进行启动工作的,也就是通过ApplicationThread类的成员函数scheduleLaunchActivity开始执行启动工作的。其它类型的组件的启动过程也是类似的,这里我们仅以Activity的启动过程作为示例,来说明ART运行时如何知道要进行Foreground GC和Background GC切换的。

ApplicationThread类的成员函数scheduleLaunchActivity的实现如下所示:

public final class ActivityThread {      ......        private class ApplicationThread extends ApplicationThreadNative {          ......            public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,                  ActivityInfo info, Configuration curConfig, CompatibilityInfo compatInfo,                  IVoiceInteractor voiceInteractor, int procState, Bundle state,                  PersistableBundle persistentState, List<ResultInfo> pendingResults,                  List<Intent> pendingNewIntents, boolean notResumed, boolean isForward,                  ProfilerInfo profilerInfo) {                updateProcessState(procState, false);                ActivityClientRecord r = new ActivityClientRecord();                r.token = token;              r.ident = ident;              r.intent = intent;              r.voiceInteractor = voiceInteractor;              r.activityInfo = info;              r.compatInfo = compatInfo;              r.state = state;              r.persistentState = persistentState;                r.pendingResults = pendingResults;              r.pendingIntents = pendingNewIntents;                r.startsNotResumed = notResumed;              r.isForward = isForward;                r.profilerInfo = profilerInfo;                updatePendingConfiguration(curConfig);                sendMessage(H.LAUNCH_ACTIVITY, r);          }            ......      }        ......  }  

这个函数定义在文件frameworks/base/core/java/android/app/ActivityThread.java中。

ApplicationThread类的成员函数scheduleLaunchActivity首先是调用另外一个成员函数updateProcessState更新进程的当前状态,接着再将其余参数封装在一个ActivityClientRecord对象中,并且将这个ActivityClientRecord对象通过一个H.LAUNCH_ACTIVITY消息传递给应用程序主线程处理。应用程序主线程处理对这个消息的处理就是启动指定的Activity,这个过程可以参考前面Android应用程序的Activity启动过程简要介绍和学习计划这个系列的文章。ApplicationThread类的成员函数scheduleLaunchActivity还调用了另外一个成员函数updatePendingConfiguration将参数cureConfig描述的系统当前配置信息保存下来待后面处理。

我们主要关注ApplicationThread类的成员函数updateProcessState,因为它涉及到进程状态的更新,它的实现如下所示:

public final class ActivityThread {      ......        private class ApplicationThread extends ApplicationThreadNative {          ......            public void updateProcessState(int processState, boolean fromIpc) {              synchronized (this) {                  if (mLastProcessState != processState) {                      mLastProcessState = processState;                      // Update Dalvik state based on ActivityManager.PROCESS_STATE_* constants.                      final int DALVIK_PROCESS_STATE_JANK_PERCEPTIBLE = 0;                      final int DALVIK_PROCESS_STATE_JANK_IMPERCEPTIBLE = 1;                      int dalvikProcessState = DALVIK_PROCESS_STATE_JANK_IMPERCEPTIBLE;                      // TODO: Tune this since things like gmail sync are important background but not jank perceptible.                      if (processState <= ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND) {                          dalvikProcessState = DALVIK_PROCESS_STATE_JANK_PERCEPTIBLE;                      }                      VMRuntime.getRuntime().updateProcessState(dalvikProcessState);                      ......                  }              }          }            ......      }        ......  }  

这个函数定义在文件frameworks/base/core/java/android/app/ActivityThread.java中。

ApplicationThread类的成员变量mLastProcessState描述的是进程上一次的状态,而参数processState描述的是进程当前的状态。当这两者的值不一致时,就表明进程的状态发生了变化,这时候就需要调用VMRuntime类的成员函数updateProcessState通知ART运行时,以便ART运行时可以在Foreground GC和Background GC之间切换。

ActivityManagerService一共定义了14种进程状态,如下所示:

public class ActivityManager {      ......        /** @hide Process is a persistent system process. */      public static final int PROCESS_STATE_PERSISTENT = 0;        /** @hide Process is a persistent system process and is doing UI. */      public static final int PROCESS_STATE_PERSISTENT_UI = 1;        /** @hide Process is hosting the current top activities.  Note that this covers      * all activities that are visible to the user. */      public static final int PROCESS_STATE_TOP = 2;        /** @hide Process is important to the user, and something they are aware of. */      public static final int PROCESS_STATE_IMPORTANT_FOREGROUND = 3;        /** @hide Process is important to the user, but not something they are aware of. */      public static final int PROCESS_STATE_IMPORTANT_BACKGROUND = 4;        /** @hide Process is in the background running a backup/restore operation. */      public static final int PROCESS_STATE_BACKUP = 5;        /** @hide Process is in the background, but it can't restore its state so we want      * to try to avoid killing it. */      public static final int PROCESS_STATE_HEAVY_WEIGHT = 6;        /** @hide Process is in the background running a service.  Unlike oom_adj, this level      * is used for both the normal running in background state and the executing      * operations state. */      public static final int PROCESS_STATE_SERVICE = 7;        /** @hide Process is in the background running a receiver.   Note that from the      * perspective of oom_adj receivers run at a higher foreground level, but for our      * prioritization here that is not necessary and putting them below services means      * many fewer changes in some process states as they receive broadcasts. */      public static final int PROCESS_STATE_RECEIVER = 8;        /** @hide Process is in the background but hosts the home activity. */      public static final int PROCESS_STATE_HOME = 9;        /** @hide Process is in the background but hosts the last shown activity. */      public static final int PROCESS_STATE_LAST_ACTIVITY = 10;        /** @hide Process is being cached for later use and contains activities. */      public static final int PROCESS_STATE_CACHED_ACTIVITY = 11;        /** @hide Process is being cached for later use and is a client of another cached      * process that contains activities. */      public static final int PROCESS_STATE_CACHED_ACTIVITY_CLIENT = 12;        /** @hide Process is being cached for later use and is empty. */      public static final int PROCESS_STATE_CACHED_EMPTY = 13;        ......  }  

这些进程状态值定义在文件frameworks/base/core/java/android/app/ActivityManager.java。

每一个进程状态都通过一个整数来描述,其中,值越小就表示进程越重要。ART运行时将状态值大于等于PROCESS_STATE_IMPORTANT_FOREGROUND的进程都认为是用户可感知的,也就是前台进程,其余的进程则认为是用户不可感知的,也就是后台进程。通过这种方式,ApplicationThread类的成员函数updateProcessState就可以简化ART运行时对进程状态的处理。

除了上述的Activity的Launch启动生命周期函数被ActivityManagerService通知调用时,Activity的Resume生命周期函数被ActivityManagerService通知调用调用时,也会发生类似的通过VMRuntime类的成员函数updateProcessState通知ART运行时应用程序状态发生了改变。对于其它的组件,例如Broadcast Receiver组件被触发时,Service组件被创建以及被绑定时,也会通过VMRuntime类的成员函数updateProcessState通知ART运行时应用程序状态发生了改变。

不过,上述组件的生命周期对应的都是应用程序处于前台时的情况,也就是要求ART运行时从Background GC切换为Foreground GC的情况。当应用程序处于后台时,ActivityManagerService是通过直接设置应用程序的状态来通知ART运行时应用程序状态发生了改变的。

ApplicationThread类实现了一个Binder接口setProcessState,供ActivityManagerService直接设置应用程序的状态,它的实现如下所示:

public final class ActivityThread {      ......        private class ApplicationThread extends ApplicationThreadNative {          ......            public void setProcessState(int state) {              updateProcessState(state, true);          }            ......      }        ......  }  

这个函数定义在文件frameworks/base/core/java/android/app/ActivityThread.java中。

ApplicationThread类实现的Binder接口setProcessState也是通过上面分析的成员函数updateProcessState来通知ART运行时进程状态发生了改变的。不过这时候进程的状态就有可能是从前面进程变为后台进程,例如当运行在该进程的Activity组件处理Stop状态时。

接下来我们继续分析VMRuntime类的成员函数updateProcessState的实现,以便了解ART运行时执行Foreground GC和Background GC切换的过程,如下所示:

public final class VMRuntime {      ......        /**      * Let the heap know of the new process state. This can change allocation and garbage collection      * behavior regarding trimming and compaction.      */      public native void updateProcessState(int state);        ......  }  

这个函数定义在文件libcore/libart/src/main/java/dalvik/system/VMRuntime.java中。

VMRuntime类的成员函数updateProcessState是一个Native函数,它由C++层的函数VMRuntime_updateProcessState实现,如下所示:

static void VMRuntime_updateProcessState(JNIEnv* env, jobject, jint process_state) {    Runtime::Current()->GetHeap()->UpdateProcessState(static_cast<gc::ProcessState>(process_state));    ......  }  

这个函数定义在文件art/runtime/native/dalvik_system_VMRuntime.cc中。

函数VMRuntime_updateProcessState主要是调用了Heap类的成员函数UpdateProcessState来通知ART运行时切换Foreground GC和Background GC,后者的实现如下所示:

void Heap::UpdateProcessState(ProcessState process_state) {    if (process_state_ != process_state) {      process_state_ = process_state;      ......      if (process_state_ == kProcessStateJankPerceptible) {        // Transition back to foreground right away to prevent jank.        RequestCollectorTransition(foreground_collector_type_, 0);      } else {        // Don't delay for debug builds since we may want to stress test the GC.        // If background_collector_type_ is kCollectorTypeHomogeneousSpaceCompact then we have        // special handling which does a homogenous space compaction once but then doesn't transition        // the collector.        RequestCollectorTransition(background_collector_type_,                                   kIsDebugBuild ? 0 : kCollectorTransitionWait);      }    }  }  

这个函数定义在文件art/runtime/gc/heap.cc中。

Heap类的成员变量prcess_state_记录了进程上一次的状态,参数process_state描述进程当前的状态。当这两者的值不相等的时候,就说明进程状态发生了变化。

如果是从kProcessStateJankImperceptible状态变为kProcessStateJankPerceptible状态,那么就调用Heap类的成员函数RequestCollectorTransition请求马上将当前的GC设置为Foreground GC。

如果是从kProcessStateJankPerceptible状态变为kProcessStateJankImperceptible,那么就调用Heap类的成员函数RequestCollectorTransition请求将当前的GC设置为Background GC。注意,在这种情况下,对于非DEBUG版本的ART运行时,不是马上将当前的GC设置为Background GC的,而是指定在kCollectorTransitionWait(5秒)时间后再设置。这样使得进程进入后台运行的一小段时间内,仍然可以使用效率较高的Mark-Sweep GC。

Heap类的成员函数RequestCollectorTransition的实现如下所示:

void Heap::RequestCollectorTransition(CollectorType desired_collector_type, uint64_t delta_time) {    Thread* self = Thread::Current();    {      MutexLock mu(self, *heap_trim_request_lock_);      if (desired_collector_type_ == desired_collector_type) {        return;      }      heap_transition_or_trim_target_time_ =          std::max(heap_transition_or_trim_target_time_, NanoTime() + delta_time);      desired_collector_type_ = desired_collector_type;    }    SignalHeapTrimDaemon(self);  }  

这个函数定义在文件art/runtime/gc/heap.cc中。

Heap类的成员函数RequestCollectorTransition首先将要切换至的目标GC以及时间点记录在成员变量desired_collector_type_和heap_transition_or_trim_target_time_中,接着再调用另外一个成员函数SignalHeapTrimDaemon唤醒一个Heap Trimmer守护线程来执行GC切换操作。注意,如果上一次请求的GC切换还未执行,又请求了下一次GC切换,并且下一次GC切换指定的时间大于上一次指定的时间,那么上次请求的GC切换就会被取消。

Heap类的成员函数RequestCollectorTransition的实现如下所示:

void Heap::SignalHeapTrimDaemon(Thread* self) {    JNIEnv* env = self->GetJniEnv();    DCHECK(WellKnownClasses::java_lang_Daemons != nullptr);    DCHECK(WellKnownClasses::java_lang_Daemons_requestHeapTrim != nullptr);    env->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons,                              WellKnownClasses::java_lang_Daemons_requestHeapTrim);    CHECK(!env->ExceptionCheck());  }  

这个函数定义在文件art/runtime/gc/heap.cc中。

Heap类的成员函数RequestCollectorTransition通过JNI接口调用了Daemons类的静态成员函数requestHeapTrim请求执行一次GC切换操作。

Daemons类的静态成员函数requestHeapTrim的实现如下所示:

public final class Daemons {      ......        public static void requestHeapTrim() {          synchronized (HeapTrimmerDaemon.INSTANCE) {              HeapTrimmerDaemon.INSTANCE.notify();          }      }        ......  }  

这个函数定义在文件libcore/libart/src/main/java/java/lang/Daemons.java中。

在前面 ART运行时垃圾收集(GC)过程分析一文中提到,Java层的java.lang.Daemons类在加载的时候,会启动五个与堆或者GC相关的守护线程,其中一个守护线程就是HeapTrimmerDaemon,这里通过调用它的成员函数notify来唤醒它。

HeapTrimmerDaemon原先被Block在成员函数run中,当它被唤醒之后 ,就会继续执行它的成员函数run,如下所示:

public final class Daemons {      ......        private static class HeapTrimmerDaemon extends Daemon {          private static final HeapTrimmerDaemon INSTANCE = new HeapTrimmerDaemon();            @Override public void run() {              while (isRunning()) {                  try {                      synchronized (this) {                          wait();                      }                      VMRuntime.getRuntime().trimHeap();                  } catch (InterruptedException ignored) {                  }              }          }      }        ......  }  

这个函数定义在文件libcore/libart/src/main/java/java/lang/Daemons.java中。

从这里就可以看到,HeapTrimmerDaemon被唤醒之后,就会调用VMRuntime类的成员函数trimHeap来执行GC切换操作。

VMRuntime类的成员函数trimHeap是一个Native函数,由C++层的函数VMRuntime_trimHeap实现,如下所示:

static void VMRuntime_trimHeap(JNIEnv*, jobject) {    Runtime::Current()->GetHeap()->DoPendingTransitionOrTrim();  }  

这个函数定义在文件art/runtime/native/dalvik_system_VMRuntime.cc 。

函数VMRuntime_trimHeap又是通过调用Heap类的成员函数DoPendingTransitionOrTrim来执行GC切换操作的,如下所示:

void Heap::DoPendingTransitionOrTrim() {    Thread* self = Thread::Current();    CollectorType desired_collector_type;    // Wait until we reach the desired transition time.    while (true) {      uint64_t wait_time;      {        MutexLock mu(self, *heap_trim_request_lock_);        desired_collector_type = desired_collector_type_;        uint64_t current_time = NanoTime();        if (current_time >= heap_transition_or_trim_target_time_) {          break;        }        wait_time = heap_transition_or_trim_target_time_ - current_time;      }      ScopedThreadStateChange tsc(self, kSleeping);      usleep(wait_time / 1000);  // Usleep takes microseconds.    }    // Launch homogeneous space compaction if it is desired.    if (desired_collector_type == kCollectorTypeHomogeneousSpaceCompact) {      if (!CareAboutPauseTimes()) {        PerformHomogeneousSpaceCompact();      }      // No need to Trim(). Homogeneous space compaction may free more virtual and physical memory.      desired_collector_type = collector_type_;      return;    }    // Transition the collector if the desired collector type is not the same as the current    // collector type.    TransitionCollector(desired_collector_type);    ......    // Do a heap trim if it is needed.    Trim();  }  

这个函数定义在文件art/runtime/gc/heap.cc中。

前面提到,下一次GC切换时间记录在Heap类的成员变量heap_transition_or_trim_target_time_中,因此,Heap类的成员函数DoPendingTransitionOrTrim首先是看看当前时间是否已经达到指定的GC切换时间。如果还没有达到,那么就进行等待,直到时间到达为止。

有一种特殊情况,如果要切换至的GC是kCollectorTypeHomogeneousSpaceCompact,并且Heap类的成员函数CareAboutPauseTimes表明不在乎执行HomogeneousSpaceCompact GC带来的暂停时间,那么就会调用Heap类的成员函数PerformHomogeneousSpaceCompact执行一次同构空间压缩。Heap类的成员函数PerformHomogeneousSpaceCompact执行同构空间压缩的过程,可以参考前面 ART运行时Compacting GC为新创建对象分配内存的过程分析一文。

Heap类的成员函数CareAboutPauseTimes实际上是判断进程的当前状态是否是用户可感知的,即是否等于kProcessStateJankPerceptible。如果是的话,就说明它在乎GC执行时带来的暂停时间。它的实现如下所示:

class Heap {   public:    ......      // Returns true if we currently care about pause times.    bool CareAboutPauseTimes() const {      return process_state_ == kProcessStateJankPerceptible;    }   ......  };  

这个函数定义在文件art/runtime/gc/heap.h中。

回到Heap类的成员函数DoPendingTransitionOrTrim中,我们继续讨论要切换至的GC是kCollectorTypeHomogeneousSpaceCompact的情况。如果Heap类的成员函数CareAboutPauseTimes表明在乎执行HomogeneousSpaceCompact GC带来的暂停时间,那么就不会调用Heap类的成员函数PerformHomogeneousSpaceCompact执行同构空间压缩。

只要切换至的GC是kCollectorTypeHomogeneousSpaceCompact,无论上述的哪一种情况,都不会真正执行GC切换的操作,因此这时候Heap类的成员函数DoPendingTransitionOrTrim就可以返回了。

从前面的调用过程可以知道,要切换至的GC要么是Foreground GC,要么是Background GC。一般来说,我们是不会将Foreground GC设置为HomogeneousSpaceCompact GC的,但是却有可能将Background GC设置为HomogeneousSpaceCompact GC。因此,上述讨论的情况只发生在Foreground GC切换为Background GC的时候。

另一方面,如果要切换至的GC不是kCollectorTypeHomogeneousSpaceCompact,那么Heap类的成员函数DoPendingTransitionOrTrim就会调用另外一个成员函数TransitionCollector执行切换GC操作。一旦GC切换完毕,Heap类的成员函数DoPendingTransitionOrTrim还会调用成员函数Trim对当前ART运行时堆进行裁剪,也就是将现在没有使用到的内存归还给内核。这个过程可以参考前面 ART运行时垃圾收集(GC)过程分析一文。

接下来我们继续分析Heap类的成员函数TransitionCollector的实现,以便了GC的切换过程,如下所示:

void Heap::TransitionCollector(CollectorType collector_type) {    if (collector_type == collector_type_) {      return;    }    ......    ThreadList* const tl = runtime->GetThreadList();    ......    // Busy wait until we can GC (StartGC can fail if we have a non-zero    // compacting_gc_disable_count_, this should rarely occurs).    for (;;) {      {        ScopedThreadStateChange tsc(self, kWaitingForGcToComplete);        MutexLock mu(self, *gc_complete_lock_);        // Ensure there is only one GC at a time.        WaitForGcToCompleteLocked(kGcCauseCollectorTransition, self);        // Currently we only need a heap transition if we switch from a moving collector to a        // non-moving one, or visa versa.        const bool copying_transition = IsMovingGc(collector_type_) != IsMovingGc(collector_type);        // If someone else beat us to it and changed the collector before we could, exit.        // This is safe to do before the suspend all since we set the collector_type_running_ before        // we exit the loop. If another thread attempts to do the heap transition before we exit,        // then it would get blocked on WaitForGcToCompleteLocked.        if (collector_type == collector_type_) {          return;        }        // GC can be disabled if someone has a used GetPrimitiveArrayCritical but not yet released.        if (!copying_transition || disable_moving_gc_count_ == 0) {          // TODO: Not hard code in semi-space collector?          collector_type_running_ = copying_transition ? kCollectorTypeSS : collector_type;          break;        }      }      usleep(1000);    }    tl->SuspendAll();    switch (collector_type) {      case kCollectorTypeSS: {        if (!IsMovingGc(collector_type_)) {          // Create the bump pointer space from the backup space.          ......          std::unique_ptr<MemMap> mem_map(main_space_backup_->ReleaseMemMap());          // We are transitioning from non moving GC -> moving GC, since we copied from the bump          // pointer space last transition it will be protected.          .....          mem_map->Protect(PROT_READ | PROT_WRITE);          bump_pointer_space_ = space::BumpPointerSpace::CreateFromMemMap("Bump pointer space",                                                                          mem_map.release());          AddSpace(bump_pointer_space_);          Compact(bump_pointer_space_, main_space_, kGcCauseCollectorTransition);          // Use the now empty main space mem map for the bump pointer temp space.          mem_map.reset(main_space_->ReleaseMemMap());          // Unset the pointers just in case.          if (dlmalloc_space_ == main_space_) {            dlmalloc_space_ = nullptr;          } else if (rosalloc_space_ == main_space_) {            rosalloc_space_ = nullptr;          }          // Remove the main space so that we don't try to trim it, this doens't work for debug          // builds since RosAlloc attempts to read the magic number from a protected page.          RemoveSpace(main_space_);          RemoveRememberedSet(main_space_);          delete main_space_;  // Delete the space since it has been removed.          main_space_ = nullptr;          RemoveRememberedSet(main_space_backup_.get());          main_space_backup_.reset(nullptr);  // Deletes the space.          temp_space_ = space::BumpPointerSpace::CreateFromMemMap("Bump pointer space 2",                                                                  mem_map.release());          AddSpace(temp_space_);        }        break;      }      case kCollectorTypeMS:        // Fall through.      case kCollectorTypeCMS: {        if (IsMovingGc(collector_type_)) {          ......          std::unique_ptr<MemMap> mem_map(temp_space_->ReleaseMemMap());          RemoveSpace(temp_space_);          temp_space_ = nullptr;          mem_map->Protect(PROT_READ | PROT_WRITE);          CreateMainMallocSpace(mem_map.get(), kDefaultInitialSize, mem_map->Size(),                                mem_map->Size());          mem_map.release();          // Compact to the main space from the bump pointer space, don't need to swap semispaces.          AddSpace(main_space_);          Compact(main_space_, bump_pointer_space_, kGcCauseCollectorTransition);          mem_map.reset(bump_pointer_space_->ReleaseMemMap());          RemoveSpace(bump_pointer_space_);          bump_pointer_space_ = nullptr;          const char* name = kUseRosAlloc ? kRosAllocSpaceName[1] : kDlMallocSpaceName[1];          ......          main_space_backup_.reset(CreateMallocSpaceFromMemMap(mem_map.get(), kDefaultInitialSize,                                                               mem_map->Size(), mem_map->Size(),                                                               name, true));          ......          mem_map.release();        }        break;      }      default: {        ......        break;      }    ChangeCollector(collector_type);    tl->ResumeAll();    ......  }  

这个函数定义在文件art/runtime/gc/heap.h中。

Heap类的成员函数TransitionCollector首先判断ART运行时当前使用的GC与要切换至的GC是一样的,那么就什么也不用做就返回了。

另一方面,如果ART运行时当前使用的GC与要切换至的GC是不一样的,那么接下来就要将ART运行时当前使用的GC切换至参数collector_type描述的GC了。由于将GC切换是通过执行一次Semi-Space GC或者Generational Semi-Space GC来实现的,因此Heap类的成员函数TransitionCollector在继续往下执行之前,要先调用Heap类的成员函数WaitForGcToCompleteLocked判断当前是否有GC正在执行。如果有的话,就进行等待,直到对应的GC执行完为止。

注意,有可能当前正在执行的GC就是要切换至的GC,在这种情况下,就没有必要将当前使用的GC切换为参数collector_type描述的GC了。此外,只有从当前执行的GC和要切换至的GC不同时为Compacting GC或者Mark-Sweep GC的时候,Heap类的成员函数TransitionCollector才会真正执行切换的操作。换句话说,只有从Compacting GC切换为Mark-Sweep GC或者从Mark-Sweep GC切换为Compacting GC时,Heap类的成员函数TransitionCollector才会真正执行切换的操作。但是,如果这时候ART运行时被禁止执行Compacting GC,即Heap类的成员函数disable_moving_gc_count_不等于0,那么Heap类的成员函数TransitionCollector就需要继续等待,直到ART运行时重新允许执行Compacting GC为止。这是因为接下来的GC切换操作是通过执行一次Compacting GC来实现的。

接下来的GC切换操作是通过调用Heap类的成员函数Compact来实现的。关于Heap类的成员函数Compact,我们在前面 ART运行时Compacting GC为新创建对象分配内存的过程分析一文已经分析过了,它主要通过执行一次Semi-Space GC、Generational Semi-Space GC或者Mark-Compact GC将指定的Source Space上的存活对象移动至指定的Target Space中。如果Source Space与Target Space相同,那么执行的就是Mark-Compact GC,否则就是Semi-Space GC或者Generational Semi-Space GC。由于Heap类的成员函数Compact是需要在Stop-the-world的前提下执行的,因此在调用它的前后,需要执行挂起和恢复除当前正在执行的线程之外的所有ART运行时线程。

Heap类的成员函数TransitionCollector通过switch语句来确定需要传递给成员函数Compact的Source Space和Target Space。通过这个switch语句,我们也可以更清楚看到Heap类的成员函数TransitionCollector允许从什么GC切换至什么GC。

首先,可切换至的GC只有三种,分别为Semi-Space GC、Mark-Sweep GC和Concurrent Mark-Sweep GC。其中,当要切换至的GC为Mark-Sweep GC和Concurrent Mark-Sweep GC时,它们的切换过程是一样的。因此,接下来我们就分两种情况来讨论。

第一种情况是要切换至的GC为Semi-Space GC。根据我们前面的分析,这时候原来的GC只能为Mark-Sweep GC或者Concurrent Mark-Sweep GC。否则的话,就不需要执行GC切换操作。从前面 ART运行时Compacting GC堆创建过程分析一文可以知道,当原来的GC为Mark-Sweep GC或者Concurrent Mark-Sweep GC时,ART运行时堆由Image Space、Zygote Space、Non Moving Space、Main Space、Main Backup Space和Large Object Space组成。这时候要做的是将Main Space上的存活对象移动至一个新创建的Bump Pointer Space上去。也就是说,这时候的Source Space为Main Space,而Target Space为Bump Pointer Space。

Main Space就保存在Heap类的成员变量main_space_中,因此就很容易可以获得。但是这时候是没有现成的Bump Pointer Space的,因此就需要创建一个。由于这时候的Main Backup Space是闲置的,并且当GC切换完毕,它也用不上了,因此我们就可以将Main Backup Space底层使用的内存块获取回来,然后再封装成一个Bump Pointer Space。注意,这时候创建的Bump Pointer Space也是作为GC切换完成后的Semi-Space GC的From Space使用的,因此,除了要将它保存在Heap类的成员变量bump_pointer_space_之外,还要将它添加到ART运行时堆的Space列表中去。

这时候Source Space和Target Space均已准备完毕,因此就可以执行Heap类的成员函数Compact了。执行完毕,还需要做一系列的清理工作,包括:

  1. 删除Main Space及其关联的Remembered Set。从前面ART运行时Compacting GC堆创建过程分析一文可以知道,Heap类的成员变量dlmalloc_space_和rosalloc_space_指向的都是Main Space。既然现在Main Space要被删除了,因此就需要将它们设置为nullptr。
  2. 删除Main Backup Space及其关联的Remembered Set。
  3. 创建一个Bump Pointer Space保存在Heap类的成员变量temp_space_中,作为GC切换完成后的Semi-Space GC的To Space使用。注意,这个To Space底层使用的内存块是来自于原来的Main Space的。

这意味着将从Mark-Sweep GC或者Concurrent Mark-Sweep GC切换为Semi-Space GC之后,原来的Main Space和Main Backup Space就消失了,并且多了两个Bump Pointer Space,其中一个作为From Space,另外一个作为To Space,并且From Space上的对象来自于原来的Main Space的存活对象。

第二种情况是要切换至Mark-Sweep GC或者Concurrent Mark-Sweep GC。根据我们前面的分析,这时候原来的GC只能为Semi-Space GC、Generational Semi-Space GC或者Mark-Compact GC。否则的话,就不需要执行GC切换操作。从前面ART运行时Compacting GC堆创建过程分析一文可以知道,当原来的GC为Semi-Space GC、Generational Semi-Space GC或者Mark-Compact GC时,ART运行时堆由Image Space、Zygote Space、Non Moving Space、Bump Pointer Space、Temp Space和Large Object Space组成。这时候要做的是将Bump Pointer Space上的存活对象移动至一个新创建的Main Space上去。也就是说,这时候的Source Space为Bump Pointer Space,而Target Space为Main Space。

Bump Pointer Space就保存在Heap类的成员变量bump_pointer_space_中,因此就很容易可以获得。但是这时候是没有现成的Main Space的,因此就需要创建一个。由于这时候的Temp Space是闲置的,并且当GC切换完毕,它也用不上了,因此我们就可以将Temp Space底层使用的内存块获取回来,然后再封装成一个Main Space,这是通过调用Heap类的成员函数CreateMainMallocSpace来实现的。注意,Heap类的成员函数CreateMainMallocSpace在执行的过程中,会将创建的Main Space保存在Heap类的成员变量main_space_中,并且它也是作为GC切换完成后的Mark-Sweep GC或者Concurrent Mark-Sweep GC的Main Space使用的,因此,就还要将它添加到ART运行时堆的Space列表中去。      

这时候Source Space和Target Space均已准备完毕,因此就可以执行Heap类的成员函数Compact了。执行完毕,还需要做一系列的清理工作,包括: 

  1. 删除Bump Pointer Space。
  2. 删除Temp Space。
  3. 创建一个Main Backup Space,保存在Heap类的成员变量main_space_backup_中,这是通过调用Heap类的成员函数CreateMallocSpaceFromMemMap实现的,并且该Main Backup Space底层使用的内存块是来自于原来的Bump Pointer Space的。

这样,GC切换的操作就基本执行完毕,最后还需要做的一件事情是调用Heap类的成员函数ChangeCollector记录当前使用的GC,以及相应地调整当前可用的内存分配器。这个函数的具体实现可以参考前面 ART运行时Compacting GC为新创建对象分配内存的过程分析一文。

至此,ART运行时Foreground GC和Background GC的切换过程分析就分析完成了,ART运行时引进的Compacting GC的学习计划也完成了,重新学习可以参考ART运行时Compacting GC简要介绍和学习计划一文。

本文出自罗升阳《老罗的Android之旅》专栏


作者简介:

@罗升阳,CSDN Android开发专栏博客《老罗的Android之旅》作者,发表了一百多篇高质量的Android系统原创性文章,亦是《Android系统源代码情景分析》一书的作者,在Android系统源代码领域有着很深的见解。


CSDN移动将持续为您优选移动开发的精华内容,共同探讨移动开发的技术热点话题,涵盖移动应用、开发工具、移动游戏及引擎、智能硬件、物联网等方方面面,如果您有想分享的技术、观点,可通过电子邮件(tangxy#csdn.net,请把#改成@)投稿。

第一时间掌握最新移动开发相关信息和技术,请关注mobilehub公众微信号(ID: mobilehub)。


黑客怒了:政府花930万美金仅做一款App Email服务迎来“第二春” 未来将更加个性化 贯穿应用开发始终的八大陷阱 微评微软也推智能手表:是追求未来,还只是跟随? Firefox OS今年6月在5国首发 不含美国市场 8086/8088汇编指令手册 下一个被黑客攻击的对象—无线路由器 Windows Blue开始按钮或将回归,你怎么看? Evernote推孵化器 不占股权 基于C++和Lua的移动游戏引擎Leadwerks 3发布 苹果秘密测试iOS 7与iPhone 6 或将6月发布 酷6 CTO 陆坚:请先信任你的程序员 从电信联手i-Free,看运营商渠道的加速整合 “Animory”开发者分享HTML5游戏开发经验 Appflood SDK:连接中国与海外App流量交互平台 Apache Subversion 1.7.9正式发布! 微软IE浏览器5大动向 加速吸引开发者 开源的简繁转换库OpenCC支持Node.js 继Opera之后,Adobe表示将支持Google Blink 提高大型软件项目质量的一些实用型技术分享 谷歌推出Mirror API,开发者可为Google Glass开发应用 无需999,也不要499,99美元Linux超级计算机带回家 微软反击AWS:推出EC2并大幅降价,“价格战”正酣 Operation InVersion:拯救了LinkedIn的大修项目 五步走战略——Avocado在最初几周内迅速扩大30倍 NoSQL产品测评:Cassandra、MongoDB、Couchbase和Aerospike 谷歌眼镜开箱评测:比想象更精致 Pinterest谈实战经验:如何在两年内实现零到数百亿的月访问 初创公司Instart Logic:专为电子出版商和网站站长解决“痛点” 未来即卖芯片又卖服务!Intel收购软件厂商Mashery 继MSN之后,微软又开始整合Skype与Lync服务 介绍几个考中级的网址来噶 CNET网站重新架构,我们的链接也要改了~~ 急,真的急 各位,有谁能告诉我怎样使得程序中每个Show的窗体都以新窗体出现在任务栏。(答对了一定加分!!!!) 能不能获得来访者的计算机名 help me!高手请看! 11号帖子,救命呀,很急,很重要! 怎样在恢复一个被删除的文件时恢复文件全名? 我急!深夜提问!大家看一看 有谁告诉我Microsoft Visual InterDev 6.0如何使用其中的站点管理 如何在Word工具条上加一个按钮 请问系统和上网的速度有关系吗 急需foxpro for win版,哪有??? 请教一下,ado.net里如何返回表里的行数? 如何在HTML页面中使用 Acrobat 的 PDF 阅读器控件 关于一个遗传算法得问题!! 请问一个TSR问题! 关于跨数据库查询的问题 请问在ListBox中可不可以将每一行字符串设置成不同的颜色? vb6.0中如何将dbgrid里的内容添加到数据库里? 请问怎样才能将窗体上的最大化按钮设置成无用,而保留最小化按钮? 各位专家:请问win2000 PRO 下的config.msi目录中的好多以rbf为扩展名的文件是什么文件?有什么用?可以删除吗? ASP.NET中DATAGRILD的烦人处 新手问两个简单的问题??? 想知道如何才能看见前页纸油笔写过后留下的字迹?(散分) 为什么用odbc连接的paradox表不能编辑? 哪位大侠帮看一下代码(关于链表),为何出"invalid type argument of `->'"的错 一个非常非常想从事计算机软件开发的愿望 关于Hook的一个小问题 文档视图结构中无法显示编辑框,怎么办啊??用什么代替啊 十万火急! 通过网络,进行语音聊天的程序。 你了解人工受精吗? 有关“无纸化考试系统”bow api中的常量 关于addslashes的问题 有关“无纸化考试系统”的问题??thanks all,bow 如何删除windowsXP?紧急!!! 【数据结构】考试用的是类pascal还是c语言 我想往服务器中传文件。请问,需要组件吗? 如何写naked function的prolog 和 epilog? LoadIcon(NULL,IDR_QQ) 关于用c写聊天室 帮忙看看是不是session_start()惹的祸 请问谁知道那里有php源码下载的好站,贴几个出来看看 一妹妹姐姐程序员求职,找深圳的工作 初级问题:RichEdit控件的ScrollBy方法自动滚动 推荐一个毕业设计题目,不要太难,我学的流体,用VC来做一个什么东西,推荐一个,谢谢. 今天中午饭后练习时台球斯诺克单杠52分~~~ 二个问题,第二个问题比较难! Windows.Net 3607 简体中文版下载,要的话赶快,不然链接要被删除了. From left to right: Jini, Mini, and Umji 一块含30度角 直角三角形(如图)它的斜边AB=8cm,里面空心三角形DEF的各边与三角形ABC的对应边平行,且各对应边的距离都为1cm,那么三角形DEF的周长为?如图 已知:在三角形ABC中,AB=AC,D为BC的中点,DE垂直于AC于E,F为DE的中点,BE交AD于N,AF交BE于M,求证:A已知:在三角形ABC中,AB=AC,D为BC的中点,DE垂直于AC于E,F为DE的中点,BE交AD于N,AF交BE于M,求证 二元一次方程组怎么转化为一次函数式 把两个含有30°角的直角三角形如图放置,点D在BC上,连接BE、AD,AD的延长线交BE于点F,证明AF⊥BE 在三角形ABC中,sinA:sinB:sinC=2:√6:(√3+1),则三角形最小的内角是 一次函数与二元一次方程组的题已知直线L1,L2的解析式分别y1=k1x+3,y2=k2x-2,其中L1与X轴的交点为A(3/2,0)L1与L2的交点为B(1,a)求L1,L2与X轴围成的三角形面积. 已知:在三角形ABC中,AB=AC,AD为中线,CF∥AB 求证:BP的平方=PE×PF (a-b)(b-a)等于多少,为什么 两条直角边分别为3和4的直角三角形的斜边与斜边上的中线的比为 p为三角形ABC内任意一点,连接AP,BP,CP后存在这一结论PA+PB+PC>1/2(AB+BC+AC),为什么 三角行的一条中线是否将这个三角形分成面积相等的两个三角形?为什么?快啊,我赶时间啊,为什么呢?准 初中快开学日记 三角形abc中 已知sinA*sinB=cos^2 (C/2) 则此三角形的形状是 利用三角形的中线,把三角形分成面积相等的四部分 初中开学周五的日记200字 如图,在三角形ABC中,AB=AC,P是BC上任意一点,连接AP,求证:BP×CP=AB²—AP² 三角形的一条中线能将三角形分成面积相等的两部分吗? 已知直角三角形两直角边上的中线长分别是4和3,求斜边的长(有解题过程) 三角形ABC中,SinA乘SinB=Cos(A/2)的平方,则三角形为何类三角形 命题"三角形一边的中线将这三角形分成面积相等的两部分"的逆命题是? 已知直角三角形两直角边上的中线长分别为4和3,球斜边长 修一条路,每天修五分之十二千米,5天正好修了全长的三分之二,这条路全长多少米? 分别以X2+3X-2=0的两根和两根积为根的一元二次方程昰( ). 已知直角三角形两条直角边上的中线长分别是12和5,求斜边的长 .中线 修一条路,每天修五分之十二千米5天正好修了全长的三分之二,这条路全长多少米 求20篇日记300字 初二数学一次函数与二元一次方程组的关系 二元一次方程组的解是2个一次函数的焦点,有时候题目给你2个一次函数叫你求他的交点,老师说是列方程组,我不知道是列成2个二元一次方程组在解 如图,在△ABC中,AB=AC,AD是边BC上的高,P是AD的中点,延长BP交AC于点F,求证:PB=3PF 给我讲解讲解初二数学的那个一次函数与二元一次方程组好吗?Thank you. 直角三角形的两条直边分别是3和4.斜边为5.求角度 如图,在三角形ABC中,角ACB等于90度p是AC的中点过点A作AD垂直于BP交于点E,交BC的延长线于点D求PE,PB长且角DBE等于30度BE的10 已知在Rt△ABC中,∠C=90°,sinA=3/5,则tanB的值为( ) A、3/4 B、4/3 C、4/5 D、5/4 已知,直角三角形除斜边外的另两条直边长,分别为3和4,求短直边相对的角度是多少? 修一条路,已修的米数占全长的40%,接着再修70米,那么没修的米数是已修的80%,这条路长多少米?算数解 在△ABC中,∠C=90°,sinA=5分之4,则 tanB= 已知一个直角三角形的两条直角边分别为3和4,以它的斜边边所在的直线为轴旋转一周,所得圆锥的体积是请讲一下斜边上的高怎么求, A,B,C,D分别表示3个整数,已知A/B/C=5,A/B-C=12,A-B=84,求A乘B乘C的积是多少? 一条路已修900米,是末修的4/3少300米.这条路总长多少米? 如图在三角形ABC中,AB大于AC,P是AD上一点且AD平分角BAC,求证BP大于CP回答得我懂的话,我回追分的. 一个直角三角形中有一个角是45度,这个三角形一定是等腰直角三角形对吗 一条路,已经修好了3/4,还剩900米,这条路全长多少米? 如图,在三角形ABC中,AD是角BAC的平分线,BP垂直AD,垂足是P,已知AC减AB等于2BP,求证:角ABC等于3角C. 一个两位数,个位数字是十位数字的4倍,把个位数字与十位数字对调,得到的两位数比原来大54,求原数 怎样总结“直角三角形” 在三角形ABC中,AD是角BAC的平分线,BP垂直于AD,垂足是P已知AC-AB=2BP,求证:角ABC=3角C 一个直角梯形 底角是45度,上底是8厘米 下底是14厘米,求面积 谁能帮我总结一些关于直角三角形的知识 如图,在三角形abc中,ad是∠bac的平分线,bp垂直于ad,垂足是p.已知ac-ab等于2bp,求证:∠abc等于3∠c. 一个直角三角形的面积是28平方厘米,一条直角边是8厘米,求另一个直角边 如图,AD是△ABC的中线,P是AD的中点,延长BP交AC于点F.(1)试说明PB=3PF(2)若AC的长为12,求AF的长 已知一个三位数个位上的数字是a,十位上的数字是b百位上的数字为c将这个三位数的个位数字和百位数字对调后得到一个新三位数,则原三位数与新三位数的差为( )求详解好的有分加 一个直角三角形,它的两条边分别是6厘米和8厘米,它的面积是( ). 修路队修一条路,已修了全长的40%,距离中点还有270米,这个修路队修了多少米? 一次函数与二元一次方程组(有题目)一次越野赛跑中,当小明跑了1600米时,小刚跑了1450米,此后两人分别以a米/秒和b米/秒匀速跑,又过100秒时小刚追上小明,200秒时小刚到达终点,300秒时小明到达 在三角形ABC 中“cosA+sinA=cos+sinB”是“C=90°”的__条件过程 甲乙两个修路队同时从两端修一条路,在距离中点20米处相遇.已知乙队修的是全长的40%,求这条路的全长 如图所示,AD是BC边上的中线,如果BC=10厘米,AC=4厘米,AD=3厘米,求三角形ABC的面积 甲乙两人分别从A,B两地同时出发,相向而行,相遇时甲比乙多走了20千米,已知甲的速度为10km/时,5km/是,则A,B两地相距多少KM? 如图,在△ABC中,P是中线AD的中点,连结BP并延长交AC与E,F为BE的中点,求证:AF‖DE 在三角形ABC中,AD为BC边上的高,AB=15厘米,AC=13厘米,AD=12厘米,求三角形的面积
备案号:鲁ICP备13029499号-2 说三道四 www.s3d4.cn 说三道四技术文摘