truffle: src/share/vm/gc_implementation/parNew/parNewGeneration.hpp comparison

comparison src/share/vm/gc_implementation/parNew/parNewGeneration.hpp @ 113:ba764ed4b6f2

6420645: Create a vm that uses compressed oops for up to 32gb heapsizes Summary: Compressed oops in instances, arrays, and headers. Code contributors are coleenp, phh, never, swamyv Reviewed-by: jmasa, kamg, acorn, tbell, kvn, rasbold

author	coleenp
date	Sun, 13 Apr 2008 17:43:42 -0400
parents	a61af66fc99e
children	d1605aabd0a1

comparison

equal deleted inserted replaced

-:a49a647afe9a
+:ba764ed4b6f2
 // 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);

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/parNew/parNewGeneration.hpp @ 113:ba764ed4b6f2