Hotpot 年轻代GC 源代码分析

图解分析：https://www.cnblogs.com/lqlqlq/p/13912325.html

Hotspot为每一个代 都设置了 各自的 level，也就是等级，年轻代 level 一般为 0， 老年代 level 一般为 1。

在默认的年轻代（/vm/memory/defNewGeneration.cpp）下的实现：

defNewGeneration::collect 有如下重要调用点：

1. gch->gen_process_strong_roots(_level,
                                true,  // Process younger gens, if any,
                                       // as strong roots.
                                true,  // activate StrongRootsScope
                                false, // not collecting perm generation.
                                SharedHeap::SO_AllClasses,
                                &fsc_with_no_gc_barrier,
                                true,   // walk *all* scavengable nmethods
                                &fsc_with_gc_barrier);

  // "evacuate followers".
2. evacuate_followers.do_void();

3. rp->process_discovered_references(&is_alive, &keep_alive, &evacuate_followers,
                                    NULL);

重要的闭包：FastScanClosure :: do_oop_work ：将 接收的参数是 T * (其实也就是 oop *) , 是指向 oop 的指针

oop 本身就是 oopDesc * 的缩写，也就是 java 在 C++ 层面的对象的指针，所以修改 T* 指向的内存单元，就可以修改这个内存单元指向的oop，相当于修改对象的引用类型变量

入参的 do_barriar 如果为 true，则在处理 T* 时，需要将该引用指向的地址的卡表，设置为 younggen_card (未知作用)

 概述：

1.gen_process_strong_roots 

处理根节点引用的oop，包括Java方法堆栈，JNI方法堆栈，符号表等引用的对象

2.evacuate_followers

负责将 从年轻代promote到老年代的对象，使用 入参为 true 的 FastScanClosure 作为参数，调用这些对象的 oop_iterate, 也就是遍历这些对象的引用类型 

也就是遍历这些对象的引用类型变量，如果年龄到阈值，则promote到老年代，否则复制到 to 区

3.处理Java提供的各种非强引用

1.gen_process_strong_roots 

该方法的实现在 GenCollectedHeap 中

// General strong roots.

  if (!do_code_roots) {
    SharedHeap::process_strong_roots(activate_scope, collecting_perm_gen, so,
                                     not_older_gens, NULL, older_gens);
  } else {
    bool do_code_marking = (activate_scope || nmethod::oops_do_marking_is_active());
    CodeBlobToOopClosure code_roots(not_older_gens, /*do_marking=*/ do_code_marking);
    SharedHeap::process_strong_roots(activate_scope, collecting_perm_gen, so,
                                     not_older_gens, &code_roots, older_gens);
  }

  if (younger_gens_as_roots) {
    if (!_gen_process_strong_tasks->is_task_claimed(GCH_PS_younger_gens)) {
      for (int i = 0; i < level; i++) {
        not_older_gens->set_generation(_gens[i]);
        _gens[i]->oop_iterate(not_older_gens);
      }
      not_older_gens->reset_generation();
    }
  }
  // When collection is parallel, all threads get to cooperate to do
  // older-gen scanning.
  for (int i = level+1; i < _n_gens; i++) {
    older_gens->set_generation(_gens[i]);
    rem_set()->younger_refs_iterate(_gens[i], older_gens);
    older_gens->reset_generation();
  }
    younger_refs_in_space_iterate
  _gen_process_strong_tasks->all_tasks_completed();

最重要的三个点是

1.process_strong_roots　　对根节点使用某个特定的 closure，上文中是 not_older_gens，即不是针对老年代的 Clsoure

2.第一个循环的 oop_iterate　　倘若是老年代调用 gen_process_strong_roots ，则level是1，也就是会调用循环中的本 oop_iterate , 年轻代的level 是 0，所以不会调用。本oop_iterate是使用 not_older_gens 的 closure 去处理oop的引用类型

3.第二个循环的 younger_refs_iterate　　是用来遍历脏卡表的，上面用的是 older_gens 去遍历脏卡表对应区域引用的对象

1.process_strong_roots

void SharedHeap::process_strong_roots(bool activate_scope,
                                      bool collecting_perm_gen,
                                      ScanningOption so,
                                      OopClosure* roots,
                                      CodeBlobClosure* code_roots,
                                      OopsInGenClosure* perm_blk) {
  StrongRootsScope srs(this, activate_scope);
  // General strong roots.
  assert(_strong_roots_parity != 0, "must have called prologue code");
  if (!_process_strong_tasks->is_task_claimed(SH_PS_Universe_oops_do)) {
    Universe::oops_do(roots); 　　//1
    ReferenceProcessor::oops_do(roots);
    // Consider perm-gen discovered lists to be strong.
    perm_gen()->ref_processor()->weak_oops_do(roots);
  }
  // Global (strong) JNI handles
  if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do))
    JNIHandles::oops_do(roots);　　//2
  // All threads execute this; the individual threads are task groups.
  if (ParallelGCThreads > 0) {
    Threads::possibly_parallel_oops_do(roots, code_roots);
  } else {
    Threads::oops_do(roots, code_roots);　　//3
  }
  if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do))
    ObjectSynchronizer::oops_do(roots);　　//4
  if (!_process_strong_tasks->is_task_claimed(SH_PS_FlatProfiler_oops_do))
    FlatProfiler::oops_do(roots);　　//5
  if (!_process_strong_tasks->is_task_claimed(SH_PS_Management_oops_do))
    Management::oops_do(roots);　　//6
  if (!_process_strong_tasks->is_task_claimed(SH_PS_jvmti_oops_do))
    JvmtiExport::oops_do(roots);　　//7

  if (!_process_strong_tasks->is_task_claimed(SH_PS_SystemDictionary_oops_do)) {
    if (so & SO_AllClasses) {
      SystemDictionary::oops_do(roots);　　//8
    } else if (so & SO_SystemClasses) {
      SystemDictionary::always_strong_oops_do(roots);
    }
  }

  if (!_process_strong_tasks->is_task_claimed(SH_PS_StringTable_oops_do)) {
    if (so & SO_Strings || (!collecting_perm_gen && !JavaObjectsInPerm)) {
      StringTable::oops_do(roots);　　//9
    }
    if (JavaObjectsInPerm) {
      // Verify the string table contents are in the perm gen
      NOT_PRODUCT(StringTable::oops_do(&assert_is_perm_closure));
    }
  }

  if (!_process_strong_tasks->is_task_claimed(SH_PS_CodeCache_oops_do)) {
    if (so & SO_CodeCache) {
      // (Currently, CMSCollector uses this to do intermediate-strength collections.)
      assert(collecting_perm_gen, "scanning all of code cache");
      assert(code_roots != NULL, "must supply closure for code cache");
      if (code_roots != NULL) {
        CodeCache::blobs_do(code_roots);
      }
    } else if (so & (SO_SystemClasses|SO_AllClasses)) {
      if (!collecting_perm_gen) {
        // If we are collecting from class statics, but we are not going to
        // visit all of the CodeCache, collect from the non-perm roots if any.
        // This makes the code cache function temporarily as a source of strong
        // roots for oops, until the next major collection.
        //
        // If collecting_perm_gen is true, we require that this phase will call
        // CodeCache::do_unloading.  This will kill off nmethods with expired
        // weak references, such as stale invokedynamic targets.
        CodeCache::scavenge_root_nmethods_do(code_roots);
      }
    }
    // Verify that the code cache contents are not subject to
    // movement by a scavenging collection.
    DEBUG_ONLY(CodeBlobToOopClosure assert_code_is_non_scavengable(&assert_is_non_scavengable_closure, /*do_marking=*/ false));
    DEBUG_ONLY(CodeCache::asserted_non_scavengable_nmethods_do(&assert_code_is_non_scavengable));
  }

  if (!collecting_perm_gen) {
    // All threads perform this; coordination is handled internally.

    rem_set()->younger_refs_iterate(perm_gen(), perm_blk);
  }
  _process_strong_tasks->all_tasks_completed();
}

1.Universe ： 某些全局量持有的对象引用，比如：

　　 

  mirror 是某个类静态遍历的集合，比如说有 Class A { static int a ; int b; static A c;}

  那么这个类的 mirror 就是 一个 12 字节的 oop，其实只是 12 字节的连续内存 区块。其中存放了 4 字节的 int 类型变量，8字节的指针类型变量

  上面这些 mirror 都是 java 提供的基础类型 的类 的 静态变量集合。每个集合 在 jvm 的 C++ 层面称为 oopDesc 。 oop 是 oopDesc * ， 即oopDesc 的指针

   f 在当前语境下是 FastScanClosure，并且 处理 oop * 后不会把这个 oop * 的卡置为 youngercard，FastScanClosure的处理逻辑如下：把 oop * 的值引用的 oopDesc 复制到 to 或 老年代（年龄够了的情况下）

   注意 oop * 是 oopDesc 的指针的指针，也就是 oop * 是一个8字节的内存地址，指向的地方的8字节处是 oop，也是 一个 8 字节的内存地址，指向的地方是一个 oopDesc

   所以通过 f 修改 oop * 指向的内存区域，就是在修改某个 C++ 层面的类或结构（此处是 Universe）的指针域

   

关于 f ：do_oop 会调用 do_oop_work

下面的逻辑是，如果对象没有被复制到别的地方，也就是 forwardee 指针是空，就尝试把对象复制到 to 区，或 promote 到 老年代

针对年轻代的 _gc_barrier 是 false

do_barrier 会把 oop * 在卡表中对应字节（一个字节代表一张卡）的值设置为youngercard

 

每种 generation 都有自己 copy_to_survivor_space 的实现，以下是默认年轻代的实现

oop DefNewGeneration::copy_to_survivor_space(oop old) {
  assert(is_in_reserved(old) && !old->is_forwarded(),
         "shouldn't be scavenging this oop");
  size_t s = old->size();
  oop obj = NULL;

  // Try allocating obj in to-space (unless too old)
  if (old->age() < tenuring_threshold()) {
    obj = (oop) to()->allocate(s);
  }

  // Otherwise try allocating obj tenured
  if (obj == NULL) {
    obj = _next_gen->promote(old, s);
    if (obj == NULL) {
      handle_promotion_failure(old);
      return old;
    }
  } else {
    // Prefetch beyond obj
    const intx interval = PrefetchCopyIntervalInBytes;
    Prefetch::write(obj, interval);

    // Copy obj
    Copy::aligned_disjoint_words((HeapWord*)old, (HeapWord*)obj, s);

    // Increment age if obj still in new generation
    obj->incr_age();
    age_table()->add(obj, s);
  }

  // Done, insert forward pointer to obj in this header
  old->forward_to(obj);

  return obj;
}

上面的1~9就是所谓的根节点，其中比较重要的几个是 Universe，java线程栈中的oop ，jni持有的 oop

3.younger_refs_iterate

这个方法会遍历脏卡表项对应内存区的对象的引用，而且是针对老年代的。

比如老年代有个对象 A 持有一个引用 b 指向 对象 B，实际上， A 和 B 都是 oopDesc， b 在 c ++ 层面就是一个 oop，也就是 oopDesc *

当 A 的 b 引用 指向了其他对象，也就是 A.b = xxx ， 那么 A 的 b 此时会指向 xxx 这个 oopDesc，此时 A 对应内存区的卡 就是一片脏卡，对应的卡表项就是脏的。

所以要用 f 处理 A， 在处理之前会把 A 的内存对应卡表项置位干净卡。f 的入参是 A 的各个 oop 的地址

比如 A 在 C ++ 层面的内存表示是：