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

comparison src/share/vm/runtime/sweeper.cpp @ 1644:2a47bd84841f

6965184: possible races in make_not_entrant_or_zombie Reviewed-by: kvn

author	never
date	Thu, 08 Jul 2010 14:29:44 -0700
parents	ff38d05ea86f
children	8d5934a77f10

comparison

equal deleted inserted replaced

-:a693e51ac197
+:2a47bd84841f
 /*
-* Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2010, 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.
 # include "incls/_precompiled.incl"
 # include "incls/_sweeper.cpp.incl"
 long      NMethodSweeper::_traversals = 0;   // No. of stack traversals performed
 nmethod*  NMethodSweeper::_current = NULL;   // Current nmethod
-int       NMethodSweeper::_seen = 0 ;        // No. of blobs we have currently processed in current pass of CodeCache
+int       NMethodSweeper::_seen = 0 ;        // No. of nmethods we have currently processed in current pass of CodeCache
-int       NMethodSweeper::_invocations = 0;  // No. of invocations left until we are completed with this pass
+volatile int NMethodSweeper::_invocations = 0;   // No. of invocations left until we are completed with this pass
+volatile int NMethodSweeper::_sweep_started = 0; // Whether a sweep is in progress.
 jint      NMethodSweeper::_locked_seen = 0;
 jint      NMethodSweeper::_not_entrant_seen_on_stack = 0;
 bool      NMethodSweeper::_rescan = false;
 bool      NMethodSweeper::_do_sweep = false;
-jint      NMethodSweeper::_sweep_started = 0;
 bool      NMethodSweeper::_was_full = false;
 jint      NMethodSweeper::_advise_to_sweep = 0;
 jlong     NMethodSweeper::_last_was_full = 0;
 uint      NMethodSweeper::_highest_marked = 0;
 long      NMethodSweeper::_was_full_traversal = 0;
 // Update the _last_was_full time so we can tell how fast the
 // code cache is filling up
 _last_was_full = os::javaTimeMillis();
-if (PrintMethodFlushing) {
+log_sweep("restart_compiler");
-tty->print_cr("### sweeper: Live blobs:" UINT32_FORMAT "/Free code cache:" SIZE_FORMAT " bytes, restarting compiler",
-CodeCache::nof_blobs(), CodeCache::unallocated_capacity());
-}
-if (LogCompilation && (xtty != NULL)) {
-ttyLocker ttyl;
-xtty->begin_elem("restart_compiler live_blobs='" UINT32_FORMAT "' free_code_cache='" SIZE_FORMAT "'",
-CodeCache::nof_blobs(), CodeCache::unallocated_capacity());
-xtty->stamp();
-xtty->end_elem();
-}
 }
 }
 }
 }
 void NMethodSweeper::possibly_sweep() {
+assert(JavaThread::current()->thread_state() == _thread_in_vm, "must run in vm mode");
 if ((!MethodFlushing) || (!_do_sweep)) return;
 if (_invocations > 0) {
 // Only one thread at a time will sweep
 jint old = Atomic::cmpxchg( 1, &_sweep_started, 0 );
 if (old != 0) {
 return;
 }
-sweep_code_cache();
+if (_invocations > 0) {
-}
+sweep_code_cache();
-_sweep_started = 0;
+_invocations--;
+}
+_sweep_started = 0;
+}
 }
 void NMethodSweeper::sweep_code_cache() {
 #ifdef ASSERT
 jlong sweep_start;
-if(PrintMethodFlushing) {
+if (PrintMethodFlushing) {
 sweep_start = os::javaTimeMillis();
 }
 #endif
 if (PrintMethodFlushing && Verbose) {
-tty->print_cr("### Sweep at %d out of %d. Invocations left: %d", _seen, CodeCache::nof_blobs(), _invocations);
+tty->print_cr("### Sweep at %d out of %d. Invocations left: %d", _seen, CodeCache::nof_nmethods(), _invocations);
 }
-// We want to visit all nmethods after NmethodSweepFraction invocations.
+// We want to visit all nmethods after NmethodSweepFraction
-// If invocation is 1 we do the rest
+// invocations so divide the remaining number of nmethods by the
-int todo = CodeCache::nof_blobs();
+// remaining number of invocations.  This is only an estimate since
-if (_invocations > 1) {
+// the number of nmethods changes during the sweep so the final
-todo = (CodeCache::nof_blobs() - _seen) / _invocations;
+// stage must iterate until it there are no more nmethods.
-}
+int todo = (CodeCache::nof_nmethods() - _seen) / _invocations;
-// Compilers may check to sweep more often than stack scans happen,
-// don't keep trying once it is all scanned
-_invocations--;
 assert(!SafepointSynchronize::is_at_safepoint(), "should not be in safepoint when we get here");
 assert(!CodeCache_lock->owned_by_self(), "just checking");
 {
 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
-for(int i = 0; i < todo && _current != NULL; i++) {
+// The last invocation iterates until there are no more nmethods
+for (int i = 0; (i < todo || _invocations == 1) && _current != NULL; i++) {
-// Since we will give up the CodeCache_lock, always skip ahead to an nmethod.
-// Other blobs can be deleted by other threads
+// Since we will give up the CodeCache_lock, always skip ahead
-// Read next before we potentially delete current
+// to the next nmethod.  Other blobs can be deleted by other
+// threads but nmethods are only reclaimed by the sweeper.
 nmethod* next = CodeCache::next_nmethod(_current);
 // Now ready to process nmethod and give up CodeCache_lock
 {
 MutexUnlockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 }
 _seen++;
 _current = next;
 }
 }
+assert(_invocations > 1 || _current == NULL, "must have scanned the whole cache");
 if (_current == NULL && !_rescan && (_locked_seen || _not_entrant_seen_on_stack)) {
 // we've completed a scan without making progress but there were
 // nmethods we were unable to process either because they were
 // locked or were still on stack.  We don't have to aggresively
 if(PrintMethodFlushing) {
 jlong sweep_end             = os::javaTimeMillis();
 tty->print_cr("### sweeper:      sweep time(%d): " INT64_FORMAT, _invocations, sweep_end - sweep_start);
 }
 #endif
+if (_invocations == 1) {
+log_sweep("finished");
+}
 }
 void NMethodSweeper::process_nmethod(nmethod *nm) {
 assert(!CodeCache_lock->owned_by_self(), "just checking");
 }
 if (nm->is_zombie()) {
 // If it is first time, we see nmethod then we mark it. Otherwise,
 // we reclame it. When we have seen a zombie method twice, we know that
-// there are no inline caches that referes to it.
+// there are no inline caches that refer to it.
 if (nm->is_marked_for_reclamation()) {
 assert(!nm->is_locked_by_vm(), "must not flush locked nmethods");
 if (PrintMethodFlushing && Verbose) {
 tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (marked for reclamation) being flushed", nm->compile_id(), nm);
 }
 jlong now = os::javaTimeMillis();
 jlong max_interval = (jlong)MinCodeCacheFlushingInterval * (jlong)1000;
 jlong curr_interval = now - _last_was_full;
 if (curr_interval < max_interval) {
 _rescan = true;
-if (PrintMethodFlushing) {
+log_sweep("disable_compiler", "flushing_interval='" UINT64_FORMAT "'",
-tty->print_cr("### handle full too often, turning off compiler");
+curr_interval/1000);
-}
-if (LogCompilation && (xtty != NULL)) {
-ttyLocker ttyl;
-xtty->begin_elem("disable_compiler flushing_interval='" UINT64_FORMAT "' live_blobs='" UINT32_FORMAT "' free_code_cache='" SIZE_FORMAT "'",
-curr_interval/1000, CodeCache::nof_blobs(), CodeCache::unallocated_capacity());
-xtty->stamp();
-xtty->end_elem();
-}
 return;
 }
 }
 VM_HandleFullCodeCache op(is_full);
 debug_only(jlong start = os::javaTimeMillis();)
 if ((!was_full()) && (is_full)) {
 if (!CodeCache::needs_flushing()) {
-if (PrintMethodFlushing) {
+log_sweep("restart_compiler");
-tty->print_cr("### sweeper: Live blobs:" UINT32_FORMAT "/Free code cache:" SIZE_FORMAT " bytes, restarting compiler",
-CodeCache::nof_blobs(), CodeCache::unallocated_capacity());
-}
-if (LogCompilation && (xtty != NULL)) {
-ttyLocker ttyl;
-xtty->begin_elem("restart_compiler live_blobs='" UINT32_FORMAT "' free_code_cache='" SIZE_FORMAT "'",
-CodeCache::nof_blobs(), CodeCache::unallocated_capacity());
-xtty->stamp();
-xtty->end_elem();
-}
 CompileBroker::set_should_compile_new_jobs(CompileBroker::run_compilation);
 return;
 }
 }
 // Traverse the code cache trying to dump the oldest nmethods
 uint curr_max_comp_id = CompileBroker::get_compilation_id();
 uint flush_target = ((curr_max_comp_id - _highest_marked) >> 1) + _highest_marked;
-if (PrintMethodFlushing && Verbose) {
+log_sweep("start_cleaning");
-tty->print_cr("### Cleaning code cache: Live blobs:" UINT32_FORMAT "/Free code cache:" SIZE_FORMAT " bytes",
-CodeCache::nof_blobs(), CodeCache::unallocated_capacity());
-}
-if (LogCompilation && (xtty != NULL)) {
-ttyLocker ttyl;
-xtty->begin_elem("start_cleaning_code_cache live_blobs='" UINT32_FORMAT "' free_code_cache='" SIZE_FORMAT "'",
-CodeCache::nof_blobs(), CodeCache::unallocated_capacity());
-xtty->stamp();
-xtty->end_elem();
-}
 nmethod* nm = CodeCache::alive_nmethod(CodeCache::first());
 jint disconnected = 0;
 jint made_not_entrant  = 0;
 while ((nm != NULL)){
 }
 }
 nm = CodeCache::alive_nmethod(CodeCache::next(nm));
 }
-if (LogCompilation && (xtty != NULL)) {
+log_sweep("stop_cleaning",
-ttyLocker ttyl;
+"disconnected='" UINT32_FORMAT "' made_not_entrant='" UINT32_FORMAT "'",
-xtty->begin_elem("stop_cleaning_code_cache disconnected='" UINT32_FORMAT "' made_not_entrant='" UINT32_FORMAT "' live_blobs='" UINT32_FORMAT "' free_code_cache='" SIZE_FORMAT "'",
+disconnected, made_not_entrant);
-disconnected, made_not_entrant, CodeCache::nof_blobs(), CodeCache::unallocated_capacity());
-xtty->stamp();
-xtty->end_elem();
-}
 // Shut off compiler. Sweeper will start over with a new stack scan and
 // traversal cycle and turn it back on if it clears enough space.
 if (was_full()) {
 _last_was_full = os::javaTimeMillis();
 if(PrintMethodFlushing && Verbose) {
 tty->print_cr("### sweeper: unload time: " INT64_FORMAT, end-start);
 }
 #endif
 }
+// Print out some state information about the current sweep and the
+// state of the code cache if it's requested.
+void NMethodSweeper::log_sweep(const char* msg, const char* format, ...) {
+if (PrintMethodFlushing) {
+ttyLocker ttyl;
+tty->print("### sweeper: %s ", msg);
+if (format != NULL) {
+va_list ap;
+va_start(ap, format);
+tty->vprint(format, ap);
+va_end(ap);
+}
+tty->print_cr(" total_blobs='" UINT32_FORMAT "' nmethods='" UINT32_FORMAT "'"
+" adapters='" UINT32_FORMAT "' free_code_cache='" SIZE_FORMAT "'",
+CodeCache::nof_blobs(), CodeCache::nof_nmethods(), CodeCache::nof_adapters(), CodeCache::unallocated_capacity());
+}
+if (LogCompilation && (xtty != NULL)) {
+ttyLocker ttyl;
+xtty->begin_elem("sweeper state='%s' traversals=`" INTX_FORMAT "' ", msg, (intx)traversal_count());
+if (format != NULL) {
+va_list ap;
+va_start(ap, format);
+xtty->vprint(format, ap);
+va_end(ap);
+}
+xtty->print(" total_blobs='" UINT32_FORMAT "' nmethods='" UINT32_FORMAT "'"
+" adapters='" UINT32_FORMAT "' free_code_cache='" SIZE_FORMAT "'",
+CodeCache::nof_blobs(), CodeCache::nof_nmethods(), CodeCache::nof_adapters(), CodeCache::unallocated_capacity());
+xtty->stamp();
+xtty->end_elem();
+}
+}

Mercurial > hg > truffle

comparison src/share/vm/runtime/sweeper.cpp @ 1644:2a47bd84841f