Hotspot源码解析-第十七章-虚拟机万物创建(二)

发布时间:2024年01月10日

17.2 GC策略初始化

这一步主要就是确定分代(新生代和老年代)信息、即将分配的Java堆内存的大小,以及针对这些信息的校验

17.2.1 collectorPolicy.cpp&ollectorPolicy.hpp

17.2.1.1 initialize_all
virtual void initialize_all() {
    // 针对内存分配的大小值做设置和校验
    CollectorPolicy::initialize_all();
    // 创建并分配新生代和老年代对象的内存
    initialize_generations();
  }

// 对应 CollectorPolicy::initialize_all() 函数
virtual void initialize_all() {
    // 父类中,这是一个纯虚函数(相当于Java里面的抽象函数),只能去子类中找实现,这个函数就是计算即将要创建和分配的内存的对齐值
    initialize_alignments(); 
    // 对 Java堆大小值的判断和设置
    initialize_flags();
    // 对以上两步产生的大小做参数检验
    initialize_size_info();
  }

// 对应 initialize_alignments() 函数
void MarkSweepPolicy::initialize_alignments() {
  /*
  * 设置空间和分代对齐(C/C++中分配内存时都需要按着一定大小对齐),对齐的目的就是为了提高内存访问效率,CPU读取内存时不是一个一个字节读的,而是一批字节来读,比如4字节、8字节和64字节等,具体读多少,与CPU的架构、型号、年份有关,现在的机器基本是读64字节(缓存行大小),如果没按对齐规则对齐,就可能读取到的内存是“半包”,这就需要CPU多次读取,效率较低。这里按Generation::GenGrain对齐,这个值定义在generattion.hpp的枚举中
  enum SomePublicConstants {
    LogOfGenGrain = 16 ARM32_ONLY(+1),  // 最终得出结果16
    GenGrain = 1 << LogOfGenGrain    // 1 << 16  ==> 2^16 ==> 64 * k
  };
  通过上面的定义可知,_space_alignment和_gen_alignment的值最终就是64*k,也就是按这个值来对齐
  */  
  _space_alignment = _gen_alignment = (uintx)Generation::GenGrain;
  _heap_alignment = compute_heap_alignment();   // 计算堆空间的对齐值,最终=512 * 4K
}
// 对应 compute_heap_alignment() 函数
size_t CollectorPolicy::compute_heap_alignment() {
  // 这里就是按CardTable卡表的大小乘以页大小来对齐的,查看源码可以得出,卡表大小card_size=1 << 9 ==> 2^9 ==> 512,最终对齐大小等于:512 * 4K(page_size)
  size_t alignment = GenRemSet::max_alignment_constraint(GenRemSet::CardTable);

  if (UseLargePages) { // 用大页,这种情况,忽略
      alignment = lcm(os::large_page_size(), alignment);
  }

  return alignment;
}

// 对应 initialize_flags() 函数
void CollectorPolicy::initialize_flags() {
  // 检验上一步计算的各空间对齐值不为0  
  assert(_space_alignment != 0, "Space alignment not set up properly");
  assert(_heap_alignment != 0, "Heap alignment not set up properly");
  assert(_heap_alignment >= _space_alignment,
         err_msg("heap_alignment: " SIZE_FORMAT " less than space_alignment: " SIZE_FORMAT,
                 _heap_alignment, _space_alignment));
  assert(_heap_alignment % _space_alignment == 0,
         err_msg("heap_alignment: " SIZE_FORMAT " not aligned by space_alignment: " SIZE_FORMAT,
                 _heap_alignment, _space_alignment));
  // 检查空间大小限制,InitialHeapSize和MaxHeapSize的值在`章节8.1.1.2`中做了解析,有兴趣的,再回头看看
  if (FLAG_IS_CMDLINE(MaxHeapSize)) {
    if (FLAG_IS_CMDLINE(InitialHeapSize) && InitialHeapSize > MaxHeapSize) {
      vm_exit_during_initialization("Initial heap size set to a larger value than the maximum heap size");
    }
    if (_min_heap_byte_size != 0 && MaxHeapSize < _min_heap_byte_size) {
      vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified");
    }
    _max_heap_size_cmdline = true;
  }

  // 初始堆大小不能小于1M
  if (InitialHeapSize < M) {
    vm_exit_during_initialization("Too small initial heap");
  }
  // 最小堆大小不能小于1M
  if (_min_heap_byte_size < M) {
    vm_exit_during_initialization("Too small minimum heap");
  }

  // 用 用户从 -Xmx and -Xms 设置的值,并通过_heap_alignment的大小对齐,得到最小堆大小、初始堆大小、最大堆大小
  _min_heap_byte_size = align_size_up(_min_heap_byte_size, _heap_alignment);
  uintx aligned_initial_heap_size = align_size_up(InitialHeapSize, _heap_alignment);
  uintx aligned_max_heap_size = align_size_up(MaxHeapSize, _heap_alignment);

  // 值改变了,就写回对应的flags中,这块的设置看`章节8.1.1.3`
  if (aligned_initial_heap_size != InitialHeapSize) {
    FLAG_SET_ERGO(uintx, InitialHeapSize, aligned_initial_heap_size);
  }
  if (aligned_max_heap_size != MaxHeapSize) {
    FLAG_SET_ERGO(uintx, MaxHeapSize, aligned_max_heap_size);
  }

  if (FLAG_IS_CMDLINE(InitialHeapSize) && _min_heap_byte_size != 0 &&
      InitialHeapSize < _min_heap_byte_size) {
    vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified");
  }
  if (!FLAG_IS_DEFAULT(InitialHeapSize) && InitialHeapSize > MaxHeapSize) {
    FLAG_SET_ERGO(uintx, MaxHeapSize, InitialHeapSize);
  } else if (!FLAG_IS_DEFAULT(MaxHeapSize) && InitialHeapSize > MaxHeapSize) {
    FLAG_SET_ERGO(uintx, InitialHeapSize, MaxHeapSize);
    if (InitialHeapSize < _min_heap_byte_size) {
      _min_heap_byte_size = InitialHeapSize;
    }
  }

  _initial_heap_byte_size = InitialHeapSize;
  _max_heap_byte_size = MaxHeapSize;

  FLAG_SET_ERGO(uintx, MinHeapDeltaBytes, align_size_up(MinHeapDeltaBytes, _space_alignment));

  DEBUG_ONLY(CollectorPolicy::assert_flags();)
}

// 分代初始化,默认分成两代(年轻和老年代)
void MarkSweepPolicy::initialize_generations() {
  // 通过malloc() 库函数分配内存,并得到一个大小为2的分代数组,分别存放年轻代和老年代GenerationSpec,number_of_generations() 这个函数里面写死了返回2
  _generations = NEW_C_HEAP_ARRAY3(GenerationSpecPtr, number_of_generations(), mtGC, CURRENT_PC,
    AllocFailStrategy::RETURN_NULL);
  if (_generations == NULL) {
    vm_exit_during_initialization("Unable to allocate gen spec");
  }

  if (UseParNewGC) {
    _generations[0] = new GenerationSpec(Generation::ParNew, _initial_gen0_size, _max_gen0_size);
  } else {
    // 串行GC的,走这条线,创建新生代GenerationSpec对象,对象内存都是通过malloc()来分配的
    _generations[0] = new GenerationSpec(Generation::DefNew, _initial_gen0_size, _max_gen0_size);
  }
  // 创建老年代GenerationSpec对象
  _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_gen1_size, _max_gen1_size);

  if (_generations[0] == NULL || _generations[1] == NULL) {
    vm_exit_during_initialization("Unable to allocate gen spec");
  }
}


17.3 Java堆空间创建

17.3.1 genCollectedHeap.cpp

17.3.1.1 GenCollectedHeap::GenCollectedHeap
GenCollectedHeap::GenCollectedHeap(GenCollectorPolicy *policy) :
  SharedHeap(policy),  // 先调用父类SharedHeap构造函数,看`章节17.3.1.2`
  _gen_policy(policy), // _gen_policy 赋值为 policy
// 创建一个子任务管理类,管理所有子任务,并赋值给_process_strong_tasks
  _process_strong_tasks(new SubTasksDone(GCH_PS_NumElements)),
  _full_collections_completed(0) // _full_collections_completed 赋值
{
  assert(policy != NULL, "Sanity check");
}

17.3.1.2 sharedHeap.cpp->SharedHeap::SharedHeap
SharedHeap::SharedHeap(CollectorPolicy* policy_) :
  CollectedHeap(), // 继续调用上级构造函数
  _collector_policy(policy_),  // 以下为赋值操作
  _rem_set(NULL),
  _strong_roots_parity(0),
  _workers(NULL)
{
  _sh = this;  // ch is static, should be set only once.
  // 由于我们讨论的是串行的GC收集器,所以下面这个逻辑不会走,忽略
  if ((UseParNewGC ||
      (UseConcMarkSweepGC && (CMSParallelInitialMarkEnabled ||
                              CMSParallelRemarkEnabled)) ||
       UseG1GC) &&
      ParallelGCThreads > 0) {
    _workers = new FlexibleWorkGang("Parallel GC Threads", ParallelGCThreads,
                            /* are_GC_task_threads */true,
                            /* are_ConcurrentGC_threads */false);
    if (_workers == NULL) {
      vm_exit_during_initialization("Failed necessary allocation.");
    } else {
      _workers->initialize_workers();
    }
  }
}
17.3.1.3 collectedHeap.cpp->CollectedHeap::CollectedHeap
CollectedHeap::CollectedHeap() : _n_par_threads(0)  // 赋值
{
  // 下面这几步就是得到最大数组的大小,用于后期判断一个对象最大占用内存大小的限制
  const size_t max_len = size_t(arrayOopDesc::max_array_length(T_INT));
  const size_t elements_per_word = HeapWordSize / sizeof(jint);
  _filler_array_max_size = align_object_size(filler_array_hdr_size() +
                                             max_len / elements_per_word);
  // 以下都是赋初始值操作
  _barrier_set = NULL;
  _is_gc_active = false;
  _total_collections = _total_full_collections = 0;
  _gc_cause = _gc_lastcause = GCCause::_no_gc;
  NOT_PRODUCT(_promotion_failure_alot_count = 0;)
  NOT_PRODUCT(_promotion_failure_alot_gc_number = 0;)

  if (UsePerfData) {  // 有关性能数据的,先忽略,以后有机会再单开一个专题来讲
    EXCEPTION_MARK;

    // create the gc cause jvmstat counters
    _perf_gc_cause = PerfDataManager::create_string_variable(SUN_GC, "cause",
                             80, GCCause::to_string(_gc_cause), CHECK);

    _perf_gc_lastcause =
                PerfDataManager::create_string_variable(SUN_GC, "lastCause",
                             80, GCCause::to_string(_gc_lastcause), CHECK);
  }
  _defer_initial_card_mark = false; // strengthened by subclass in pre_initialize() below.
  // gc日志事件
  if (LogEvents) {
    _gc_heap_log = new GCHeapLog();
  } else {
    _gc_heap_log = NULL;
  }
}
文章来源:https://blog.csdn.net/zhang527294844/article/details/135510161
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。