jdk-sandbox: comparison hotspot/src/share/vm/compiler/compileBroker.cpp

equal deleted inserted replaced

-:c6e0ac3339ac
+:c43940b3cf78
 /**
 * Add a CompileTask to a CompileQueue.
 */
 void CompileQueue::add(CompileTask* task) {
-assert(lock()->owned_by_self(), "must own lock");
+assert(MethodCompileQueue_lock->owned_by_self(), "must own lock");
 task->set_next(NULL);
 task->set_prev(NULL);
 if (_last == NULL) {
 if (LogCompilation && xtty != NULL) {
 task->log_task_queued();
 }
 // Notify CompilerThreads that a task is available.
-lock()->notify_all();
+MethodCompileQueue_lock->notify_all();
 }
 /**
 * Empties compilation queue by putting all compilation tasks onto
 * a freelist. Furthermore, the method wakes up all threads that are
 * waiting on a compilation task to finish. This can happen if background
 * compilation is disabled.
 */
 void CompileQueue::free_all() {
-MutexLocker mu(lock());
+MutexLocker mu(MethodCompileQueue_lock);
 CompileTask* next = _first;
 // Iterate over all tasks in the compile queue
 while (next != NULL) {
 CompileTask* current = next;
 CompileTask::free(current);
 }
 _first = NULL;
 // Wake up all threads that block on the queue.
-lock()->notify_all();
+MethodCompileQueue_lock->notify_all();
 }
 /**
 * Get the next CompileTask from a CompileQueue
 */
 CompileTask* CompileQueue::get() {
-MutexLocker locker(lock());
+MutexLocker locker(MethodCompileQueue_lock);
 // If _first is NULL we have no more compile jobs. There are two reasons for
 // having no compile jobs: First, we compiled everything we wanted. Second,
 // we ran out of code cache so compilation has been disabled. In the latter
 // case we perform code cache sweeps to free memory such that we can re-enable
 // compilation.
 // the stable state, i.e., we do not want to evict methods from the
 // code cache if it is unnecessary.
 // We need a timed wait here, since compiler threads can exit if compilation
 // is disabled forever. We use 5 seconds wait time; the exiting of compiler threads
 // is not critical and we do not want idle compiler threads to wake up too often.
-lock()->wait(!Mutex::_no_safepoint_check_flag, 5*1000);
+MethodCompileQueue_lock->wait(!Mutex::_no_safepoint_check_flag, 5*1000);
 }
 if (CompileBroker::is_compilation_disabled_forever()) {
 return NULL;
 }
 }
 // Clean & deallocate stale compile tasks.
 // Temporarily releases MethodCompileQueue lock.
 void CompileQueue::purge_stale_tasks() {
-assert(lock()->owned_by_self(), "must own lock");
+assert(MethodCompileQueue_lock->owned_by_self(), "must own lock");
 if (_first_stale != NULL) {
 // Stale tasks are purged when MCQ lock is released,
 // but _first_stale updates are protected by MCQ lock.
 // Once task processing starts and MCQ lock is released,
 // other compiler threads can reuse _first_stale.
 CompileTask* head = _first_stale;
 _first_stale = NULL;
 {
-MutexUnlocker ul(lock());
+MutexUnlocker ul(MethodCompileQueue_lock);
 for (CompileTask* task = head; task != NULL; ) {
 CompileTask* next_task = task->next();
 CompileTaskWrapper ctw(task); // Frees the task
 task->set_failure_reason("stale task");
 task = next_task;
 }
 }
 }
 void CompileQueue::remove(CompileTask* task) {
-assert(lock()->owned_by_self(), "must own lock");
+assert(MethodCompileQueue_lock->owned_by_self(), "must own lock");
 if (task->prev() != NULL) {
 task->prev()->set_next(task->next());
 } else {
 // max is the first element
 assert(task == _first, "Sanity");
 }
 --_size;
 }
 void CompileQueue::remove_and_mark_stale(CompileTask* task) {
-assert(lock()->owned_by_self(), "must own lock");
+assert(MethodCompileQueue_lock->owned_by_self(), "must own lock");
 remove(task);
 // Enqueue the task for reclamation (should be done outside MCQ lock)
 task->set_next(_first_stale);
 task->set_prev(NULL);
 _c2_compile_queue->print(st);
 }
 }
 void CompileQueue::print(outputStream* st) {
-assert(lock()->owned_by_self(), "must own lock");
+assert(MethodCompileQueue_lock->owned_by_self(), "must own lock");
 st->print_cr("Contents of %s", name());
 st->print_cr("----------------------------");
 CompileTask* task = _first;
 if (task == NULL) {
 st->print_cr("Empty");
 #if !defined(ZERO) && !defined(SHARK)
 assert(c2_compiler_count > 0 || c1_compiler_count > 0, "No compilers?");
 #endif // !ZERO && !SHARK
 // Initialize the compilation queue
 if (c2_compiler_count > 0) {
-_c2_compile_queue  = new CompileQueue("C2 compile queue",  MethodCompileQueue_lock);
+_c2_compile_queue  = new CompileQueue("C2 compile queue");
 _compilers[1]->set_num_compiler_threads(c2_compiler_count);
 }
 if (c1_compiler_count > 0) {
-_c1_compile_queue  = new CompileQueue("C1 compile queue",  MethodCompileQueue_lock);
+_c1_compile_queue  = new CompileQueue("C1 compile queue");
 _compilers[0]->set_num_compiler_threads(c1_compiler_count);
 }
 int compiler_count = c1_compiler_count + c2_compiler_count;
 bool         blocking = false;
 CompileQueue* queue  = compile_queue(comp_level);
 // Acquire our lock.
 {
-MutexLocker locker(queue->lock(), thread);
+MutexLocker locker(MethodCompileQueue_lock, thread);
 // Make sure the method has not slipped into the queues since
 // last we checked; note that those checks were "fast bail-outs".
 // Here we need to be more careful, see 14012000 below.
 if (compilation_is_in_queue(method)) {

changeset 27696	c43940b3cf78
parent 27642	8c9eff693145
child 27706	3f10f4ac2bd6