truffle: src/share/vm/runtime/safepoint.cpp comparison

comparison src/share/vm/runtime/safepoint.cpp @ 4875:379b22e03c32

Merge

author	jcoomes
date	Fri, 03 Feb 2012 12:08:55 -0800
parents	0382d2b469b2
children	0ebca2e35ca5 541c4a5e7b88

comparison

equal deleted inserted replaced

-:527cf36f4a20
+:379b22e03c32
 /*
-* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 // Implementation of Safepoint begin/end
 SafepointSynchronize::SynchronizeState volatile SafepointSynchronize::_state = SafepointSynchronize::_not_synchronized;
 volatile int  SafepointSynchronize::_waiting_to_block = 0;
 volatile int SafepointSynchronize::_safepoint_counter = 0;
+int SafepointSynchronize::_current_jni_active_count = 0;
 long  SafepointSynchronize::_end_of_last_safepoint = 0;
 static volatile int PageArmed = 0 ;        // safepoint polling page is RO|RW vs PROT_NONE
 static volatile int TryingToBlock = 0 ;    // proximate value -- for advisory use only
 static bool timeout_error_printed = false;
 tty->print_cr("Safepoint synchronization initiated. (%d)", nof_threads);
 }
 RuntimeService::record_safepoint_begin();
-{
 MutexLocker mu(Safepoint_lock);
+// Reset the count of active JNI critical threads
+_current_jni_active_count = 0;
 // Set number of threads to wait for, before we initiate the callbacks
 _waiting_to_block = nof_threads;
 TryingToBlock     = 0 ;
 int still_running = nof_threads;
 // Record state
 _state = _synchronized;
 OrderAccess::fence();
+// Update the count of active JNI critical regions
+GC_locker::set_jni_lock_count(_current_jni_active_count);
 if (TraceSafepoint) {
 VM_Operation *op = VMThread::vm_operation();
 tty->print_cr("Entering safepoint region: %s", (op != NULL) ? op->name() : "no vm operation");
 }
 do_cleanup_tasks();
 if (PrintSafepointStatistics) {
 // Record how much time spend on the above cleanup tasks
 update_statistics_on_cleanup_end(os::javaTimeNanos());
-}
 }
 }
 // Wake up all threads, so they are ready to resume execution after the safepoint
 // operation has been carried out
 return false;
 }
 }
+// See if the thread is running inside a lazy critical native and
+// update the thread critical count if so.  Also set a suspend flag to
+// cause the native wrapper to return into the JVM to do the unlock
+// once the native finishes.
+void SafepointSynchronize::check_for_lazy_critical_native(JavaThread *thread, JavaThreadState state) {
+if (state == _thread_in_native &&
+thread->has_last_Java_frame() &&
+thread->frame_anchor()->walkable()) {
+// This thread might be in a critical native nmethod so look at
+// the top of the stack and increment the critical count if it
+// is.
+frame wrapper_frame = thread->last_frame();
+CodeBlob* stub_cb = wrapper_frame.cb();
+if (stub_cb != NULL &&
+stub_cb->is_nmethod() &&
+stub_cb->as_nmethod_or_null()->is_lazy_critical_native()) {
+// A thread could potentially be in a critical native across
+// more than one safepoint, so only update the critical state on
+// the first one.  When it returns it will perform the unlock.
+if (!thread->do_critical_native_unlock()) {
+#ifdef ASSERT
+if (!thread->in_critical()) {
+GC_locker::increment_debug_jni_lock_count();
+}
+#endif
+thread->enter_critical();
+// Make sure the native wrapper calls back on return to
+// perform the needed critical unlock.
+thread->set_critical_native_unlock();
+}
+}
+}
+}
 // -------------------------------------------------------------------------------------------------------
 // Implementation of Safepoint callback point
 void SafepointSynchronize::block(JavaThread *thread) {
 assert(thread != NULL, "thread must be set");
 if (is_synchronizing()) {
 // Decrement the number of threads to wait for and signal vm thread
 assert(_waiting_to_block > 0, "sanity check");
 _waiting_to_block--;
 thread->safepoint_state()->set_has_called_back(true);
+if (thread->in_critical()) {
+// Notice that this thread is in a critical section
+increment_jni_active_count();
+}
 // Consider (_waiting_to_block < 2) to pipeline the wakeup of the VM thread
 if (_waiting_to_block == 0) {
 Safepoint_lock->notify_all();
 }
 // Some JavaThread states have an initial safepoint state of
 // running, but are actually at a safepoint. We will happily
 // agree and update the safepoint state here.
 if (SafepointSynchronize::safepoint_safe(_thread, state)) {
 roll_forward(_at_safepoint);
-return;
+SafepointSynchronize::check_for_lazy_critical_native(_thread, state);
+if (_thread->in_critical()) {
+// Notice that this thread is in a critical section
+SafepointSynchronize::increment_jni_active_count();
+}
+return;
 }
 if (state == _thread_in_vm) {
 roll_forward(_call_back);
 return;

Mercurial > hg > truffle

comparison src/share/vm/runtime/safepoint.cpp @ 4875:379b22e03c32