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

equal deleted inserted replaced

-:5e8f9713e343
+:3636bab5e81e
 #include "utilities/dtrace.hpp"
 #include "utilities/events.hpp"
 #include "utilities/vmError.hpp"
 #include "utilities/xmlstream.hpp"
+VM_QueueHead VMOperationQueue::_queue_head[VMOperationQueue::nof_priorities];
 VMOperationQueue::VMOperationQueue() {
 // The queue is a circular doubled-linked list, which always contains
 // one element (i.e., one element means empty).
 for(int i = 0; i < nof_priorities; i++) {
 _queue_length[i] = 0;
 _queue_counter = 0;
-_queue[i] = new VM_None("QueueHead");
+_queue[i] = &_queue_head[i];
 _queue[i]->set_next(_queue[i]);
 _queue[i]->set_prev(_queue[i]);
 }
 _drain_list = NULL;
 }
 n->set_next(q->next());
 q->next()->set_prev(n);
 q->set_next(n);
 }
-void VMOperationQueue::queue_add_front(int prio, VM_Operation *op) {
+void VMOperationQueue::queue_add(int prio, VM_Operation *op) {
-_queue_length[prio]++;
-insert(_queue[prio]->next(), op);
-}
-void VMOperationQueue::queue_add_back(int prio, VM_Operation *op) {
 _queue_length[prio]++;
 insert(_queue[prio]->prev(), op);
 }
 // High-level interface
 void VMOperationQueue::add(VM_Operation *op) {
 HOTSPOT_VMOPS_REQUEST(
 (char *) op->name(), strlen(op->name()),
-op->evaluation_mode());
+op->evaluate_at_safepoint() ? 0 : 1);
 // Encapsulates VM queue policy. Currently, that
 // only involves putting them on the right list
-queue_add_back(op->evaluate_at_safepoint() ? SafepointPriority : MediumPriority, op);
+queue_add(op->evaluate_at_safepoint() ? SafepointPriority : MediumPriority, op);
 }
 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.
 static void post_vm_operation_event(EventExecuteVMOperation* event, VM_Operation* op) {
 assert(event != NULL, "invariant");
 assert(event->should_commit(), "invariant");
 assert(op != NULL, "invariant");
-const bool is_concurrent = op->evaluate_concurrently();
 const bool evaluate_at_safepoint = op->evaluate_at_safepoint();
 event->set_operation(op->type());
 event->set_safepoint(evaluate_at_safepoint);
-event->set_blocking(!is_concurrent);
+event->set_blocking(true);
-// Only write caller thread information for non-concurrent vm operations.
+event->set_caller(JFR_THREAD_ID(op->calling_thread()));
-// 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_id() : 0);
 event->commit();
 }
 void VMThread::evaluate_operation(VM_Operation* op) {
 {
 PerfTraceTime vm_op_timer(perf_accumulated_vm_operation_time());
 HOTSPOT_VMOPS_BEGIN(
 (char *) op->name(), strlen(op->name()),
-op->evaluation_mode());
+op->evaluate_at_safepoint() ? 0 : 1);
 EventExecuteVMOperation event;
 op->evaluate();
 if (event.should_commit()) {
 post_vm_operation_event(&event, op);
 }
 HOTSPOT_VMOPS_END(
 (char *) op->name(), strlen(op->name()),
-op->evaluation_mode());
+op->evaluate_at_safepoint() ? 0 : 1);
 }
-// Last access of info in _cur_vm_operation!
-bool c_heap_allocated = op->is_cheap_allocated();
 // Mark as completed
-if (!op->evaluate_concurrently()) {
+op->calling_thread()->increment_vm_operation_completed_count();
-op->calling_thread()->increment_vm_operation_completed_count();
-}
-// It is unsafe to access the _cur_vm_operation after the 'increment_vm_operation_completed_count' call,
-// since if it is stack allocated the calling thread might have deallocated
-if (c_heap_allocated) {
-delete _cur_vm_operation;
-}
 }
 static VM_None    safepointALot_op("SafepointALot");
 static VM_Cleanup cleanup_op;
 jt->verify_states_for_handshake();
 #endif
 }
 };
+void VMThread::check_for_forced_cleanup() {
+MonitorLocker mq(VMOperationQueue_lock,  Mutex::_no_safepoint_check_flag);
+mq.notify();
+}
 VM_Operation* VMThread::no_op_safepoint() {
 // Check for handshakes first since we may need to return a VMop.
 if (HandshakeALot) {
 HandshakeALotTC haltc;
 Handshake::execute(&haltc);
 }
 // Check for a cleanup before SafepointALot to keep stats correct.
 long interval_ms = SafepointTracing::time_since_last_safepoint_ms();
 bool max_time_exceeded = GuaranteedSafepointInterval != 0 &&
 (interval_ms >= GuaranteedSafepointInterval);
-if (max_time_exceeded && SafepointSynchronize::is_cleanup_needed()) {
+if ((max_time_exceeded && SafepointSynchronize::is_cleanup_needed()) ||
+SafepointSynchronize::is_forced_cleanup_needed()) {
 return &cleanup_op;
 }
 if (SafepointALot) {
 return &safepointALot_op;
 }
 // Look for new operation
 assert(_cur_vm_operation == NULL, "no current one should be executing");
 _cur_vm_operation = _vm_queue->remove_next();
 // Stall time tracking code
-if (PrintVMQWaitTime && _cur_vm_operation != NULL &&
+if (PrintVMQWaitTime && _cur_vm_operation != NULL) {
-!_cur_vm_operation->evaluate_concurrently()) {
 long stall = os::javaTimeMillis() - _cur_vm_operation->timestamp();
 if (stall > 0)
 tty->print_cr("%s stall: %ld",  _cur_vm_operation->name(), stall);
 }
 while (!should_terminate() && _cur_vm_operation == NULL) {
 // wait with a timeout to guarantee safepoints at regular intervals
-bool timedout =
+// (if there is cleanup work to do)
-mu_queue.wait(GuaranteedSafepointInterval);
+(void)mu_queue.wait(GuaranteedSafepointInterval);
 // Support for self destruction
 if ((SelfDestructTimer != 0) && !VMError::is_error_reported() &&
 (os::elapsedTime() > (double)SelfDestructTimer * 60.0)) {
 tty->print_cr("VM self-destructed");
 exit(-1);
 }
-if (timedout) {
+// If the queue contains a safepoint VM op,
+// clean up will be done so we can skip this part.
+if (!_vm_queue->peek_at_safepoint_priority()) {
 // Have to unlock VMOperationQueue_lock just in case no_op_safepoint()
-// has to do a handshake.
+// has to do a handshake when HandshakeALot is enabled.
 MutexUnlocker mul(VMOperationQueue_lock, Mutex::_no_safepoint_check_flag);
 if ((_cur_vm_operation = VMThread::no_op_safepoint()) != NULL) {
 // Force a safepoint since we have not had one for at least
 // 'GuaranteedSafepointInterval' milliseconds and we need to clean
 // something. This will run all the clean-up processing that needs
 //
 //  Notify (potential) waiting Java thread(s)
 { MonitorLocker mu(VMOperationRequest_lock, Mutex::_no_safepoint_check_flag);
 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) {
-HandleMark hm(VMThread::vm_thread());
-SafepointSynchronize::begin();
-SafepointSynchronize::end();
-_cur_vm_operation = NULL;
-}
 }
 }
 // A SkipGCALot object is used to elide the usual effect of gc-a-lot
 // over a section of execution by a thread. Currently, it's used only to
 Thread* t = Thread::current();
 if (!t->is_VM_thread()) {
 SkipGCALot sgcalot(t);    // avoid re-entrant attempts to gc-a-lot
 // JavaThread or WatcherThread
-bool concurrent = op->evaluate_concurrently();
+t->check_for_valid_safepoint_state();
-// only blocking VM operations need to verify the caller's safepoint state:
-if (!concurrent) {
-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);
-// It does not make sense to execute the epilogue, if the VM operation object is getting
+// Get ticket number for the VM operation
-// deallocated by the VM thread.
+int ticket = t->vm_operation_ticket();
-bool execute_epilog = !op->is_cheap_allocated();
-assert(!concurrent || op->is_cheap_allocated(), "concurrent => cheap_allocated");
-// Get ticket number for non-concurrent VM operations
-int ticket = 0;
-if (!concurrent) {
-ticket = t->vm_operation_ticket();
-}
 // 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.
 {
 log_debug(vmthread)("Adding VM operation: %s", op->name());
 _vm_queue->add(op);
 op->set_timestamp(os::javaTimeMillis());
 ml.notify();
 }
+{
-if (!concurrent) {
+// Wait for completion of request
-// Wait for completion of request (non-concurrent)
 // Note: only a JavaThread triggers the safepoint check when locking
 MonitorLocker ml(VMOperationRequest_lock,
 t->is_Java_thread() ? Mutex::_safepoint_check_flag : Mutex::_no_safepoint_check_flag);
 while(t->vm_operation_completed_count() < ticket) {
 ml.wait();
 }
 }
+op->doit_epilogue();
-if (execute_epilog) {
-op->doit_epilogue();
-}
 } else {
 // invoked by VM thread; usually nested VM operation
 assert(t->is_VM_thread(), "must be a VM thread");
 VM_Operation* prev_vm_operation = vm_operation();
 if (prev_vm_operation != NULL) {
 SafepointSynchronize::end();
 } else {
 op->evaluate();
 }
-// Free memory if needed
-if (op->is_cheap_allocated()) delete op;
 _cur_vm_operation = prev_vm_operation;
 }
 }

changeset 59325	3636bab5e81e
parent 59290	97d13893ec3c