*** old/src/share/vm/memory/genMarkSweep.cpp	Fri Oct 17 16:28:44 2014
--- new/src/share/vm/memory/genMarkSweep.cpp	Fri Oct 17 16:28:44 2014

*** 35,44 ****
--- 35,45 ----
  #include "gc_implementation/shared/gcTraceTime.hpp"
  #include "gc_interface/collectedHeap.inline.hpp"
  #include "memory/genCollectedHeap.hpp"
  #include "memory/genMarkSweep.hpp"
  #include "memory/genOopClosures.inline.hpp"
+ #include "memory/generation.hpp"
  #include "memory/generation.inline.hpp"
  #include "memory/modRefBarrierSet.hpp"
  #include "memory/referencePolicy.hpp"
  #include "memory/space.hpp"
  #include "oops/instanceRefKlass.hpp"

*** 50,61 ****
--- 51,61 ----
  #include "runtime/thread.inline.hpp"
  #include "runtime/vmThread.hpp"
  #include "utilities/copy.hpp"
  #include "utilities/events.hpp"
  
- void GenMarkSweep::invoke_at_safepoint(int level, ReferenceProcessor* rp, bool clear_all_softrefs) {
    guarantee(level == 1, "We always collect both old and young.");
    assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint");
  
    GenCollectedHeap* gch = GenCollectedHeap::heap();
  #ifdef ASSERT
    if (gch->collector_policy()->should_clear_all_soft_refs()) {

*** 84,106 ****
--- 84,106 ----
    size_t gch_prev_used = gch->used();
  
    // Capture used regions for each generation that will be
    // subject to collection, so that card table adjustments can
    // be made intelligently (see clear / invalidate further below).
-   gch->save_used_regions(level);
  
    allocate_stacks();
  
-   mark_sweep_phase1(level, clear_all_softrefs);
  
    mark_sweep_phase2();
  
    // Don't add any more derived pointers during phase3
    COMPILER2_PRESENT(assert(DerivedPointerTable::is_active(), "Sanity"));
    COMPILER2_PRESENT(DerivedPointerTable::set_active(false));
  
-   mark_sweep_phase3(level);
  
    mark_sweep_phase4();
  
    restore_marks();
  

*** 108,130 ****
--- 108,125 ----
    // (Should this be in general part?)
    gch->save_marks();
  
    deallocate_stacks();
  
!   // If compaction completely evacuated all generations younger than this
    // one, then we can clear the card table.  Otherwise, we must invalidate
    // it (consider all cards dirty).  In the future, we might consider doing
-   // compaction within generations only, and doing card-table sliding.
    bool all_empty = true;
    for (int i = 0; all_empty && i < level; i++) {
      Generation* g = gch->get_gen(i);
      all_empty = all_empty && gch->get_gen(i)->used() == 0;
    }
!   // If compaction completely evacuated the young generation we can clear
+   // the card table.  Otherwise, we must invalidate it (consider all cards dirty).
+   // In the future, we might consider doing compaction within generations only,
!   // and doing card-table sliding.
    GenRemSet* rs = gch->rem_set();
!   Generation* old_gen = gch->get_gen(level);
!   Generation* old_gen = gch->old_gen();
    // Clear/invalidate below make use of the "prev_used_regions" saved earlier.
!   if (all_empty) {
!   if (gch->young_gen()->used() == 0) {
      // We've evacuated all generations below us.
      rs->clear_into_younger(old_gen);
    } else {
      // Invalidate the cards corresponding to the currently used
      // region and clear those corresponding to the evacuated region.

*** 158,168 ****
--- 153,163 ----
  
  void GenMarkSweep::allocate_stacks() {
    GenCollectedHeap* gch = GenCollectedHeap::heap();
    // Scratch request on behalf of oldest generation; will do no
    // allocation.
!   ScratchBlock* scratch = gch->gather_scratch(gch->_gens[gch->_n_gens-1], 0);
!   ScratchBlock* scratch = gch->gather_scratch(gch->old_gen(), 0);
  
    // $$$ To cut a corner, we'll only use the first scratch block, and then
    // revert to malloc.
    if (scratch != NULL) {
      _preserved_count_max =

*** 186,213 ****
--- 181,207 ----
    _preserved_oop_stack.clear(true);
    _marking_stack.clear();
    _objarray_stack.clear(true);
  }
  
! void GenMarkSweep::mark_sweep_phase1(int level,
                                    bool clear_all_softrefs) {
! void GenMarkSweep::mark_sweep_phase1(bool clear_all_softrefs) {
    // Recursively traverse all live objects and mark them
    GCTraceTime tm("phase 1", PrintGC && Verbose, true, _gc_timer, _gc_tracer->gc_id());
    trace(" 1");
  
    GenCollectedHeap* gch = GenCollectedHeap::heap();
  
    // Because follow_root_closure is created statically, cannot
    // use OopsInGenClosure constructor which takes a generation,
    // as the Universe has not been created when the static constructors
    // are run.
!   follow_root_closure.set_orig_generation(gch->get_gen(level));
!   follow_root_closure.set_orig_generation(gch->old_gen());
  
    // Need new claim bits before marking starts.
    ClassLoaderDataGraph::clear_claimed_marks();
  
!   gch->gen_process_roots(level,
!   gch->gen_process_roots(Generation::Old,
                           false, // Younger gens are not roots.
                           true,  // activate StrongRootsScope
                           SharedHeap::SO_None,
                           GenCollectedHeap::StrongRootsOnly,
                           &follow_root_closure,

*** 272,282 ****
--- 266,276 ----
    void do_generation(Generation* gen) {
      gen->adjust_pointers();
    }
  };
  
- void GenMarkSweep::mark_sweep_phase3(int level) {
    GenCollectedHeap* gch = GenCollectedHeap::heap();
  
    // Adjust the pointers to reflect the new locations
    GCTraceTime tm("phase 3", PrintGC && Verbose, true, _gc_timer, _gc_tracer->gc_id());
    trace("3");

*** 286,298 ****
--- 280,292 ----
  
    // Because the closure below is created statically, we cannot
    // use OopsInGenClosure constructor which takes a generation,
    // as the Universe has not been created when the static constructors
    // are run.
!   adjust_pointer_closure.set_orig_generation(gch->get_gen(level));
!   adjust_pointer_closure.set_orig_generation(gch->old_gen());
  
!   gch->gen_process_roots(level,
!   gch->gen_process_roots(Generation::Old,
                           false, // Younger gens are not roots.
                           true,  // activate StrongRootsScope
                           SharedHeap::SO_AllCodeCache,
                           GenCollectedHeap::StrongAndWeakRoots,
                           &adjust_pointer_closure,