--- a/hotspot/src/share/vm/gc_implementation/g1/g1OopClosures.hpp Fri Jul 10 16:01:20 2009 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1OopClosures.hpp Tue Jul 14 15:40:39 2009 -0700
@@ -42,18 +42,6 @@
virtual void set_region(HeapRegion* from) { _from = from; }
};
-
-class G1ScanAndBalanceClosure : public OopClosure {
- G1CollectedHeap* _g1;
- static int _nq;
-public:
- G1ScanAndBalanceClosure(G1CollectedHeap* g1) : _g1(g1) { }
- inline void do_oop_nv(oop* p);
- inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
- virtual void do_oop(oop* p);
- virtual void do_oop(narrowOop* p) { guarantee(false, "NYI"); }
-};
-
class G1ParClosureSuper : public OopsInHeapRegionClosure {
protected:
G1CollectedHeap* _g1;
@@ -69,34 +57,32 @@
public:
G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
G1ParClosureSuper(g1, par_scan_state) { }
- void do_oop_nv(oop* p); // should be made inline
- inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
+ template <class T> void do_oop_nv(T* p);
virtual void do_oop(oop* p) { do_oop_nv(p); }
virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
};
-#define G1_PARTIAL_ARRAY_MASK 1
+#define G1_PARTIAL_ARRAY_MASK 0x2
-inline bool has_partial_array_mask(oop* ref) {
- return (intptr_t) ref & G1_PARTIAL_ARRAY_MASK;
+template <class T> inline bool has_partial_array_mask(T* ref) {
+ return ((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) == G1_PARTIAL_ARRAY_MASK;
}
-inline oop* set_partial_array_mask(oop obj) {
- return (oop*) ((intptr_t) obj | G1_PARTIAL_ARRAY_MASK);
+template <class T> inline T* set_partial_array_mask(T obj) {
+ assert(((uintptr_t)obj & G1_PARTIAL_ARRAY_MASK) == 0, "Information loss!");
+ return (T*) ((uintptr_t)obj | G1_PARTIAL_ARRAY_MASK);
}
-inline oop clear_partial_array_mask(oop* ref) {
- return oop((intptr_t) ref & ~G1_PARTIAL_ARRAY_MASK);
+template <class T> inline oop clear_partial_array_mask(T* ref) {
+ return oop((intptr_t)ref & ~G1_PARTIAL_ARRAY_MASK);
}
class G1ParScanPartialArrayClosure : public G1ParClosureSuper {
G1ParScanClosure _scanner;
- template <class T> void process_array_chunk(oop obj, int start, int end);
public:
G1ParScanPartialArrayClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
G1ParClosureSuper(g1, par_scan_state), _scanner(g1, par_scan_state) { }
- void do_oop_nv(oop* p);
- void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
+ template <class T> void do_oop_nv(T* p);
virtual void do_oop(oop* p) { do_oop_nv(p); }
virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
};
@@ -105,7 +91,7 @@
class G1ParCopyHelper : public G1ParClosureSuper {
G1ParScanClosure *_scanner;
protected:
- void mark_forwardee(oop* p);
+ template <class T> void mark_forwardee(T* p);
oop copy_to_survivor_space(oop obj);
public:
G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state,
@@ -117,36 +103,35 @@
bool do_mark_forwardee, bool skip_cset_test>
class G1ParCopyClosure : public G1ParCopyHelper {
G1ParScanClosure _scanner;
- void do_oop_work(oop* p);
- void do_oop_work(narrowOop* p) { guarantee(false, "NYI"); }
+ template <class T> void do_oop_work(T* p);
public:
G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
_scanner(g1, par_scan_state), G1ParCopyHelper(g1, par_scan_state, &_scanner) { }
- inline void do_oop_nv(oop* p) {
+ template <class T> void do_oop_nv(T* p) {
do_oop_work(p);
if (do_mark_forwardee)
mark_forwardee(p);
}
- inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
virtual void do_oop(oop* p) { do_oop_nv(p); }
virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
};
typedef G1ParCopyClosure<false, G1BarrierNone, false, false> G1ParScanExtRootClosure;
typedef G1ParCopyClosure<true, G1BarrierNone, false, false> G1ParScanPermClosure;
+typedef G1ParCopyClosure<false, G1BarrierRS, false, false> G1ParScanHeapRSClosure;
typedef G1ParCopyClosure<false, G1BarrierNone, true, false> G1ParScanAndMarkExtRootClosure;
typedef G1ParCopyClosure<true, G1BarrierNone, true, false> G1ParScanAndMarkPermClosure;
-typedef G1ParCopyClosure<false, G1BarrierRS, false, false> G1ParScanHeapRSClosure;
typedef G1ParCopyClosure<false, G1BarrierRS, true, false> G1ParScanAndMarkHeapRSClosure;
// This is the only case when we set skip_cset_test. Basically, this
// closure is (should?) only be called directly while we're draining
// the overflow and task queues. In that case we know that the
// reference in question points into the collection set, otherwise we
-// would not have pushed it on the queue.
-typedef G1ParCopyClosure<false, G1BarrierEvac, false, true> G1ParScanHeapEvacClosure;
+// would not have pushed it on the queue. The following is defined in
+// g1_specialized_oop_closures.hpp.
+// typedef G1ParCopyClosure<false, G1BarrierEvac, false, true> G1ParScanHeapEvacClosure;
// We need a separate closure to handle references during evacuation
-// failure processing, as it cannot asume that the reference already
- // points to the collection set (like G1ParScanHeapEvacClosure does).
+// failure processing, as we cannot asume that the reference already
+// points into the collection set (like G1ParScanHeapEvacClosure does).
typedef G1ParCopyClosure<false, G1BarrierEvac, false, false> G1ParScanHeapEvacFailureClosure;
class FilterIntoCSClosure: public OopClosure {
@@ -158,10 +143,9 @@
G1CollectedHeap* g1, OopClosure* oc) :
_dcto_cl(dcto_cl), _g1(g1), _oc(oc)
{}
- inline void do_oop_nv(oop* p);
- inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
- virtual void do_oop(oop* p);
- virtual void do_oop(narrowOop* p) { guarantee(false, "NYI"); }
+ template <class T> void do_oop_nv(T* p);
+ virtual void do_oop(oop* p) { do_oop_nv(p); }
+ virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
bool apply_to_weak_ref_discovered_field() { return true; }
bool do_header() { return false; }
};
@@ -174,10 +158,9 @@
OopsInHeapRegionClosure* oc) :
_g1(g1), _oc(oc)
{}
- inline void do_oop_nv(oop* p);
- inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
- virtual void do_oop(oop* p);
- virtual void do_oop(narrowOop* p) { guarantee(false, "NYI"); }
+ template <class T> void do_oop_nv(T* p);
+ virtual void do_oop(oop* p) { do_oop_nv(p); }
+ virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
bool apply_to_weak_ref_discovered_field() { return true; }
bool do_header() { return false; }
void set_region(HeapRegion* from) {
@@ -195,10 +178,9 @@
ConcurrentMark* cm)
: _g1(g1), _oc(oc), _cm(cm) { }
- inline void do_oop_nv(oop* p);
- inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
- virtual void do_oop(oop* p);
- virtual void do_oop(narrowOop* p) { guarantee(false, "NYI"); }
+ template <class T> void do_oop_nv(T* p);
+ virtual void do_oop(oop* p) { do_oop_nv(p); }
+ virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
bool apply_to_weak_ref_discovered_field() { return true; }
bool do_header() { return false; }
void set_region(HeapRegion* from) {
@@ -213,10 +195,9 @@
int _out_of_region;
public:
FilterOutOfRegionClosure(HeapRegion* r, OopClosure* oc);
- inline void do_oop_nv(oop* p);
- inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
- virtual void do_oop(oop* p);
- virtual void do_oop(narrowOop* p) { guarantee(false, "NYI"); }
+ template <class T> void do_oop_nv(T* p);
+ virtual void do_oop(oop* p) { do_oop_nv(p); }
+ virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
bool apply_to_weak_ref_discovered_field() { return true; }
bool do_header() { return false; }
int out_of_region() { return _out_of_region; }