hotspot/src/share/vm/gc/g1/g1EvacFailure.cpp
changeset 46590 cd27cb97655c
parent 46258 d26ebd7e2f10
child 46634 f0fb6b3c47d2
equal deleted inserted replaced
46589:f1c04490ded1 46590:cd27cb97655c
    33 #include "gc/g1/g1_globals.hpp"
    33 #include "gc/g1/g1_globals.hpp"
    34 #include "gc/g1/heapRegion.hpp"
    34 #include "gc/g1/heapRegion.hpp"
    35 #include "gc/g1/heapRegionRemSet.hpp"
    35 #include "gc/g1/heapRegionRemSet.hpp"
    36 #include "gc/shared/preservedMarks.inline.hpp"
    36 #include "gc/shared/preservedMarks.inline.hpp"
    37 
    37 
    38 class UpdateRSetDeferred : public OopsInHeapRegionClosure {
    38 class UpdateRSetDeferred : public ExtendedOopClosure {
    39 private:
    39 private:
    40   G1CollectedHeap* _g1;
    40   G1CollectedHeap* _g1;
    41   DirtyCardQueue *_dcq;
    41   DirtyCardQueue *_dcq;
    42   G1SATBCardTableModRefBS* _ct_bs;
    42   G1SATBCardTableModRefBS* _ct_bs;
       
    43   HeapRegion* _from;
    43 
    44 
    44 public:
    45 public:
    45   UpdateRSetDeferred(DirtyCardQueue* dcq) :
    46   UpdateRSetDeferred(DirtyCardQueue* dcq) :
    46     _g1(G1CollectedHeap::heap()), _ct_bs(_g1->g1_barrier_set()), _dcq(dcq) {}
    47     _g1(G1CollectedHeap::heap()), _ct_bs(_g1->g1_barrier_set()), _dcq(dcq), _from(NULL) {}
    47 
    48 
    48   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
    49   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
    49   virtual void do_oop(      oop* p) { do_oop_work(p); }
    50   virtual void do_oop(      oop* p) { do_oop_work(p); }
    50   template <class T> void do_oop_work(T* p) {
    51   template <class T> void do_oop_work(T* p) {
    51     assert(_from->is_in_reserved(p), "paranoia");
    52     assert(_from->is_in_reserved(p), "paranoia");
    56       if (_ct_bs->mark_card_deferred(card_index)) {
    57       if (_ct_bs->mark_card_deferred(card_index)) {
    57         _dcq->enqueue((jbyte*)_ct_bs->byte_for_index(card_index));
    58         _dcq->enqueue((jbyte*)_ct_bs->byte_for_index(card_index));
    58       }
    59       }
    59     }
    60     }
    60   }
    61   }
       
    62 
       
    63   void set_region(HeapRegion* from) { _from = from; }
    61 };
    64 };
    62 
    65 
    63 class RemoveSelfForwardPtrObjClosure: public ObjectClosure {
    66 class RemoveSelfForwardPtrObjClosure: public ObjectClosure {
    64 private:
    67 private:
    65   G1CollectedHeap* _g1;
    68   G1CollectedHeap* _g1;
    66   G1ConcurrentMark* _cm;
    69   G1ConcurrentMark* _cm;
    67   HeapRegion* _hr;
    70   HeapRegion* _hr;
    68   size_t _marked_bytes;
    71   size_t _marked_bytes;
    69   OopsInHeapRegionClosure *_update_rset_cl;
    72   UpdateRSetDeferred* _update_rset_cl;
    70   bool _during_initial_mark;
    73   bool _during_initial_mark;
    71   uint _worker_id;
    74   uint _worker_id;
    72   HeapWord* _last_forwarded_object_end;
    75   HeapWord* _last_forwarded_object_end;
    73 
    76 
    74 public:
    77 public:
    75   RemoveSelfForwardPtrObjClosure(HeapRegion* hr,
    78   RemoveSelfForwardPtrObjClosure(HeapRegion* hr,
    76                                  OopsInHeapRegionClosure* update_rset_cl,
    79                                  UpdateRSetDeferred* update_rset_cl,
    77                                  bool during_initial_mark,
    80                                  bool during_initial_mark,
    78                                  uint worker_id) :
    81                                  uint worker_id) :
    79     _g1(G1CollectedHeap::heap()),
    82     _g1(G1CollectedHeap::heap()),
    80     _cm(_g1->concurrent_mark()),
    83     _cm(_g1->concurrent_mark()),
    81     _hr(hr),
    84     _hr(hr),