Print this page 
rev 2585 : [mq]: g1-reference-processing
Split Close
Expand all
Collapse all
          --- old/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp
          +++ new/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp
↓ open down ↓ 54 lines elided ↑ open up ↑ 
  55   55  
  56   56    SharedHeap* sh = SharedHeap::heap();
  57   57  #ifdef ASSERT
  58   58    if (sh->collector_policy()->should_clear_all_soft_refs()) {
  59   59      assert(clear_all_softrefs, "Policy should have been checked earler");
  60   60    }
  61   61  #endif
  62   62    // hook up weak ref data so it can be used during Mark-Sweep
  63   63    assert(GenMarkSweep::ref_processor() == NULL, "no stomping");
  64   64    assert(rp != NULL, "should be non-NULL");
       65 +  assert(rp == G1CollectedHeap::heap()->ref_processor_stw(), "Precondition");
       66 +
  65   67    GenMarkSweep::_ref_processor = rp;
  66   68    rp->setup_policy(clear_all_softrefs);
  67   69  
  68   70    // When collecting the permanent generation methodOops may be moving,
  69   71    // so we either have to flush all bcp data or convert it into bci.
  70   72    CodeCache::gc_prologue();
  71   73    Threads::gc_prologue();
  72   74  
  73   75    // Increment the invocation count for the permanent generation, since it is
  74   76    // implicitly collected whenever we do a full mark sweep collection.
↓ open down ↓ 57 lines elided ↑ open up ↑ 
 132  134  
 133  135    sh->process_strong_roots(true,  // activeate StrongRootsScope
 134  136                             true,  // Collecting permanent generation.
 135  137                             SharedHeap::SO_SystemClasses,
 136  138                             &GenMarkSweep::follow_root_closure,
 137  139                             &GenMarkSweep::follow_code_root_closure,
 138  140                             &GenMarkSweep::follow_root_closure);
 139  141  
 140  142    // Process reference objects found during marking
 141  143    ReferenceProcessor* rp = GenMarkSweep::ref_processor();
      144 +  assert(rp == G1CollectedHeap::heap()->ref_processor_stw(), "Sanity");
      145 +
 142  146    rp->setup_policy(clear_all_softrefs);
 143  147    rp->process_discovered_references(&GenMarkSweep::is_alive,
 144  148                                      &GenMarkSweep::keep_alive,
 145  149                                      &GenMarkSweep::follow_stack_closure,
 146  150                                      NULL);
 147  151  
 148  152    // Follow system dictionary roots and unload classes
 149  153    bool purged_class = SystemDictionary::do_unloading(&GenMarkSweep::is_alive);
 150  154    assert(GenMarkSweep::_marking_stack.is_empty(),
 151  155           "stack should be empty by now");
↓ open down ↓ 7 lines elided ↑ open up ↑ 
 159  163  
 160  164    // Update subklass/sibling/implementor links of live klasses
 161  165    GenMarkSweep::follow_weak_klass_links();
 162  166    assert(GenMarkSweep::_marking_stack.is_empty(),
 163  167           "stack should be empty by now");
 164  168  
 165  169    // Visit memoized MDO's and clear any unmarked weak refs
 166  170    GenMarkSweep::follow_mdo_weak_refs();
 167  171    assert(GenMarkSweep::_marking_stack.is_empty(), "just drained");
 168  172  
 169      -
 170  173    // Visit interned string tables and delete unmarked oops
 171  174    StringTable::unlink(&GenMarkSweep::is_alive);
 172  175    // Clean up unreferenced symbols in symbol table.
 173  176    SymbolTable::unlink();
 174  177  
 175  178    assert(GenMarkSweep::_marking_stack.is_empty(),
 176  179           "stack should be empty by now");
 177  180  
 178  181    if (VerifyDuringGC) {
 179  182      HandleMark hm;  // handle scope
↓ open down ↓ 159 lines elided ↑ open up ↑ 
 339  342  
 340  343    SharedHeap* sh = SharedHeap::heap();
 341  344  
 342  345    sh->process_strong_roots(true,  // activate StrongRootsScope
 343  346                             true,  // Collecting permanent generation.
 344  347                             SharedHeap::SO_AllClasses,
 345  348                             &GenMarkSweep::adjust_root_pointer_closure,
 346  349                             NULL,  // do not touch code cache here
 347  350                             &GenMarkSweep::adjust_pointer_closure);
 348  351  
 349      -  g1h->ref_processor()->weak_oops_do(&GenMarkSweep::adjust_root_pointer_closure);
      352 +  assert(GenMarkSweep::ref_processor() == g1h->ref_processor_stw(), "Sanity");
      353 +  g1h->ref_processor_stw()->weak_oops_do(&GenMarkSweep::adjust_root_pointer_closure);
      354 +
      355 +  // The discovered lists of the CM reference processor were emptied
      356 +  // at the start of the Full GC but if the sentinel ref was moved
      357 +  // as part of this Full GC then they need to be adjusted to point
      358 +  // to the sentinel ref's new location.
      359 +  g1h->ref_processor_cm()->weak_oops_do(&GenMarkSweep::adjust_root_pointer_closure);
 350  360  
 351  361    // Now adjust pointers in remaining weak roots.  (All of which should
 352  362    // have been cleared if they pointed to non-surviving objects.)
 353  363    g1h->g1_process_weak_roots(&GenMarkSweep::adjust_root_pointer_closure,
 354  364                               &GenMarkSweep::adjust_pointer_closure);
 355  365  
 356  366    GenMarkSweep::adjust_marks();
 357  367  
 358  368    G1AdjustPointersClosure blk;
 359  369    g1h->heap_region_iterate(&blk);
↓ open down ↓ 54 lines elided ↑ open up ↑ 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX