*** old/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp	Thu Sep 19 22:40:48 2013
--- new/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp	Thu Sep 19 22:40:48 2013

*** 50,129 ****
--- 50,83 ----
  PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
  PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
  ParallelScavengeHeap* ParallelScavengeHeap::_psh = NULL;
  GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
  
  static void trace_gen_sizes(const char* const str,
                              size_t og_min, size_t og_max,
                              size_t yg_min, size_t yg_max)
  {
!   if (TracePageSizes) {
      tty->print_cr("%s:  " SIZE_FORMAT "," SIZE_FORMAT " "
                    SIZE_FORMAT "," SIZE_FORMAT " "
                    SIZE_FORMAT,
                    str,
                    og_min / K, og_max / K,
                    yg_min / K, yg_max / K,
                    (og_max + yg_max) / K);
+  size_t ParallelScavengeHeap::intra_heap_alignment() {
+    return GenCollectorPolicy::intra_heap_alignment();
+  }
+ 
!  size_t ParallelScavengeHeap::alignment() {
+    return collector_policy()->min_alignment();
   }
  }
  
  jint ParallelScavengeHeap::initialize() {
    CollectedHeap::pre_initialize();
  
    // Cannot be initialized until after the flags are parsed
    // GenerationSizer flag_parser;
+   // Initialize collector policy
    _collector_policy = new GenerationSizer();
  
    size_t yg_min_size = _collector_policy->min_young_gen_size();
!   size_t yg_max_size = _collector_policy->max_young_gen_size();
    size_t og_min_size = _collector_policy->min_old_gen_size();
    size_t og_max_size = _collector_policy->max_old_gen_size();
  
    trace_gen_sizes("ps heap raw",
                    og_min_size, og_max_size,
                    yg_min_size, yg_max_size);
  
    const size_t og_page_sz = os::page_size_for_region(yg_min_size + og_min_size,
                                                       yg_max_size + og_max_size,
                                                       8);
+   // An alias to save on typing below
!   GenerationSizer * p = _collector_policy;
  
!   const size_t og_align = set_alignment(_old_gen_alignment,   og_page_sz);
    const size_t yg_align = set_alignment(_young_gen_alignment, og_page_sz);
  
    // Update sizes to reflect the selected page size(s).
    //
    // NEEDS_CLEANUP.  The default TwoGenerationCollectorPolicy uses NewRatio; it
    // should check UseAdaptiveSizePolicy.  Changes from generationSizer could
    // move to the common code.
    yg_min_size = align_size_up(yg_min_size, yg_align);
    yg_max_size = align_size_up(yg_max_size, yg_align);
    size_t yg_cur_size =
      align_size_up(_collector_policy->young_gen_size(), yg_align);
    yg_cur_size = MAX2(yg_cur_size, yg_min_size);
  
    og_min_size = align_size_up(og_min_size, og_align);
    // Align old gen size down to preserve specified heap size.
    assert(og_align == yg_align, "sanity");
    og_max_size = align_size_down(og_max_size, og_align);
    og_max_size = MAX2(og_max_size, og_min_size);
    size_t og_cur_size =
      align_size_down(_collector_policy->old_gen_size(), og_align);
    og_cur_size = MAX2(og_cur_size, og_min_size);
  
    trace_gen_sizes("ps heap rnd",
                    og_min_size, og_max_size,
                    yg_min_size, yg_max_size);
  
    const size_t heap_size = og_max_size + yg_max_size;
  
    ReservedSpace heap_rs = Universe::reserve_heap(heap_size, og_align);
!   const size_t heap_size = p->max_heap_byte_size();
  
+   ReservedSpace heap_rs = Universe::reserve_heap(heap_size, p->max_alignment());
    MemTracker::record_virtual_memory_type((address)heap_rs.base(), mtJavaHeap);
  
!   os::trace_page_sizes("ps main", og_min_size + yg_min_size,
!                        og_max_size + yg_max_size, og_page_sz,
!   os::trace_page_sizes("ps main", p->min_heap_byte_size(),
!                        heap_size, alignment(),
                         heap_rs.base(),
                         heap_rs.size());
    if (!heap_rs.is_reserved()) {
      vm_shutdown_during_initialization(
        "Could not reserve enough space for object heap");

*** 140,172 ****
--- 94,120 ----
      vm_shutdown_during_initialization(
        "Could not reserve enough space for barrier set");
      return JNI_ENOMEM;
    }
  
    // Initial young gen size is 4 Mb
    //
    // XXX - what about flag_parser.young_gen_size()?
    const size_t init_young_size = align_size_up(4 * M, yg_align);
    yg_cur_size = MAX2(MIN2(init_young_size, yg_max_size), yg_cur_size);
  
    // Make up the generations
    // Calculate the maximum size that a generation can grow.  This
    // includes growth into the other generation.  Note that the
    // parameter _max_gen_size is kept as the maximum
    // 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;
  
    _gens = new AdjoiningGenerations(heap_rs,
!                                    og_cur_size,
!                                    og_min_size,
!                                    og_max_size,
!                                    yg_cur_size,
!                                    yg_min_size,
!                                    yg_max_size,
!                                    yg_align);
!                                    p->initial_gen1_size(),
!                                    p->min_gen1_size(),
!                                    p->max_gen1_size(),
!                                    p->initial_gen0_size(),
!                                    p->min_gen0_size(),
!                                    p->max_gen0_size(),
!                                    alignment());
  
    _old_gen = _gens->old_gen();
    _young_gen = _gens->young_gen();
  
    const size_t eden_capacity = _young_gen->eden_space()->capacity_in_bytes();