专栏首页立权的博客Hotpot 年轻代GC 源代码分析

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 ++ 层面的内存表示是:

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • centos-ubuntu互通时遇到网络配置陷阱

    需求:在centos上开启docker跑mysql,在ubuntu上开启docker跑tomcat

    执生
  • Java:手写线程安全LRU缓存X探究影响命中率的因素

    最近遇到一个需求,需要频繁访问数据库,但是访问的内容只是 id + 名称 这样的简单键值对。

    执生
  • 栈论 : 递归与栈式访问,如何用栈实现所有递归操作(幼儿园题目篇,题目3)

    这一题,乍一看和之前题目间明显的区别是什么呢?没错,聪明的你可能已经想到了,子函数要和父函数通信了,子函数需要告诉父函数a或b在不在自己这里,自己有没有找到a或...

    执生
  • java开发_闹钟

    ==========================================================

    Hongten
  • 你真的会写mybatis.xml吗?养成好习惯写养眼好用的xml

    我们使用mybatis无非就是进行一些增删改查的操作,但是简单的增删改查想要写好却大有门道。

    我的小熊不见了丶
  • 聊聊BinaryLogClient的connect

    mysql-binlog-connector-java-0.20.1/src/main/java/com/github/shyiko/mysql/binlog/...

    codecraft
  • 聊聊BinaryLogClient的connect

    mysql-binlog-connector-java-0.20.1/src/main/java/com/github/shyiko/mysql/binlog/...

    codecraft
  • Springsecurity-oauth2之/oauth/token的处理

        Springsecurity-oauth2的版本是2.2.1.RELEASE.

    克虏伯
  • cyclegan 学习深度信息的效果

    每个视频的深度基础真实存储在16位灰度PNG图像中: 深度值是从z缓冲区获得的相机平面距理(https://en.wikipedia.org/wiki/Z-b...

    用户1908973
  • Python代码需要缩进吗

    Python最具特色的是用缩进来标明成块的代码。我下面以if选择结构来举例。if后面跟随条件,如果条件成立,则执行归属于if的一个代码块。

    砸漏

扫码关注云+社区

领取腾讯云代金券