src/hotspot/share/gc/parallel/parallelScavengeHeap.cpp

*** 23,32 ****
--- 23,33 ----
   */
  
  #include "precompiled.hpp"
  #include "code/codeCache.hpp"
  #include "gc/parallel/adjoiningGenerations.hpp"
+ #include "gc/parallel/adjoiningGenerationsForHeteroHeap.hpp"
  #include "gc/parallel/adjoiningVirtualSpaces.hpp"
  #include "gc/parallel/gcTaskManager.hpp"
  #include "gc/parallel/generationSizer.hpp"
  #include "gc/parallel/objectStartArray.inline.hpp"
  #include "gc/parallel/parallelScavengeHeap.inline.hpp"
*** 56,66 ****
  PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
  PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
  GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
  
  jint ParallelScavengeHeap::initialize() {
!   const size_t heap_size = _collector_policy->max_heap_byte_size();
  
    ReservedSpace heap_rs = Universe::reserve_heap(heap_size, _collector_policy->heap_alignment());
  
    os::trace_page_sizes("Heap",
                         _collector_policy->min_heap_byte_size(),
--- 57,71 ----
  PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
  PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
  GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
  
  jint ParallelScavengeHeap::initialize() {
!   size_t heap_size = _collector_policy->max_heap_byte_size();
! 
!   if (AllocateOldGenAt != NULL && UseAdaptiveGCBoundary) {
!     heap_size = AdjoiningGenerationsForHeteroHeap::required_reserved_memory(_collector_policy);
!   }
  
    ReservedSpace heap_rs = Universe::reserve_heap(heap_size, _collector_policy->heap_alignment());
  
    os::trace_page_sizes("Heap",
                         _collector_policy->min_heap_byte_size(),
*** 84,94 ****
--- 89,105 ----
    // size of the generation as the boundaries currently stand.
    // _max_gen_size is still used as that value.
    double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0;
    double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0;
  
+   if (AllocateOldGenAt != NULL && UseAdaptiveGCBoundary) {
+     _gens = new AdjoiningGenerationsForHeteroHeap(heap_rs, _collector_policy->max_heap_byte_size() /* total_size_limit */,
+                                                   _collector_policy, generation_alignment());
+   }
+   else {
      _gens = new AdjoiningGenerations(heap_rs, _collector_policy, generation_alignment());
+   }
  
    _old_gen = _gens->old_gen();
    _young_gen = _gens->young_gen();
  
    const size_t eden_capacity = _young_gen->eden_space()->capacity_in_bytes();
*** 102,112 ****
                               max_gc_pause_sec,
                               max_gc_minor_pause_sec,
                               GCTimeRatio
                               );
  
!   assert(!UseAdaptiveGCBoundary ||
      (old_gen()->virtual_space()->high_boundary() ==
       young_gen()->virtual_space()->low_boundary()),
      "Boundaries must meet");
    // initialize the policy counters - 2 collectors, 2 generations
    _gc_policy_counters =
--- 113,123 ----
                               max_gc_pause_sec,
                               max_gc_minor_pause_sec,
                               GCTimeRatio
                               );
  
!   assert(AllocateOldGenAt != NULL || !UseAdaptiveGCBoundary ||
      (old_gen()->virtual_space()->high_boundary() ==
       young_gen()->virtual_space()->low_boundary()),
      "Boundaries must meet");
    // initialize the policy counters - 2 collectors, 2 generations
    _gc_policy_counters =