Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp @ 375:81cd571500b0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6725697: par compact - rename class ChunkData to RegionData Reviewed-by: iveresov, tonyp
author jcoomes
date Tue, 30 Sep 2008 12:20:22 -0700
parents a61af66fc99e
children ad8c8ca4ab0f
comparison
equal deleted inserted replaced
374:a4b729f5b611 375:81cd571500b0
50 50
51 class ParCompactionManager : public CHeapObj { 51 class ParCompactionManager : public CHeapObj {
52 friend class ParallelTaskTerminator; 52 friend class ParallelTaskTerminator;
53 friend class ParMarkBitMap; 53 friend class ParMarkBitMap;
54 friend class PSParallelCompact; 54 friend class PSParallelCompact;
55 friend class StealChunkCompactionTask; 55 friend class StealRegionCompactionTask;
56 friend class UpdateAndFillClosure; 56 friend class UpdateAndFillClosure;
57 friend class RefProcTaskExecutor; 57 friend class RefProcTaskExecutor;
58 58
59 public: 59 public:
60 60
70 NotValid 70 NotValid
71 }; 71 };
72 // ------------------------ End don't putback if not needed 72 // ------------------------ End don't putback if not needed
73 73
74 private: 74 private:
75 static ParCompactionManager** _manager_array; 75 static ParCompactionManager** _manager_array;
76 static OopTaskQueueSet* _stack_array; 76 static OopTaskQueueSet* _stack_array;
77 static ObjectStartArray* _start_array; 77 static ObjectStartArray* _start_array;
78 static ChunkTaskQueueSet* _chunk_array; 78 static RegionTaskQueueSet* _region_array;
79 static PSOldGen* _old_gen; 79 static PSOldGen* _old_gen;
80 80
81 OopTaskQueue _marking_stack; 81 OopTaskQueue _marking_stack;
82 GrowableArray<oop>* _overflow_stack; 82 GrowableArray<oop>* _overflow_stack;
83 // Is there a way to reuse the _marking_stack for the 83 // Is there a way to reuse the _marking_stack for the
84 // saving empty chunks? For now just create a different 84 // saving empty regions? For now just create a different
85 // type of TaskQueue. 85 // type of TaskQueue.
86 86
87 #ifdef USE_ChunkTaskQueueWithOverflow 87 #ifdef USE_RegionTaskQueueWithOverflow
88 ChunkTaskQueueWithOverflow _chunk_stack; 88 RegionTaskQueueWithOverflow _region_stack;
89 #else 89 #else
90 ChunkTaskQueue _chunk_stack; 90 RegionTaskQueue _region_stack;
91 GrowableArray<size_t>* _chunk_overflow_stack; 91 GrowableArray<size_t>* _region_overflow_stack;
92 #endif 92 #endif
93 93
94 #if 1 // does this happen enough to need a per thread stack? 94 #if 1 // does this happen enough to need a per thread stack?
95 GrowableArray<Klass*>* _revisit_klass_stack; 95 GrowableArray<Klass*>* _revisit_klass_stack;
96 #endif 96 #endif
97 static ParMarkBitMap* _mark_bitmap; 97 static ParMarkBitMap* _mark_bitmap;
98 98
99 Action _action; 99 Action _action;
100 100
101 static PSOldGen* old_gen() { return _old_gen; } 101 static PSOldGen* old_gen() { return _old_gen; }
102 static ObjectStartArray* start_array() { return _start_array; } 102 static ObjectStartArray* start_array() { return _start_array; }
103 static OopTaskQueueSet* stack_array() { return _stack_array; } 103 static OopTaskQueueSet* stack_array() { return _stack_array; }
104 104
105 static void initialize(ParMarkBitMap* mbm); 105 static void initialize(ParMarkBitMap* mbm);
106 106
107 protected: 107 protected:
108 // Array of tasks. Needed by the ParallelTaskTerminator. 108 // Array of tasks. Needed by the ParallelTaskTerminator.
109 static ChunkTaskQueueSet* chunk_array() { return _chunk_array; } 109 static RegionTaskQueueSet* region_array() { return _region_array; }
110 110 OopTaskQueue* marking_stack() { return &_marking_stack; }
111 OopTaskQueue* marking_stack() { return &_marking_stack; } 111 GrowableArray<oop>* overflow_stack() { return _overflow_stack; }
112 GrowableArray<oop>* overflow_stack() { return _overflow_stack; } 112 #ifdef USE_RegionTaskQueueWithOverflow
113 #ifdef USE_ChunkTaskQueueWithOverflow 113 RegionTaskQueueWithOverflow* region_stack() { return &_region_stack; }
114 ChunkTaskQueueWithOverflow* chunk_stack() { return &_chunk_stack; }
115 #else 114 #else
116 ChunkTaskQueue* chunk_stack() { return &_chunk_stack; } 115 RegionTaskQueue* region_stack() { return &_region_stack; }
117 GrowableArray<size_t>* chunk_overflow_stack() { return _chunk_overflow_stack; } 116 GrowableArray<size_t>* region_overflow_stack() {
117 return _region_overflow_stack;
118 }
118 #endif 119 #endif
119 120
120 // Pushes onto the marking stack. If the marking stack is full, 121 // Pushes onto the marking stack. If the marking stack is full,
121 // pushes onto the overflow stack. 122 // pushes onto the overflow stack.
122 void stack_push(oop obj); 123 void stack_push(oop obj);
123 // Do not implement an equivalent stack_pop. Deal with the 124 // Do not implement an equivalent stack_pop. Deal with the
124 // marking stack and overflow stack directly. 125 // marking stack and overflow stack directly.
125 126
126 // Pushes onto the chunk stack. If the chunk stack is full, 127 // Pushes onto the region stack. If the region stack is full,
127 // pushes onto the chunk overflow stack. 128 // pushes onto the region overflow stack.
128 void chunk_stack_push(size_t chunk_index); 129 void region_stack_push(size_t region_index);
129 public: 130 public:
130 131
131 Action action() { return _action; } 132 Action action() { return _action; }
132 void set_action(Action v) { _action = v; } 133 void set_action(Action v) { _action = v; }
133 134
158 // Save oop for later processing. Must not fail. 159 // Save oop for later processing. Must not fail.
159 void save_for_scanning(oop m); 160 void save_for_scanning(oop m);
160 // Get a oop for scanning. If returns null, no oop were found. 161 // Get a oop for scanning. If returns null, no oop were found.
161 oop retrieve_for_scanning(); 162 oop retrieve_for_scanning();
162 163
163 // Save chunk for later processing. Must not fail. 164 // Save region for later processing. Must not fail.
164 void save_for_processing(size_t chunk_index); 165 void save_for_processing(size_t region_index);
165 // Get a chunk for processing. If returns null, no chunk were found. 166 // Get a region for processing. If returns null, no region were found.
166 bool retrieve_for_processing(size_t& chunk_index); 167 bool retrieve_for_processing(size_t& region_index);
167 168
168 // Access function for compaction managers 169 // Access function for compaction managers
169 static ParCompactionManager* gc_thread_compaction_manager(int index); 170 static ParCompactionManager* gc_thread_compaction_manager(int index);
170 171
171 static bool steal(int queue_num, int* seed, Task& t) { 172 static bool steal(int queue_num, int* seed, Task& t) {
172 return stack_array()->steal(queue_num, seed, t); 173 return stack_array()->steal(queue_num, seed, t);
173 } 174 }
174 175
175 static bool steal(int queue_num, int* seed, ChunkTask& t) { 176 static bool steal(int queue_num, int* seed, RegionTask& t) {
176 return chunk_array()->steal(queue_num, seed, t); 177 return region_array()->steal(queue_num, seed, t);
177 } 178 }
178 179
179 // Process tasks remaining on any stack 180 // Process tasks remaining on any stack
180 void drain_marking_stacks(OopClosure *blk); 181 void drain_marking_stacks(OopClosure *blk);
181 182
182 // Process tasks remaining on any stack 183 // Process tasks remaining on any stack
183 void drain_chunk_stacks(); 184 void drain_region_stacks();
184 185
185 // Process tasks remaining on any stack 186 // Process tasks remaining on any stack
186 void drain_chunk_overflow_stack(); 187 void drain_region_overflow_stack();
187 188
188 // Debugging support 189 // Debugging support
189 #ifdef ASSERT 190 #ifdef ASSERT
190 bool stacks_have_been_allocated(); 191 bool stacks_have_been_allocated();
191 #endif 192 #endif