• file
• revisions
• annotate
• diff
• comparison
• raw

src/share/vm/runtime/sweeper.cpp@b5cb079ecaa4 (annotated)

src/share/vm/runtime/sweeper.cpp

Sun, 03 Feb 2013 22:43:57 +0100

author

ewendeli

date

Sun, 03 Feb 2013 22:43:57 +0100

changeset 4703

b5cb079ecaa4

parent 4037

da91efe96a93

child 5038

0cfa93c2fcc4

permissions

-rw-r--r--

Merge

duke@435	1	/*
coleenp@4037	2	* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
duke@435	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435	4	*
duke@435	5	* This code is free software; you can redistribute it and/or modify it
duke@435	6	* under the terms of the GNU General Public License version 2 only, as
duke@435	7	* published by the Free Software Foundation.
duke@435	8	*
duke@435	9	* This code is distributed in the hope that it will be useful, but WITHOUT
duke@435	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435	12	* version 2 for more details (a copy is included in the LICENSE file that
duke@435	13	* accompanied this code).
duke@435	14	*
duke@435	15	* You should have received a copy of the GNU General Public License version
duke@435	16	* 2 along with this work; if not, write to the Free Software Foundation,
duke@435	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435	18	*
trims@1907	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907	20	* or visit www.oracle.com if you need additional information or have any
trims@1907	21	* questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
stefank@2314	25	#include "precompiled.hpp"
stefank@2314	26	#include "code/codeCache.hpp"
coleenp@4037	27	#include "code/compiledIC.hpp"
coleenp@4037	28	#include "code/icBuffer.hpp"
stefank@2314	29	#include "code/nmethod.hpp"
stefank@2314	30	#include "compiler/compileBroker.hpp"
stefank@2314	31	#include "memory/resourceArea.hpp"
coleenp@4037	32	#include "oops/method.hpp"
stefank@2314	33	#include "runtime/atomic.hpp"
stefank@2314	34	#include "runtime/compilationPolicy.hpp"
stefank@2314	35	#include "runtime/mutexLocker.hpp"
stefank@2314	36	#include "runtime/os.hpp"
stefank@2314	37	#include "runtime/sweeper.hpp"
stefank@2314	38	#include "runtime/vm_operations.hpp"
stefank@2314	39	#include "utilities/events.hpp"
stefank@2314	40	#include "utilities/xmlstream.hpp"
duke@435	41
never@2916	42	#ifdef ASSERT
never@2916	43
never@2916	44	#define SWEEP(nm) record_sweep(nm, __LINE__)
never@2916	45	// Sweeper logging code
never@2916	46	class SweeperRecord {
never@2916	47	public:
never@2916	48	int traversal;
never@2916	49	int invocation;
never@2916	50	int compile_id;
never@2916	51	long traversal_mark;
never@2916	52	int state;
never@2916	53	const char* kind;
never@2916	54	address vep;
never@2916	55	address uep;
never@2916	56	int line;
never@2916	57
never@2916	58	void print() {
never@2916	59	tty->print_cr("traversal = %d invocation = %d compile_id = %d %s uep = " PTR_FORMAT " vep = "
never@2916	60	PTR_FORMAT " state = %d traversal_mark %d line = %d",
never@2916	61	traversal,
never@2916	62	invocation,
never@2916	63	compile_id,
never@2916	64	kind == NULL ? "" : kind,
never@2916	65	uep,
never@2916	66	vep,
never@2916	67	state,
never@2916	68	traversal_mark,
never@2916	69	line);
never@2916	70	}
never@2916	71	};
never@2916	72
never@2916	73	static int _sweep_index = 0;
never@2916	74	static SweeperRecord* _records = NULL;
never@2916	75
never@2916	76	void NMethodSweeper::report_events(int id, address entry) {
never@2916	77	if (_records != NULL) {
never@2916	78	for (int i = _sweep_index; i < SweeperLogEntries; i++) {
never@2916	79	if (_records[i].uep == entry ||
never@2916	80	_records[i].vep == entry ||
never@2916	81	_records[i].compile_id == id) {
never@2916	82	_records[i].print();
never@2916	83	}
never@2916	84	}
never@2916	85	for (int i = 0; i < _sweep_index; i++) {
never@2916	86	if (_records[i].uep == entry ||
never@2916	87	_records[i].vep == entry ||
never@2916	88	_records[i].compile_id == id) {
never@2916	89	_records[i].print();
never@2916	90	}
never@2916	91	}
never@2916	92	}
never@2916	93	}
never@2916	94
never@2916	95	void NMethodSweeper::report_events() {
never@2916	96	if (_records != NULL) {
never@2916	97	for (int i = _sweep_index; i < SweeperLogEntries; i++) {
never@2916	98	// skip empty records
never@2916	99	if (_records[i].vep == NULL) continue;
never@2916	100	_records[i].print();
never@2916	101	}
never@2916	102	for (int i = 0; i < _sweep_index; i++) {
never@2916	103	// skip empty records
never@2916	104	if (_records[i].vep == NULL) continue;
never@2916	105	_records[i].print();
never@2916	106	}
never@2916	107	}
never@2916	108	}
never@2916	109
never@2916	110	void NMethodSweeper::record_sweep(nmethod* nm, int line) {
never@2916	111	if (_records != NULL) {
never@2916	112	_records[_sweep_index].traversal = _traversals;
never@2916	113	_records[_sweep_index].traversal_mark = nm->_stack_traversal_mark;
never@2916	114	_records[_sweep_index].invocation = _invocations;
never@2916	115	_records[_sweep_index].compile_id = nm->compile_id();
never@2916	116	_records[_sweep_index].kind = nm->compile_kind();
never@2916	117	_records[_sweep_index].state = nm->_state;
never@2916	118	_records[_sweep_index].vep = nm->verified_entry_point();
never@2916	119	_records[_sweep_index].uep = nm->entry_point();
never@2916	120	_records[_sweep_index].line = line;
never@2916	121
never@2916	122	_sweep_index = (_sweep_index + 1) % SweeperLogEntries;
never@2916	123	}
never@2916	124	}
never@2916	125	#else
never@2916	126	#define SWEEP(nm)
never@2916	127	#endif
never@2916	128
never@2916	129
duke@435	130	long NMethodSweeper::_traversals = 0; // No. of stack traversals performed
never@1970	131	nmethod* NMethodSweeper::_current = NULL; // Current nmethod
never@1999	132	int NMethodSweeper::_seen = 0 ; // No. of nmethods we have currently processed in current pass of CodeCache
never@1999	133
never@1999	134	volatile int NMethodSweeper::_invocations = 0; // No. of invocations left until we are completed with this pass
never@1999	135	volatile int NMethodSweeper::_sweep_started = 0; // Whether a sweep is in progress.
duke@435	136
duke@435	137	jint NMethodSweeper::_locked_seen = 0;
duke@435	138	jint NMethodSweeper::_not_entrant_seen_on_stack = 0;
duke@435	139	bool NMethodSweeper::_rescan = false;
never@1893	140	bool NMethodSweeper::_do_sweep = false;
kvn@1637	141	bool NMethodSweeper::_was_full = false;
kvn@1637	142	jint NMethodSweeper::_advise_to_sweep = 0;
kvn@1637	143	jlong NMethodSweeper::_last_was_full = 0;
kvn@1637	144	uint NMethodSweeper::_highest_marked = 0;
kvn@1637	145	long NMethodSweeper::_was_full_traversal = 0;
duke@435	146
jrose@1424	147	class MarkActivationClosure: public CodeBlobClosure {
jrose@1424	148	public:
jrose@1424	149	virtual void do_code_blob(CodeBlob* cb) {
jrose@1424	150	// If we see an activation belonging to a non_entrant nmethod, we mark it.
jrose@1424	151	if (cb->is_nmethod() && ((nmethod*)cb)->is_not_entrant()) {
jrose@1424	152	((nmethod*)cb)->mark_as_seen_on_stack();
jrose@1424	153	}
jrose@1424	154	}
jrose@1424	155	};
jrose@1424	156	static MarkActivationClosure mark_activation_closure;
jrose@1424	157
never@1893	158	void NMethodSweeper::scan_stacks() {
duke@435	159	assert(SafepointSynchronize::is_at_safepoint(), "must be executed at a safepoint");
duke@435	160	if (!MethodFlushing) return;
never@1893	161	_do_sweep = true;
duke@435	162
duke@435	163	// No need to synchronize access, since this is always executed at a
duke@435	164	// safepoint. If we aren't in the middle of scan and a rescan
never@1893	165	// hasn't been requested then just return. If UseCodeCacheFlushing is on and
never@1893	166	// code cache flushing is in progress, don't skip sweeping to help make progress
never@1893	167	// clearing space in the code cache.
never@1893	168	if ((_current == NULL && !_rescan) && !(UseCodeCacheFlushing && !CompileBroker::should_compile_new_jobs())) {
never@1893	169	_do_sweep = false;
never@1893	170	return;
never@1893	171	}
duke@435	172
duke@435	173	// Make sure CompiledIC_lock in unlocked, since we might update some
duke@435	174	// inline caches. If it is, we just bail-out and try later.
duke@435	175	if (CompiledIC_lock->is_locked() || Patching_lock->is_locked()) return;
duke@435	176
duke@435	177	// Check for restart
duke@435	178	assert(CodeCache::find_blob_unsafe(_current) == _current, "Sweeper nmethod cached state invalid");
duke@435	179	if (_current == NULL) {
duke@435	180	_seen = 0;
duke@435	181	_invocations = NmethodSweepFraction;
never@1893	182	_current = CodeCache::first_nmethod();
duke@435	183	_traversals += 1;
duke@435	184	if (PrintMethodFlushing) {
duke@435	185	tty->print_cr("### Sweep: stack traversal %d", _traversals);
duke@435	186	}
jrose@1424	187	Threads::nmethods_do(&mark_activation_closure);
duke@435	188
duke@435	189	// reset the flags since we started a scan from the beginning.
duke@435	190	_rescan = false;
duke@435	191	_locked_seen = 0;
duke@435	192	_not_entrant_seen_on_stack = 0;
duke@435	193	}
duke@435	194
kvn@1637	195	if (UseCodeCacheFlushing) {
kvn@1637	196	if (!CodeCache::needs_flushing()) {
never@1893	197	// scan_stacks() runs during a safepoint, no race with setters
kvn@1637	198	_advise_to_sweep = 0;
kvn@1637	199	}
kvn@1637	200
kvn@1637	201	if (was_full()) {
kvn@1637	202	// There was some progress so attempt to restart the compiler
kvn@1637	203	jlong now = os::javaTimeMillis();
kvn@1637	204	jlong max_interval = (jlong)MinCodeCacheFlushingInterval * (jlong)1000;
kvn@1637	205	jlong curr_interval = now - _last_was_full;
kvn@1637	206	if ((!CodeCache::needs_flushing()) && (curr_interval > max_interval)) {
kvn@1637	207	CompileBroker::set_should_compile_new_jobs(CompileBroker::run_compilation);
kvn@1637	208	set_was_full(false);
kvn@1637	209
kvn@1637	210	// Update the _last_was_full time so we can tell how fast the
kvn@1637	211	// code cache is filling up
kvn@1637	212	_last_was_full = os::javaTimeMillis();
kvn@1637	213
never@1999	214	log_sweep("restart_compiler");
kvn@1637	215	}
kvn@1637	216	}
kvn@1637	217	}
duke@435	218	}
duke@435	219
never@1893	220	void NMethodSweeper::possibly_sweep() {
never@1999	221	assert(JavaThread::current()->thread_state() == _thread_in_vm, "must run in vm mode");
never@1893	222	if ((!MethodFlushing) || (!_do_sweep)) return;
never@1893	223
never@1893	224	if (_invocations > 0) {
never@1893	225	// Only one thread at a time will sweep
never@1893	226	jint old = Atomic::cmpxchg( 1, &_sweep_started, 0 );
never@1893	227	if (old != 0) {
never@1893	228	return;
never@1893	229	}
never@2916	230	#ifdef ASSERT
never@2916	231	if (LogSweeper && _records == NULL) {
never@2916	232	// Create the ring buffer for the logging code
zgu@3900	233	_records = NEW_C_HEAP_ARRAY(SweeperRecord, SweeperLogEntries, mtGC);
never@2916	234	memset(_records, 0, sizeof(SweeperRecord) * SweeperLogEntries);
never@2916	235	}
never@2916	236	#endif
never@1999	237	if (_invocations > 0) {
never@1999	238	sweep_code_cache();
never@1999	239	_invocations--;
never@1999	240	}
never@1999	241	_sweep_started = 0;
never@1893	242	}
never@1893	243	}
never@1893	244
never@1893	245	void NMethodSweeper::sweep_code_cache() {
never@1893	246	#ifdef ASSERT
never@1893	247	jlong sweep_start;
never@1999	248	if (PrintMethodFlushing) {
never@1893	249	sweep_start = os::javaTimeMillis();
never@1893	250	}
never@1893	251	#endif
never@1893	252	if (PrintMethodFlushing && Verbose) {
never@1999	253	tty->print_cr("### Sweep at %d out of %d. Invocations left: %d", _seen, CodeCache::nof_nmethods(), _invocations);
never@1893	254	}
never@1893	255
never@1999	256	// We want to visit all nmethods after NmethodSweepFraction
never@1999	257	// invocations so divide the remaining number of nmethods by the
never@1999	258	// remaining number of invocations. This is only an estimate since
never@1999	259	// the number of nmethods changes during the sweep so the final
never@1999	260	// stage must iterate until it there are no more nmethods.
never@1999	261	int todo = (CodeCache::nof_nmethods() - _seen) / _invocations;
never@1893	262
never@1893	263	assert(!SafepointSynchronize::is_at_safepoint(), "should not be in safepoint when we get here");
never@1893	264	assert(!CodeCache_lock->owned_by_self(), "just checking");
never@1893	265
never@1893	266	{
never@1893	267	MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
never@1893	268
never@1999	269	// The last invocation iterates until there are no more nmethods
never@1999	270	for (int i = 0; (i < todo || _invocations == 1) && _current != NULL; i++) {
iveresov@3572	271	if (SafepointSynchronize::is_synchronizing()) { // Safepoint request
iveresov@3572	272	if (PrintMethodFlushing && Verbose) {
iveresov@3572	273	tty->print_cr("### Sweep at %d out of %d, invocation: %d, yielding to safepoint", _seen, CodeCache::nof_nmethods(), _invocations);
iveresov@3572	274	}
iveresov@3572	275	MutexUnlockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
never@1893	276
iveresov@3572	277	assert(Thread::current()->is_Java_thread(), "should be java thread");
iveresov@3572	278	JavaThread* thread = (JavaThread*)Thread::current();
iveresov@3572	279	ThreadBlockInVM tbivm(thread);
iveresov@3572	280	thread->java_suspend_self();
iveresov@3572	281	}
never@1999	282	// Since we will give up the CodeCache_lock, always skip ahead
never@1999	283	// to the next nmethod. Other blobs can be deleted by other
never@1999	284	// threads but nmethods are only reclaimed by the sweeper.
never@1970	285	nmethod* next = CodeCache::next_nmethod(_current);
never@1893	286
never@1893	287	// Now ready to process nmethod and give up CodeCache_lock
never@1893	288	{
never@1893	289	MutexUnlockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
never@1970	290	process_nmethod(_current);
never@1893	291	}
never@1893	292	_seen++;
never@1893	293	_current = next;
never@1893	294	}
never@1893	295	}
never@1893	296
never@1999	297	assert(_invocations > 1 || _current == NULL, "must have scanned the whole cache");
never@1999	298
never@1893	299	if (_current == NULL && !_rescan && (_locked_seen || _not_entrant_seen_on_stack)) {
never@1893	300	// we've completed a scan without making progress but there were
never@1893	301	// nmethods we were unable to process either because they were
never@1893	302	// locked or were still on stack. We don't have to aggresively
never@1893	303	// clean them up so just stop scanning. We could scan once more
never@1893	304	// but that complicates the control logic and it's unlikely to
never@1893	305	// matter much.
never@1893	306	if (PrintMethodFlushing) {
never@1893	307	tty->print_cr("### Couldn't make progress on some nmethods so stopping sweep");
never@1893	308	}
never@1893	309	}
never@1893	310
never@1893	311	#ifdef ASSERT
never@1893	312	if(PrintMethodFlushing) {
never@1893	313	jlong sweep_end = os::javaTimeMillis();
never@1893	314	tty->print_cr("### sweeper: sweep time(%d): " INT64_FORMAT, _invocations, sweep_end - sweep_start);
never@1893	315	}
never@1893	316	#endif
never@1999	317
never@1999	318	if (_invocations == 1) {
never@1999	319	log_sweep("finished");
never@1999	320	}
never@1893	321	}
never@1893	322
never@2916	323	class NMethodMarker: public StackObj {
never@2916	324	private:
never@2916	325	CompilerThread* _thread;
never@2916	326	public:
never@2916	327	NMethodMarker(nmethod* nm) {
never@2916	328	_thread = CompilerThread::current();
coleenp@4037	329	if (!nm->is_zombie() && !nm->is_unloaded()) {
coleenp@4037	330	// Only expose live nmethods for scanning
never@2916	331	_thread->set_scanned_nmethod(nm);
never@2916	332	}
coleenp@4037	333	}
never@2916	334	~NMethodMarker() {
never@2916	335	_thread->set_scanned_nmethod(NULL);
never@2916	336	}
never@2916	337	};
never@2916	338
coleenp@4037	339	void NMethodSweeper::release_nmethod(nmethod *nm) {
coleenp@4037	340	// Clean up any CompiledICHolders
coleenp@4037	341	{
coleenp@4037	342	ResourceMark rm;
coleenp@4037	343	MutexLocker ml_patch(CompiledIC_lock);
coleenp@4037	344	RelocIterator iter(nm);
coleenp@4037	345	while (iter.next()) {
coleenp@4037	346	if (iter.type() == relocInfo::virtual_call_type) {
coleenp@4037	347	CompiledIC::cleanup_call_site(iter.virtual_call_reloc());
coleenp@4037	348	}
coleenp@4037	349	}
coleenp@4037	350	}
coleenp@4037	351
coleenp@4037	352	MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
coleenp@4037	353	nm->flush();
coleenp@4037	354	}
duke@435	355
duke@435	356	void NMethodSweeper::process_nmethod(nmethod *nm) {
never@1893	357	assert(!CodeCache_lock->owned_by_self(), "just checking");
never@1893	358
never@2916	359	// Make sure this nmethod doesn't get unloaded during the scan,
never@2916	360	// since the locks acquired below might safepoint.
never@2916	361	NMethodMarker nmm(nm);
never@2916	362
never@2916	363	SWEEP(nm);
never@2916	364
duke@435	365	// Skip methods that are currently referenced by the VM
duke@435	366	if (nm->is_locked_by_vm()) {
duke@435	367	// But still remember to clean-up inline caches for alive nmethods
duke@435	368	if (nm->is_alive()) {
duke@435	369	// Clean-up all inline caches that points to zombie/non-reentrant methods
never@1893	370	MutexLocker cl(CompiledIC_lock);
duke@435	371	nm->cleanup_inline_caches();
never@2916	372	SWEEP(nm);
duke@435	373	} else {
duke@435	374	_locked_seen++;
never@2916	375	SWEEP(nm);
duke@435	376	}
duke@435	377	return;
duke@435	378	}
duke@435	379
duke@435	380	if (nm->is_zombie()) {
duke@435	381	// If it is first time, we see nmethod then we mark it. Otherwise,
duke@435	382	// we reclame it. When we have seen a zombie method twice, we know that
never@1999	383	// there are no inline caches that refer to it.
duke@435	384	if (nm->is_marked_for_reclamation()) {
duke@435	385	assert(!nm->is_locked_by_vm(), "must not flush locked nmethods");
ysr@1376	386	if (PrintMethodFlushing && Verbose) {
kvn@1637	387	tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (marked for reclamation) being flushed", nm->compile_id(), nm);
ysr@1376	388	}
coleenp@4037	389	release_nmethod(nm);
duke@435	390	} else {
ysr@1376	391	if (PrintMethodFlushing && Verbose) {
kvn@1637	392	tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (zombie) being marked for reclamation", nm->compile_id(), nm);
ysr@1376	393	}
duke@435	394	nm->mark_for_reclamation();
duke@435	395	_rescan = true;
never@2916	396	SWEEP(nm);
duke@435	397	}
duke@435	398	} else if (nm->is_not_entrant()) {
duke@435	399	// If there is no current activations of this method on the
duke@435	400	// stack we can safely convert it to a zombie method
duke@435	401	if (nm->can_not_entrant_be_converted()) {
ysr@1376	402	if (PrintMethodFlushing && Verbose) {
kvn@1637	403	tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (not entrant) being made zombie", nm->compile_id(), nm);
ysr@1376	404	}
duke@435	405	nm->make_zombie();
duke@435	406	_rescan = true;
never@2916	407	SWEEP(nm);
duke@435	408	} else {
duke@435	409	// Still alive, clean up its inline caches
never@1893	410	MutexLocker cl(CompiledIC_lock);
duke@435	411	nm->cleanup_inline_caches();
duke@435	412	// we coudn't transition this nmethod so don't immediately
duke@435	413	// request a rescan. If this method stays on the stack for a
never@1893	414	// long time we don't want to keep rescanning the code cache.
duke@435	415	_not_entrant_seen_on_stack++;
never@2916	416	SWEEP(nm);
duke@435	417	}
duke@435	418	} else if (nm->is_unloaded()) {
duke@435	419	// Unloaded code, just make it a zombie
ysr@1376	420	if (PrintMethodFlushing && Verbose)
kvn@1637	421	tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (unloaded) being made zombie", nm->compile_id(), nm);
ysr@1376	422	if (nm->is_osr_method()) {
coleenp@4037	423	SWEEP(nm);
duke@435	424	// No inline caches will ever point to osr methods, so we can just remove it
coleenp@4037	425	release_nmethod(nm);
duke@435	426	} else {
duke@435	427	nm->make_zombie();
duke@435	428	_rescan = true;
never@2916	429	SWEEP(nm);
duke@435	430	}
duke@435	431	} else {
duke@435	432	assert(nm->is_alive(), "should be alive");
kvn@1637	433
kvn@1637	434	if (UseCodeCacheFlushing) {
kvn@1637	435	if ((nm->method()->code() != nm) && !(nm->is_locked_by_vm()) && !(nm->is_osr_method()) &&
kvn@1637	436	(_traversals > _was_full_traversal+2) && (((uint)nm->compile_id()) < _highest_marked) &&
kvn@1637	437	CodeCache::needs_flushing()) {
kvn@1637	438	// This method has not been called since the forced cleanup happened
kvn@1637	439	nm->make_not_entrant();
kvn@1637	440	}
kvn@1637	441	}
kvn@1637	442
duke@435	443	// Clean-up all inline caches that points to zombie/non-reentrant methods
never@1893	444	MutexLocker cl(CompiledIC_lock);
duke@435	445	nm->cleanup_inline_caches();
never@2916	446	SWEEP(nm);
duke@435	447	}
duke@435	448	}
kvn@1637	449
kvn@1637	450	// Code cache unloading: when compilers notice the code cache is getting full,
kvn@1637	451	// they will call a vm op that comes here. This code attempts to speculatively
kvn@1637	452	// unload the oldest half of the nmethods (based on the compile job id) by
kvn@1637	453	// saving the old code in a list in the CodeCache. Then
never@1893	454	// execution resumes. If a method so marked is not called by the second sweeper
never@1893	455	// stack traversal after the current one, the nmethod will be marked non-entrant and
coleenp@4037	456	// got rid of by normal sweeping. If the method is called, the Method*'s
coleenp@4037	457	// _code field is restored and the Method*/nmethod
kvn@1637	458	// go back to their normal state.
kvn@1637	459	void NMethodSweeper::handle_full_code_cache(bool is_full) {
kvn@1637	460	// Only the first one to notice can advise us to start early cleaning
kvn@1637	461	if (!is_full){
kvn@1637	462	jint old = Atomic::cmpxchg( 1, &_advise_to_sweep, 0 );
kvn@1637	463	if (old != 0) {
kvn@1637	464	return;
kvn@1637	465	}
kvn@1637	466	}
kvn@1637	467
kvn@1637	468	if (is_full) {
kvn@1637	469	// Since code cache is full, immediately stop new compiles
kvn@1637	470	bool did_set = CompileBroker::set_should_compile_new_jobs(CompileBroker::stop_compilation);
kvn@1637	471	if (!did_set) {
kvn@1637	472	// only the first to notice can start the cleaning,
kvn@1637	473	// others will go back and block
kvn@1637	474	return;
kvn@1637	475	}
kvn@1637	476	set_was_full(true);
kvn@1637	477
kvn@1637	478	// If we run out within MinCodeCacheFlushingInterval of the last unload time, give up
kvn@1637	479	jlong now = os::javaTimeMillis();
kvn@1637	480	jlong max_interval = (jlong)MinCodeCacheFlushingInterval * (jlong)1000;
kvn@1637	481	jlong curr_interval = now - _last_was_full;
kvn@1637	482	if (curr_interval < max_interval) {
kvn@1637	483	_rescan = true;
never@1999	484	log_sweep("disable_compiler", "flushing_interval='" UINT64_FORMAT "'",
never@1999	485	curr_interval/1000);
kvn@1637	486	return;
kvn@1637	487	}
kvn@1637	488	}
kvn@1637	489
kvn@1637	490	VM_HandleFullCodeCache op(is_full);
kvn@1637	491	VMThread::execute(&op);
kvn@1637	492
kvn@1637	493	// rescan again as soon as possible
kvn@1637	494	_rescan = true;
kvn@1637	495	}
kvn@1637	496
kvn@1637	497	void NMethodSweeper::speculative_disconnect_nmethods(bool is_full) {
kvn@1637	498	// If there was a race in detecting full code cache, only run
kvn@1637	499	// one vm op for it or keep the compiler shut off
kvn@1637	500
kvn@1637	501	debug_only(jlong start = os::javaTimeMillis();)
kvn@1637	502
kvn@1637	503	if ((!was_full()) && (is_full)) {
kvn@1637	504	if (!CodeCache::needs_flushing()) {
never@1999	505	log_sweep("restart_compiler");
kvn@1637	506	CompileBroker::set_should_compile_new_jobs(CompileBroker::run_compilation);
kvn@1637	507	return;
kvn@1637	508	}
kvn@1637	509	}
kvn@1637	510
kvn@1637	511	// Traverse the code cache trying to dump the oldest nmethods
kvn@1637	512	uint curr_max_comp_id = CompileBroker::get_compilation_id();
kvn@1637	513	uint flush_target = ((curr_max_comp_id - _highest_marked) >> 1) + _highest_marked;
never@1999	514	log_sweep("start_cleaning");
kvn@1637	515
kvn@1637	516	nmethod* nm = CodeCache::alive_nmethod(CodeCache::first());
kvn@1637	517	jint disconnected = 0;
kvn@1637	518	jint made_not_entrant = 0;
kvn@1637	519	while ((nm != NULL)){
kvn@1637	520	uint curr_comp_id = nm->compile_id();
kvn@1637	521
kvn@1637	522	// OSR methods cannot be flushed like this. Also, don't flush native methods
kvn@1637	523	// since they are part of the JDK in most cases
kvn@1637	524	if (nm->is_in_use() && (!nm->is_osr_method()) && (!nm->is_locked_by_vm()) &&
kvn@1637	525	(!nm->is_native_method()) && ((curr_comp_id < flush_target))) {
kvn@1637	526
kvn@1637	527	if ((nm->method()->code() == nm)) {
kvn@1637	528	// This method has not been previously considered for
kvn@1637	529	// unloading or it was restored already
kvn@1637	530	CodeCache::speculatively_disconnect(nm);
kvn@1637	531	disconnected++;
kvn@1637	532	} else if (nm->is_speculatively_disconnected()) {
kvn@1637	533	// This method was previously considered for preemptive unloading and was not called since then
iveresov@2138	534	CompilationPolicy::policy()->delay_compilation(nm->method());
kvn@1637	535	nm->make_not_entrant();
kvn@1637	536	made_not_entrant++;
kvn@1637	537	}
kvn@1637	538
kvn@1637	539	if (curr_comp_id > _highest_marked) {
kvn@1637	540	_highest_marked = curr_comp_id;
kvn@1637	541	}
kvn@1637	542	}
kvn@1637	543	nm = CodeCache::alive_nmethod(CodeCache::next(nm));
kvn@1637	544	}
kvn@1637	545
never@1999	546	log_sweep("stop_cleaning",
never@1999	547	"disconnected='" UINT32_FORMAT "' made_not_entrant='" UINT32_FORMAT "'",
never@1999	548	disconnected, made_not_entrant);
kvn@1637	549
never@1893	550	// Shut off compiler. Sweeper will start over with a new stack scan and
never@1893	551	// traversal cycle and turn it back on if it clears enough space.
kvn@1637	552	if (was_full()) {
kvn@1637	553	_last_was_full = os::javaTimeMillis();
kvn@1637	554	CompileBroker::set_should_compile_new_jobs(CompileBroker::stop_compilation);
kvn@1637	555	}
kvn@1637	556
kvn@1637	557	// After two more traversals the sweeper will get rid of unrestored nmethods
kvn@1637	558	_was_full_traversal = _traversals;
kvn@1637	559	#ifdef ASSERT
kvn@1637	560	jlong end = os::javaTimeMillis();
kvn@1637	561	if(PrintMethodFlushing && Verbose) {
kvn@1637	562	tty->print_cr("### sweeper: unload time: " INT64_FORMAT, end-start);
kvn@1637	563	}
kvn@1637	564	#endif
kvn@1637	565	}
never@1999	566
never@1999	567
never@1999	568	// Print out some state information about the current sweep and the
never@1999	569	// state of the code cache if it's requested.
never@1999	570	void NMethodSweeper::log_sweep(const char* msg, const char* format, ...) {
never@1999	571	if (PrintMethodFlushing) {
iveresov@2764	572	stringStream s;
iveresov@2764	573	// Dump code cache state into a buffer before locking the tty,
iveresov@2764	574	// because log_state() will use locks causing lock conflicts.
iveresov@2764	575	CodeCache::log_state(&s);
iveresov@2764	576
never@1999	577	ttyLocker ttyl;
never@1999	578	tty->print("### sweeper: %s ", msg);
never@1999	579	if (format != NULL) {
never@1999	580	va_list ap;
never@1999	581	va_start(ap, format);
never@1999	582	tty->vprint(format, ap);
never@1999	583	va_end(ap);
never@1999	584	}
iveresov@2764	585	tty->print_cr(s.as_string());
never@1999	586	}
never@1999	587
never@1999	588	if (LogCompilation && (xtty != NULL)) {
iveresov@2764	589	stringStream s;
iveresov@2764	590	// Dump code cache state into a buffer before locking the tty,
iveresov@2764	591	// because log_state() will use locks causing lock conflicts.
iveresov@2764	592	CodeCache::log_state(&s);
iveresov@2764	593
never@1999	594	ttyLocker ttyl;
never@2001	595	xtty->begin_elem("sweeper state='%s' traversals='" INTX_FORMAT "' ", msg, (intx)traversal_count());
never@1999	596	if (format != NULL) {
never@1999	597	va_list ap;
never@1999	598	va_start(ap, format);
never@1999	599	xtty->vprint(format, ap);
never@1999	600	va_end(ap);
never@1999	601	}
iveresov@2764	602	xtty->print(s.as_string());
never@1999	603	xtty->stamp();
never@1999	604	xtty->end_elem();
never@1999	605	}
never@1999	606	}