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

src/share/vm/services/classLoadingService.cpp@f95d63e2154a (annotated)

src/share/vm/services/classLoadingService.cpp

Tue, 23 Nov 2010 13:22:55 -0800

author

stefank

date

Tue, 23 Nov 2010 13:22:55 -0800

changeset 2314

f95d63e2154a

parent 1907

c18cbe5936b8

child 2497

3582bf76420e

permissions

-rw-r--r--

6989984: Use standard include model for Hospot
Summary: Replaced MakeDeps and the includeDB files with more standardized solutions.
Reviewed-by: coleenp, kvn, kamg

duke@435	1	/*
stefank@2314	2	* Copyright (c) 2003, 2010, 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 "classfile/systemDictionary.hpp"
stefank@2314	27	#include "memory/allocation.hpp"
stefank@2314	28	#include "memory/universe.hpp"
stefank@2314	29	#include "oops/oop.inline.hpp"
stefank@2314	30	#include "runtime/mutexLocker.hpp"
stefank@2314	31	#include "services/classLoadingService.hpp"
stefank@2314	32	#include "services/memoryService.hpp"
stefank@2314	33	#include "utilities/dtrace.hpp"
duke@435	34
duke@435	35	#ifdef DTRACE_ENABLED
duke@435	36
duke@435	37	// Only bother with this argument setup if dtrace is available
duke@435	38
duke@435	39	HS_DTRACE_PROBE_DECL4(hotspot, class__loaded, char*, int, oop, bool);
duke@435	40	HS_DTRACE_PROBE_DECL4(hotspot, class__unloaded, char*, int, oop, bool);
duke@435	41
duke@435	42	#define DTRACE_CLASSLOAD_PROBE(type, clss, shared) \
duke@435	43	{ \
duke@435	44	char* data = NULL; \
duke@435	45	int len = 0; \
duke@435	46	symbolOop name = (clss)->name(); \
duke@435	47	if (name != NULL) { \
duke@435	48	data = (char*)name->bytes(); \
duke@435	49	len = name->utf8_length(); \
duke@435	50	} \
duke@435	51	HS_DTRACE_PROBE4(hotspot, class__##type, \
duke@435	52	data, len, (clss)->class_loader(), (shared)); \
duke@435	53	}
duke@435	54
duke@435	55	#else // ndef DTRACE_ENABLED
duke@435	56
duke@435	57	#define DTRACE_CLASSLOAD_PROBE(type, clss, shared)
duke@435	58
duke@435	59	#endif
duke@435	60
duke@435	61	// counters for classes loaded from class files
duke@435	62	PerfCounter* ClassLoadingService::_classes_loaded_count = NULL;
duke@435	63	PerfCounter* ClassLoadingService::_classes_unloaded_count = NULL;
duke@435	64	PerfCounter* ClassLoadingService::_classbytes_loaded = NULL;
duke@435	65	PerfCounter* ClassLoadingService::_classbytes_unloaded = NULL;
duke@435	66
duke@435	67	// counters for classes loaded from shared archive
duke@435	68	PerfCounter* ClassLoadingService::_shared_classes_loaded_count = NULL;
duke@435	69	PerfCounter* ClassLoadingService::_shared_classes_unloaded_count = NULL;
duke@435	70	PerfCounter* ClassLoadingService::_shared_classbytes_loaded = NULL;
duke@435	71	PerfCounter* ClassLoadingService::_shared_classbytes_unloaded = NULL;
duke@435	72	PerfVariable* ClassLoadingService::_class_methods_size = NULL;
duke@435	73
duke@435	74	void ClassLoadingService::init() {
duke@435	75	EXCEPTION_MARK;
duke@435	76
duke@435	77	// These counters are for java.lang.management API support.
duke@435	78	// They are created even if -XX:-UsePerfData is set and in
duke@435	79	// that case, they will be allocated on C heap.
duke@435	80	_classes_loaded_count =
duke@435	81	PerfDataManager::create_counter(JAVA_CLS, "loadedClasses",
duke@435	82	PerfData::U_Events, CHECK);
duke@435	83
duke@435	84	_classes_unloaded_count =
duke@435	85	PerfDataManager::create_counter(JAVA_CLS, "unloadedClasses",
duke@435	86	PerfData::U_Events, CHECK);
duke@435	87
duke@435	88	_shared_classes_loaded_count =
duke@435	89	PerfDataManager::create_counter(JAVA_CLS, "sharedLoadedClasses",
duke@435	90	PerfData::U_Events, CHECK);
duke@435	91
duke@435	92	_shared_classes_unloaded_count =
duke@435	93	PerfDataManager::create_counter(JAVA_CLS, "sharedUnloadedClasses",
duke@435	94	PerfData::U_Events, CHECK);
duke@435	95
duke@435	96	if (UsePerfData) {
duke@435	97	_classbytes_loaded =
duke@435	98	PerfDataManager::create_counter(SUN_CLS, "loadedBytes",
duke@435	99	PerfData::U_Bytes, CHECK);
duke@435	100
duke@435	101	_classbytes_unloaded =
duke@435	102	PerfDataManager::create_counter(SUN_CLS, "unloadedBytes",
duke@435	103	PerfData::U_Bytes, CHECK);
duke@435	104	_shared_classbytes_loaded =
duke@435	105	PerfDataManager::create_counter(SUN_CLS, "sharedLoadedBytes",
duke@435	106	PerfData::U_Bytes, CHECK);
duke@435	107
duke@435	108	_shared_classbytes_unloaded =
duke@435	109	PerfDataManager::create_counter(SUN_CLS, "sharedUnloadedBytes",
duke@435	110	PerfData::U_Bytes, CHECK);
duke@435	111	_class_methods_size =
duke@435	112	PerfDataManager::create_variable(SUN_CLS, "methodBytes",
duke@435	113	PerfData::U_Bytes, CHECK);
duke@435	114	}
duke@435	115	}
duke@435	116
duke@435	117	void ClassLoadingService::notify_class_unloaded(instanceKlass* k) {
duke@435	118	DTRACE_CLASSLOAD_PROBE(unloaded, k, false);
duke@435	119	// Classes that can be unloaded must be non-shared
duke@435	120	_classes_unloaded_count->inc();
duke@435	121
duke@435	122	if (UsePerfData) {
duke@435	123	// add the class size
duke@435	124	size_t size = compute_class_size(k);
duke@435	125	_classbytes_unloaded->inc(size);
duke@435	126
duke@435	127	// Compute method size & subtract from running total.
duke@435	128	// We are called during phase 1 of mark sweep, so it's
duke@435	129	// still ok to iterate through methodOops here.
duke@435	130	objArrayOop methods = k->methods();
duke@435	131	for (int i = 0; i < methods->length(); i++) {
duke@435	132	_class_methods_size->inc(-methods->obj_at(i)->size());
duke@435	133	}
duke@435	134	}
duke@435	135
duke@435	136	if (TraceClassUnloading) {
duke@435	137	ResourceMark rm;
ysr@1582	138	tty->print_cr("[Unloading class %s]", k->external_name());
duke@435	139	}
duke@435	140	}
duke@435	141
duke@435	142	void ClassLoadingService::notify_class_loaded(instanceKlass* k, bool shared_class) {
duke@435	143	DTRACE_CLASSLOAD_PROBE(loaded, k, shared_class);
duke@435	144	PerfCounter* classes_counter = (shared_class ? _shared_classes_loaded_count
duke@435	145	: _classes_loaded_count);
duke@435	146	// increment the count
duke@435	147	classes_counter->inc();
duke@435	148
duke@435	149	if (UsePerfData) {
duke@435	150	PerfCounter* classbytes_counter = (shared_class ? _shared_classbytes_loaded
duke@435	151	: _classbytes_loaded);
duke@435	152	// add the class size
duke@435	153	size_t size = compute_class_size(k);
duke@435	154	classbytes_counter->inc(size);
duke@435	155	}
duke@435	156	}
duke@435	157
duke@435	158	size_t ClassLoadingService::compute_class_size(instanceKlass* k) {
duke@435	159	// lifted from ClassStatistics.do_class(klassOop k)
duke@435	160
duke@435	161	size_t class_size = 0;
duke@435	162
duke@435	163	class_size += k->as_klassOop()->size();
duke@435	164
duke@435	165	if (k->oop_is_instance()) {
duke@435	166	class_size += k->methods()->size();
duke@435	167	class_size += k->constants()->size();
duke@435	168	class_size += k->local_interfaces()->size();
duke@435	169	class_size += k->transitive_interfaces()->size();
duke@435	170	// We do not have to count implementors, since we only store one!
duke@435	171	class_size += k->fields()->size();
duke@435	172	}
duke@435	173	return class_size * oopSize;
duke@435	174	}
duke@435	175
duke@435	176
duke@435	177	bool ClassLoadingService::set_verbose(bool verbose) {
duke@435	178	MutexLocker m(Management_lock);
duke@435	179
duke@435	180	// verbose will be set to the previous value
duke@435	181	bool succeed = CommandLineFlags::boolAtPut((char*)"TraceClassLoading", &verbose, MANAGEMENT);
duke@435	182	assert(succeed, "Setting TraceClassLoading flag fails");
duke@435	183	reset_trace_class_unloading();
duke@435	184
duke@435	185	return verbose;
duke@435	186	}
duke@435	187
duke@435	188	// Caller to this function must own Management_lock
duke@435	189	void ClassLoadingService::reset_trace_class_unloading() {
duke@435	190	assert(Management_lock->owned_by_self(), "Must own the Management_lock");
duke@435	191	bool value = MemoryService::get_verbose() || ClassLoadingService::get_verbose();
duke@435	192	bool succeed = CommandLineFlags::boolAtPut((char*)"TraceClassUnloading", &value, MANAGEMENT);
duke@435	193	assert(succeed, "Setting TraceClassUnLoading flag fails");
duke@435	194	}
duke@435	195
duke@435	196	GrowableArray<KlassHandle>* LoadedClassesEnumerator::_loaded_classes = NULL;
duke@435	197	Thread* LoadedClassesEnumerator::_current_thread = NULL;
duke@435	198
duke@435	199	LoadedClassesEnumerator::LoadedClassesEnumerator(Thread* cur_thread) {
duke@435	200	assert(cur_thread == Thread::current(), "Check current thread");
duke@435	201
duke@435	202	int init_size = ClassLoadingService::loaded_class_count();
duke@435	203	_klass_handle_array = new GrowableArray<KlassHandle>(init_size);
duke@435	204
duke@435	205	// For consistency of the loaded classes, grab the SystemDictionary lock
duke@435	206	MutexLocker sd_mutex(SystemDictionary_lock);
duke@435	207
duke@435	208	// Set _loaded_classes and _current_thread and begin enumerating all classes.
duke@435	209	// Only one thread will do the enumeration at a time.
duke@435	210	// These static variables are needed and they are used by the static method
duke@435	211	// add_loaded_class called from classes_do().
duke@435	212	_loaded_classes = _klass_handle_array;
duke@435	213	_current_thread = cur_thread;
duke@435	214
duke@435	215	SystemDictionary::classes_do(&add_loaded_class);
duke@435	216
duke@435	217	// FIXME: Exclude array klasses for now
duke@435	218	// Universe::basic_type_classes_do(&add_loaded_class);
duke@435	219	}