jdk-sandbox: comparison src/hotspot/share/runtime/vmThread.cpp

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 }
 }
 //-----------------------------------------------------------------
 // High-level interface
-bool VMOperationQueue::add(VM_Operation *op) {
+void VMOperationQueue::add(VM_Operation *op) {
 HOTSPOT_VMOPS_REQUEST(
 (char *) op->name(), strlen(op->name()),
 op->evaluation_mode());
 // Encapsulates VM queue policy. Currently, that
 // only involves putting them on the right list
-if (op->evaluate_at_safepoint()) {
+queue_add_back(op->evaluate_at_safepoint() ? SafepointPriority : MediumPriority, op);
-queue_add_back(SafepointPriority, op);
-return true;
-}
-queue_add_back(MediumPriority, op);
-return true;
 }
 VM_Operation* VMOperationQueue::remove_next() {
 // Assuming VMOperation queue is two-level priority queue. If there are
 // more than two priorities, we need a different scheduling algorithm.
 // Notify the VMThread that the last non-daemon JavaThread has terminated,
 // and wait until operation is performed.
 void VMThread::wait_for_vm_thread_exit() {
 assert(Thread::current()->is_Java_thread(), "Should be a JavaThread");
 assert(((JavaThread*)Thread::current())->is_terminated(), "Should be terminated");
-{ MutexLocker mu(VMOperationQueue_lock, Mutex::_no_safepoint_check_flag);
+{ MonitorLocker mu(VMOperationQueue_lock, Mutex::_no_safepoint_check_flag);
 _should_terminate = true;
-VMOperationQueue_lock->notify();
+mu.notify();
 }
 // Note: VM thread leaves at Safepoint. We are not stopped by Safepoint
 // because this thread has been removed from the threads list. But anything
 // that could get blocked by Safepoint should not be used after this point,
 event->set_blocking(!is_concurrent);
 // Only write caller thread information for non-concurrent vm operations.
 // For concurrent vm operations, the thread id is set to 0 indicating thread is unknown.
 // This is because the caller thread could have exited already.
 event->set_caller(is_concurrent ? 0 : JFR_THREAD_ID(op->calling_thread()));
-event->set_safepointId(evaluate_at_safepoint ? SafepointSynchronize::safepoint_counter() : 0);
+event->set_safepointId(evaluate_at_safepoint ? SafepointSynchronize::safepoint_id() : 0);
 event->commit();
 }
 void VMThread::evaluate_operation(VM_Operation* op) {
 ResourceMark rm;
 // the queue until there are none left
 do {
 _cur_vm_operation = safepoint_ops;
 if (_cur_vm_operation != NULL) {
 do {
+EventMark em("Executing coalesced safepoint VM operation: %s", _cur_vm_operation->name());
 log_debug(vmthread)("Evaluating coalesced safepoint VM operation: %s", _cur_vm_operation->name());
 // evaluate_operation deletes the op object so we have
 // to grab the next op now
 VM_Operation* next = _cur_vm_operation->next();
 _vm_queue->set_drain_list(next);
 }
 }
 //
 //  Notify (potential) waiting Java thread(s)
-{ MutexLocker mu(VMOperationRequest_lock, Mutex::_no_safepoint_check_flag);
+{ MonitorLocker mu(VMOperationRequest_lock, Mutex::_no_safepoint_check_flag);
-VMOperationRequest_lock->notify_all();
+mu.notify_all();
 }
 // We want to make sure that we get to a safepoint regularly
 // even when executing VMops that don't require safepoints.
 if ((_cur_vm_operation = VMThread::no_op_safepoint()) != NULL) {
 SkipGCALot sgcalot(t);    // avoid re-entrant attempts to gc-a-lot
 // JavaThread or WatcherThread
 bool concurrent = op->evaluate_concurrently();
 // only blocking VM operations need to verify the caller's safepoint state:
 if (!concurrent) {
-t->check_for_valid_safepoint_state(true);
+t->check_for_valid_safepoint_state();
 }
 // New request from Java thread, evaluate prologue
 if (!op->doit_prologue()) {
 return;   // op was cancelled
 }
 // Setup VM_operations for execution
-op->set_calling_thread(t, Thread::get_priority(t));
+op->set_calling_thread(t);
 // It does not make sense to execute the epilogue, if the VM operation object is getting
 // deallocated by the VM thread.
 bool execute_epilog = !op->is_cheap_allocated();
 assert(!concurrent || op->is_cheap_allocated(), "concurrent => cheap_allocated");
 // Add VM operation to list of waiting threads. We are guaranteed not to block while holding the
 // VMOperationQueue_lock, so we can block without a safepoint check. This allows vm operation requests
 // to be queued up during a safepoint synchronization.
 {
-VMOperationQueue_lock->lock_without_safepoint_check();
+MonitorLocker ml(VMOperationQueue_lock, Mutex::_no_safepoint_check_flag);
 log_debug(vmthread)("Adding VM operation: %s", op->name());
-bool ok = _vm_queue->add(op);
+_vm_queue->add(op);
 op->set_timestamp(os::javaTimeMillis());
-VMOperationQueue_lock->notify();
+ml.notify();
-VMOperationQueue_lock->unlock();
-// VM_Operation got skipped
-if (!ok) {
-assert(concurrent, "can only skip concurrent tasks");
-if (op->is_cheap_allocated()) delete op;
-return;
-}
 }
 if (!concurrent) {
 // Wait for completion of request (non-concurrent)
 // Note: only a JavaThread triggers the safepoint check when locking
 // does not allow nested scavenges or compiles.
 if (!prev_vm_operation->allow_nested_vm_operations()) {
 fatal("Nested VM operation %s requested by operation %s",
 op->name(), vm_operation()->name());
 }
-op->set_calling_thread(prev_vm_operation->calling_thread(), prev_vm_operation->priority());
+op->set_calling_thread(prev_vm_operation->calling_thread());
 }
 EventMark em("Executing %s VM operation: %s", prev_vm_operation ? "nested" : "", op->name());
 // Release all internal handles after operation is evaluated

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54786	ebf733a324d4
child 58679	9c3209ff7550