hotspot/src/share/vm/gc/g1/heapRegion.cpp
changeset 46518 69f8479862a2
parent 46517 14de3e5151a9
child 46520 de5cb3eed39b
equal deleted inserted replaced
46517:14de3e5151a9 46518:69f8479862a2
    45 int    HeapRegion::LogOfHRGrainBytes = 0;
    45 int    HeapRegion::LogOfHRGrainBytes = 0;
    46 int    HeapRegion::LogOfHRGrainWords = 0;
    46 int    HeapRegion::LogOfHRGrainWords = 0;
    47 size_t HeapRegion::GrainBytes        = 0;
    47 size_t HeapRegion::GrainBytes        = 0;
    48 size_t HeapRegion::GrainWords        = 0;
    48 size_t HeapRegion::GrainWords        = 0;
    49 size_t HeapRegion::CardsPerRegion    = 0;
    49 size_t HeapRegion::CardsPerRegion    = 0;
    50 
       
    51 HeapRegionDCTOC::HeapRegionDCTOC(G1CollectedHeap* g1,
       
    52                                  HeapRegion* hr,
       
    53                                  G1ParPushHeapRSClosure* cl,
       
    54                                  CardTableModRefBS::PrecisionStyle precision) :
       
    55   DirtyCardToOopClosure(hr, cl, precision, NULL),
       
    56   _hr(hr), _rs_scan(cl), _g1(g1) { }
       
    57 
       
    58 void HeapRegionDCTOC::walk_mem_region(MemRegion mr,
       
    59                                       HeapWord* bottom,
       
    60                                       HeapWord* top) {
       
    61   G1CollectedHeap* g1h = _g1;
       
    62   size_t oop_size;
       
    63   HeapWord* cur = bottom;
       
    64 
       
    65   // Start filtering what we add to the remembered set. If the object is
       
    66   // not considered dead, either because it is marked (in the mark bitmap)
       
    67   // or it was allocated after marking finished, then we add it. Otherwise
       
    68   // we can safely ignore the object.
       
    69   if (!g1h->is_obj_dead(oop(cur))) {
       
    70     oop_size = oop(cur)->oop_iterate_size(_rs_scan, mr);
       
    71   } else {
       
    72     oop_size = _hr->block_size(cur);
       
    73   }
       
    74 
       
    75   cur += oop_size;
       
    76 
       
    77   if (cur < top) {
       
    78     oop cur_oop = oop(cur);
       
    79     oop_size = _hr->block_size(cur);
       
    80     HeapWord* next_obj = cur + oop_size;
       
    81     while (next_obj < top) {
       
    82       // Keep filtering the remembered set.
       
    83       if (!g1h->is_obj_dead(cur_oop)) {
       
    84         // Bottom lies entirely below top, so we can call the
       
    85         // non-memRegion version of oop_iterate below.
       
    86         cur_oop->oop_iterate(_rs_scan);
       
    87       }
       
    88       cur = next_obj;
       
    89       cur_oop = oop(cur);
       
    90       oop_size = _hr->block_size(cur);
       
    91       next_obj = cur + oop_size;
       
    92     }
       
    93 
       
    94     // Last object. Need to do dead-obj filtering here too.
       
    95     if (!g1h->is_obj_dead(oop(cur))) {
       
    96       oop(cur)->oop_iterate(_rs_scan, mr);
       
    97     }
       
    98   }
       
    99 }
       
   100 
    50 
   101 size_t HeapRegion::max_region_size() {
    51 size_t HeapRegion::max_region_size() {
   102   return HeapRegionBounds::max_size();
    52   return HeapRegionBounds::max_size();
   103 }
    53 }
   104 
    54