jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.hpp

equal deleted inserted replaced

-:f4edb0d9f109
+:21d113ecbf6a
 // It would be better if these types could be kept local to the .cpp file,
 // but they must be here to allow ParScanClosure::do_oop_work to be defined
 // in genOopClosures.inline.hpp.
 typedef OopTaskQueue    ObjToScanQueue;
 typedef OopTaskQueueSet ObjToScanQueueSet;
 // Enable this to get push/pop/steal stats.
 const int PAR_STATS_ENABLED = 0;
 class ParKeepAliveClosure: public DefNewGeneration::KeepAliveClosure {
+private:
 ParScanWeakRefClosure* _par_cl;
+protected:
+template <class T> void do_oop_work(T* p);
 public:
 ParKeepAliveClosure(ParScanWeakRefClosure* cl);
-void do_oop(oop* p);
+virtual void do_oop(oop* p);
+virtual void do_oop(narrowOop* p);
 };
 // The state needed by thread performing parallel young-gen collection.
 class ParScanThreadState {
 friend class ParScanThreadStateSet;
+private:
 ObjToScanQueue *_work_queue;
 ParGCAllocBuffer _to_space_alloc_buffer;
 ParScanWithoutBarrierClosure         _to_space_closure; // scan_without_gc_barrier
 ParScanThreadState(Space* to_space_, ParNewGeneration* gen_,
 Generation* old_gen_, int thread_num_,
 ObjToScanQueueSet* work_queue_set_, size_t desired_plab_sz_,
 ParallelTaskTerminator& term_);
 public:
 ageTable* age_table() {return &_ageTable;}
 ObjToScanQueue* work_queue() { return _work_queue; }
 ParGCAllocBuffer* to_space_alloc_buffer() {
 double term_time() { return _term_time; }
 double elapsed() {
 return os::elapsedTime() - _start;
 }
 };
 class ParNewGenTask: public AbstractGangTask {
-ParNewGeneration* _gen;
+private:
-Generation* _next_gen;
+ParNewGeneration*            _gen;
-HeapWord* _young_old_boundary;
+Generation*                  _next_gen;
+HeapWord*                    _young_old_boundary;
 class ParScanThreadStateSet* _state_set;
 public:
 ParNewGenTask(ParNewGeneration*      gen,
 Generation*            next_gen,
 void work(int i);
 };
 class KeepAliveClosure: public DefNewGeneration::KeepAliveClosure {
+protected:
+template <class T> void do_oop_work(T* p);
 public:
 KeepAliveClosure(ScanWeakRefClosure* cl);
-void do_oop(oop* p);
+virtual void do_oop(oop* p);
+virtual void do_oop(narrowOop* p);
 };
 class EvacuateFollowersClosureGeneral: public VoidClosure {
-GenCollectedHeap* _gch;
+private:
-int _level;
+GenCollectedHeap* _gch;
-OopsInGenClosure* _scan_cur_or_nonheap;
+int               _level;
-OopsInGenClosure* _scan_older;
+OopsInGenClosure* _scan_cur_or_nonheap;
-public:
+OopsInGenClosure* _scan_older;
-EvacuateFollowersClosureGeneral(GenCollectedHeap* gch, int level,
+public:
-OopsInGenClosure* cur,
+EvacuateFollowersClosureGeneral(GenCollectedHeap* gch, int level,
-OopsInGenClosure* older);
+OopsInGenClosure* cur,
-void do_void();
+OopsInGenClosure* older);
+virtual void do_void();
 };
 // Closure for scanning ParNewGeneration.
 // Same as ScanClosure, except does parallel GC barrier.
 class ScanClosureWithParBarrier: public ScanClosure {
-public:
+protected:
+template <class T> void do_oop_work(T* p);
+public:
 ScanClosureWithParBarrier(ParNewGeneration* g, bool gc_barrier);
-void do_oop(oop* p);
+virtual void do_oop(oop* p);
+virtual void do_oop(narrowOop* p);
 };
 // Implements AbstractRefProcTaskExecutor for ParNew.
 class ParNewRefProcTaskExecutor: public AbstractRefProcTaskExecutor {
-public:
+private:
+ParNewGeneration&      _generation;
+ParScanThreadStateSet& _state_set;
+public:
 ParNewRefProcTaskExecutor(ParNewGeneration& generation,
 ParScanThreadStateSet& state_set)
 : _generation(generation), _state_set(state_set)
 { }
 // Executes a task using worker threads.
 virtual void execute(ProcessTask& task);
 virtual void execute(EnqueueTask& task);
 // Switch to single threaded mode.
 virtual void set_single_threaded_mode();
-private:
-ParNewGeneration&      _generation;
-ParScanThreadStateSet& _state_set;
 };
 // A Generation that does parallel young-gen collection.
 friend class ParNewGenTask;
 friend class ParNewRefProcTask;
 friend class ParNewRefProcTaskExecutor;
 friend class ParScanThreadStateSet;
+private:
 // XXX use a global constant instead of 64!
 struct ObjToScanQueuePadded {
 ObjToScanQueue work_queue;
 char pad[64 - sizeof(ObjToScanQueue)];  // prevent false sharing
 };
 // Adjust the tenuring threshold.  See the implementation for
 // the details of the policy.
 virtual void adjust_desired_tenuring_threshold();
 public:
 ParNewGeneration(ReservedSpace rs, size_t initial_byte_size, int level);
 ~ParNewGeneration() {
 for (uint i = 0; i < ParallelGCThreads; i++)
 delete _task_queues->queue(i);

changeset 360	21d113ecbf6a
parent 1	489c9b5090e2
child 670	ddf3e9583f2f