179 if (UsePerfData) _perf_compile_type->set_value((jlong)compile_type);
180 }
181
182 int compile_type() { return _compile_type; }
183
184 PerfCounter* time_counter() { return _perf_time; }
185 PerfCounter* compile_counter() { return _perf_compiles; }
186 };
187
188 // CompileQueue
189 //
190 // A list of CompileTasks.
191 class CompileQueue : public CHeapObj<mtCompiler> {
192 private:
193 const char* _name;
194 Monitor* _lock;
195
196 CompileTask* _first;
197 CompileTask* _last;
198
199 int _size;
200 public:
201 CompileQueue(const char* name, Monitor* lock) {
202 _name = name;
203 _lock = lock;
204 _first = NULL;
205 _last = NULL;
206 _size = 0;
207 }
208
209 const char* name() const { return _name; }
210 Monitor* lock() const { return _lock; }
211
212 void add(CompileTask* task);
213 void remove(CompileTask* task);
214 CompileTask* first() { return _first; }
215 CompileTask* last() { return _last; }
216
217 CompileTask* get();
218
219 bool is_empty() const { return _first == NULL; }
220 int size() const { return _size; }
221
222 // Redefine Classes support
223 void mark_on_stack();
224 void free_all();
225 NOT_PRODUCT (void print();)
226
227 ~CompileQueue() {
228 assert (is_empty(), " Compile Queue must be empty");
229 }
230 };
231
232 // CompileTaskWrapper
233 //
234 // Assign this task to the current thread. Deallocate the task
235 // when the compilation is complete.
236 class CompileTaskWrapper : StackObj {
237 public:
238 CompileTaskWrapper(CompileTask* task);
239 ~CompileTaskWrapper();
240 };
241
|
179 if (UsePerfData) _perf_compile_type->set_value((jlong)compile_type);
180 }
181
182 int compile_type() { return _compile_type; }
183
184 PerfCounter* time_counter() { return _perf_time; }
185 PerfCounter* compile_counter() { return _perf_compiles; }
186 };
187
188 // CompileQueue
189 //
190 // A list of CompileTasks.
191 class CompileQueue : public CHeapObj<mtCompiler> {
192 private:
193 const char* _name;
194 Monitor* _lock;
195
196 CompileTask* _first;
197 CompileTask* _last;
198
199 CompileTask* _first_stale;
200
201 int _size;
202
203 void purge_stale_tasks();
204 public:
205 CompileQueue(const char* name, Monitor* lock) {
206 _name = name;
207 _lock = lock;
208 _first = NULL;
209 _last = NULL;
210 _size = 0;
211 _first_stale = NULL;
212 }
213
214 const char* name() const { return _name; }
215 Monitor* lock() const { return _lock; }
216
217 void add(CompileTask* task);
218 void remove(CompileTask* task);
219 void remove_and_mark_stale(CompileTask* task);
220 CompileTask* first() { return _first; }
221 CompileTask* last() { return _last; }
222
223 CompileTask* get();
224
225 bool is_empty() const { return _first == NULL; }
226 int size() const { return _size; }
227
228
229 // Redefine Classes support
230 void mark_on_stack();
231 void free_all();
232 NOT_PRODUCT (void print();)
233
234 ~CompileQueue() {
235 assert (is_empty(), " Compile Queue must be empty");
236 }
237 };
238
239 // CompileTaskWrapper
240 //
241 // Assign this task to the current thread. Deallocate the task
242 // when the compilation is complete.
243 class CompileTaskWrapper : StackObj {
244 public:
245 CompileTaskWrapper(CompileTask* task);
246 ~CompileTaskWrapper();
247 };
248
|