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

equal deleted inserted replaced

-:bf1133e7dfba
+:b22d8ae270a2
 #include "utilities/dtrace.hpp"
 #include "utilities/events.hpp"
 #include "utilities/vmError.hpp"
 #include "utilities/xmlstream.hpp"
-// Dummy VM operation to act as first element in our circular double-linked list
-class VM_None: public VM_Operation {
-VMOp_Type type() const { return VMOp_None; }
-void  doit() {};
-};
 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();
+_queue[i] = new VM_None("QueueHead");
 _queue[i]->set_next(_queue[i]);
 _queue[i]->set_prev(_queue[i]);
 }
 _drain_list = NULL;
 }
 }
 //------------------------------------------------------------------------------------------------------------------
 // Implementation of VMThread stuff
-bool                VMThread::_should_terminate   = false;
+bool              VMThread::_should_terminate   = false;
 bool              VMThread::_terminated         = false;
 Monitor*          VMThread::_terminate_lock     = NULL;
 VMThread*         VMThread::_vm_thread          = NULL;
 VM_Operation*     VMThread::_cur_vm_operation   = NULL;
 VMOperationQueue* VMThread::_vm_queue           = NULL;
 PerfCounter*      VMThread::_perf_accumulated_vm_operation_time = NULL;
-const char*       VMThread::_no_op_reason       = NULL;
+uint64_t          VMThread::_coalesced_count = 0;
 VMOperationTimeoutTask* VMThread::_timeout_task = NULL;
 void VMThread::create() {
 assert(vm_thread() == NULL, "we can only allocate one VMThread");
 }
 void VMThread::destroy() {
 _vm_thread = NULL;      // VM thread is gone
 }
+static VM_None halt_op("Halt");
 void VMThread::run() {
 assert(this == vm_thread(), "check");
 // Notify_lock wait checks on active_handles() to rewait in
 xtty->end_elem();
 assert(should_terminate(), "termination flag must be set");
 }
 // 4526887 let VM thread exit at Safepoint
-_no_op_reason = "Halt";
+_cur_vm_operation = &halt_op;
 SafepointSynchronize::begin();
 if (VerifyBeforeExit) {
 HandleMark hm(VMThread::vm_thread());
 // Among other things, this ensures that Eden top is correct.
 if (c_heap_allocated) {
 delete _cur_vm_operation;
 }
 }
-bool VMThread::no_op_safepoint_needed(bool check_time) {
+static VM_None    safepointALot_op("SafepointALot");
+static VM_Cleanup cleanup_op;
+VM_Operation* VMThread::no_op_safepoint(bool check_time) {
 if (SafepointALot) {
-_no_op_reason = "SafepointALot";
+return &safepointALot_op;
-return true;
 }
 if (!SafepointSynchronize::is_cleanup_needed()) {
-return false;
+return NULL;
 }
 if (check_time) {
-long interval = SafepointSynchronize::last_non_safepoint_interval();
+long interval_ms = SafepointTracing::time_since_last_safepoint_ms();
 bool max_time_exceeded = GuaranteedSafepointInterval != 0 &&
-(interval > GuaranteedSafepointInterval);
+(interval_ms > GuaranteedSafepointInterval);
 if (!max_time_exceeded) {
-return false;
+return NULL;
 }
 }
-_no_op_reason = "Cleanup";
+return &cleanup_op;
-return true;
 }
 void VMThread::loop() {
 assert(_cur_vm_operation == NULL, "no current one should be executing");
 (os::elapsedTime() > (double)SelfDestructTimer * 60.0)) {
 tty->print_cr("VM self-destructed");
 exit(-1);
 }
-if (timedout && VMThread::no_op_safepoint_needed(false)) {
+if (timedout && (_cur_vm_operation = VMThread::no_op_safepoint(false)) != NULL) {
 MutexUnlockerEx mul(VMOperationQueue_lock,
 Mutex::_no_safepoint_check_flag);
 // Force a safepoint since we have not had one for at least
 // 'GuaranteedSafepointInterval' milliseconds.  This will run all
 // the clean-up processing that needs to be done regularly at a
 SafepointSynchronize::begin();
 #ifdef ASSERT
 if (GCALotAtAllSafepoints) InterfaceSupport::check_gc_alot();
 #endif
 SafepointSynchronize::end();
+_cur_vm_operation = NULL;
 }
 _cur_vm_operation = _vm_queue->remove_next();
 // If we are at a safepoint we will evaluate all the operations that
 // follow that also require a safepoint
 // to grab the next op now
 VM_Operation* next = _cur_vm_operation->next();
 _vm_queue->set_drain_list(next);
 evaluate_operation(_cur_vm_operation);
 _cur_vm_operation = next;
-if (log_is_enabled(Debug, safepoint, stats)) {
+_coalesced_count++;
-SafepointSynchronize::inc_vmop_coalesced_count();
-}
 } while (_cur_vm_operation != NULL);
 }
 // There is a chance that a thread enqueued a safepoint op
 // since we released the op-queue lock and initiated the safepoint.
 // So we drain the queue again if there is anything there, as an
 }
 //
 // We want to make sure that we get to a safepoint regularly.
 //
-if (VMThread::no_op_safepoint_needed(true)) {
+if ((_cur_vm_operation = VMThread::no_op_safepoint(false)) != 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

changeset 53895	b22d8ae270a2
parent 53775	5d20b085d893
child 54278	16999bd91ba6