Mercurial > hg > truffle
annotate src/share/vm/services/classLoadingService.cpp @ 8733:9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate().
Reviewed-by: johnc, ysr
Contributed-by: tamao <tao.mao@oracle.com>
| author | tamao |
|---|---|
| date | Tue, 05 Mar 2013 15:36:56 -0800 |
| parents | db9981fd3124 |
| children | 190899198332 72b7e96c1922 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
2 * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1147
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1147
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1147
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "memory/allocation.hpp" | |
| 28 #include "memory/universe.hpp" | |
| 29 #include "oops/oop.inline.hpp" | |
| 30 #include "runtime/mutexLocker.hpp" | |
| 31 #include "services/classLoadingService.hpp" | |
| 32 #include "services/memoryService.hpp" | |
| 33 #include "utilities/dtrace.hpp" | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6854
diff
changeset
|
34 #include "utilities/macros.hpp" |
| 0 | 35 |
| 36 #ifdef DTRACE_ENABLED | |
| 37 | |
| 38 // Only bother with this argument setup if dtrace is available | |
| 39 | |
| 4006 | 40 #ifndef USDT2 |
| 41 | |
| 0 | 42 HS_DTRACE_PROBE_DECL4(hotspot, class__loaded, char*, int, oop, bool); |
| 43 HS_DTRACE_PROBE_DECL4(hotspot, class__unloaded, char*, int, oop, bool); | |
| 44 | |
| 45 #define DTRACE_CLASSLOAD_PROBE(type, clss, shared) \ | |
| 46 { \ | |
| 47 char* data = NULL; \ | |
| 48 int len = 0; \ | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
49 Symbol* name = (clss)->name(); \ |
| 0 | 50 if (name != NULL) { \ |
| 51 data = (char*)name->bytes(); \ | |
| 52 len = name->utf8_length(); \ | |
| 53 } \ | |
| 54 HS_DTRACE_PROBE4(hotspot, class__##type, \ | |
| 55 data, len, (clss)->class_loader(), (shared)); \ | |
| 56 } | |
| 57 | |
| 4006 | 58 #else /* USDT2 */ |
| 59 | |
| 60 #define HOTSPOT_CLASS_unloaded HOTSPOT_CLASS_UNLOADED | |
| 61 #define HOTSPOT_CLASS_loaded HOTSPOT_CLASS_LOADED | |
| 62 #define DTRACE_CLASSLOAD_PROBE(type, clss, shared) \ | |
| 63 { \ | |
| 64 char* data = NULL; \ | |
| 65 int len = 0; \ | |
| 66 Symbol* name = (clss)->name(); \ | |
| 67 if (name != NULL) { \ | |
| 68 data = (char*)name->bytes(); \ | |
| 69 len = name->utf8_length(); \ | |
| 70 } \ | |
| 71 HOTSPOT_CLASS_##type( /* type = unloaded, loaded */ \ | |
| 72 data, len, (clss)->class_loader(), (shared)); \ | |
| 73 } | |
| 74 | |
| 75 #endif /* USDT2 */ | |
| 0 | 76 #else // ndef DTRACE_ENABLED |
| 77 | |
| 78 #define DTRACE_CLASSLOAD_PROBE(type, clss, shared) | |
| 79 | |
| 80 #endif | |
| 81 | |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
82 #if INCLUDE_MANAGEMENT |
| 0 | 83 // counters for classes loaded from class files |
| 84 PerfCounter* ClassLoadingService::_classes_loaded_count = NULL; | |
| 85 PerfCounter* ClassLoadingService::_classes_unloaded_count = NULL; | |
| 86 PerfCounter* ClassLoadingService::_classbytes_loaded = NULL; | |
| 87 PerfCounter* ClassLoadingService::_classbytes_unloaded = NULL; | |
| 88 | |
| 89 // counters for classes loaded from shared archive | |
| 90 PerfCounter* ClassLoadingService::_shared_classes_loaded_count = NULL; | |
| 91 PerfCounter* ClassLoadingService::_shared_classes_unloaded_count = NULL; | |
| 92 PerfCounter* ClassLoadingService::_shared_classbytes_loaded = NULL; | |
| 93 PerfCounter* ClassLoadingService::_shared_classbytes_unloaded = NULL; | |
| 94 PerfVariable* ClassLoadingService::_class_methods_size = NULL; | |
| 95 | |
| 96 void ClassLoadingService::init() { | |
| 97 EXCEPTION_MARK; | |
| 98 | |
| 99 // These counters are for java.lang.management API support. | |
| 100 // They are created even if -XX:-UsePerfData is set and in | |
| 101 // that case, they will be allocated on C heap. | |
| 102 _classes_loaded_count = | |
| 103 PerfDataManager::create_counter(JAVA_CLS, "loadedClasses", | |
| 104 PerfData::U_Events, CHECK); | |
| 105 | |
| 106 _classes_unloaded_count = | |
| 107 PerfDataManager::create_counter(JAVA_CLS, "unloadedClasses", | |
| 108 PerfData::U_Events, CHECK); | |
| 109 | |
| 110 _shared_classes_loaded_count = | |
| 111 PerfDataManager::create_counter(JAVA_CLS, "sharedLoadedClasses", | |
| 112 PerfData::U_Events, CHECK); | |
| 113 | |
| 114 _shared_classes_unloaded_count = | |
| 115 PerfDataManager::create_counter(JAVA_CLS, "sharedUnloadedClasses", | |
| 116 PerfData::U_Events, CHECK); | |
| 117 | |
| 118 if (UsePerfData) { | |
| 119 _classbytes_loaded = | |
| 120 PerfDataManager::create_counter(SUN_CLS, "loadedBytes", | |
| 121 PerfData::U_Bytes, CHECK); | |
| 122 | |
| 123 _classbytes_unloaded = | |
| 124 PerfDataManager::create_counter(SUN_CLS, "unloadedBytes", | |
| 125 PerfData::U_Bytes, CHECK); | |
| 126 _shared_classbytes_loaded = | |
| 127 PerfDataManager::create_counter(SUN_CLS, "sharedLoadedBytes", | |
| 128 PerfData::U_Bytes, CHECK); | |
| 129 | |
| 130 _shared_classbytes_unloaded = | |
| 131 PerfDataManager::create_counter(SUN_CLS, "sharedUnloadedBytes", | |
| 132 PerfData::U_Bytes, CHECK); | |
| 133 _class_methods_size = | |
| 134 PerfDataManager::create_variable(SUN_CLS, "methodBytes", | |
| 135 PerfData::U_Bytes, CHECK); | |
| 136 } | |
| 137 } | |
| 138 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
139 void ClassLoadingService::notify_class_unloaded(InstanceKlass* k) { |
| 0 | 140 DTRACE_CLASSLOAD_PROBE(unloaded, k, false); |
| 141 // Classes that can be unloaded must be non-shared | |
| 142 _classes_unloaded_count->inc(); | |
| 143 | |
| 144 if (UsePerfData) { | |
| 145 // add the class size | |
| 146 size_t size = compute_class_size(k); | |
| 147 _classbytes_unloaded->inc(size); | |
| 148 | |
| 149 // Compute method size & subtract from running total. | |
| 150 // We are called during phase 1 of mark sweep, so it's | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
151 // still ok to iterate through Method*s here. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
152 Array<Method*>* methods = k->methods(); |
| 0 | 153 for (int i = 0; i < methods->length(); i++) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
154 _class_methods_size->inc(-methods->at(i)->size()); |
| 0 | 155 } |
| 156 } | |
| 157 | |
| 158 if (TraceClassUnloading) { | |
| 159 ResourceMark rm; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
160 tty->print_cr("[Unloading class %s " INTPTR_FORMAT "]", k->external_name(), k); |
| 0 | 161 } |
| 162 } | |
| 163 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
164 void ClassLoadingService::notify_class_loaded(InstanceKlass* k, bool shared_class) { |
| 0 | 165 DTRACE_CLASSLOAD_PROBE(loaded, k, shared_class); |
| 166 PerfCounter* classes_counter = (shared_class ? _shared_classes_loaded_count | |
| 167 : _classes_loaded_count); | |
| 168 // increment the count | |
| 169 classes_counter->inc(); | |
| 170 | |
| 171 if (UsePerfData) { | |
| 172 PerfCounter* classbytes_counter = (shared_class ? _shared_classbytes_loaded | |
| 173 : _classbytes_loaded); | |
| 174 // add the class size | |
| 175 size_t size = compute_class_size(k); | |
| 176 classbytes_counter->inc(size); | |
| 177 } | |
| 178 } | |
| 179 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
180 size_t ClassLoadingService::compute_class_size(InstanceKlass* k) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
181 // lifted from ClassStatistics.do_class(Klass* k) |
| 0 | 182 |
| 183 size_t class_size = 0; | |
| 184 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
185 class_size += k->size(); |
| 0 | 186 |
| 187 if (k->oop_is_instance()) { | |
| 188 class_size += k->methods()->size(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
189 // FIXME: Need to count the contents of methods |
| 0 | 190 class_size += k->constants()->size(); |
| 191 class_size += k->local_interfaces()->size(); | |
| 192 class_size += k->transitive_interfaces()->size(); | |
| 193 // We do not have to count implementors, since we only store one! | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
194 // FIXME: How should these be accounted for, now when they have moved. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
195 //class_size += k->fields()->size(); |
| 0 | 196 } |
| 197 return class_size * oopSize; | |
| 198 } | |
| 199 | |
| 200 | |
| 201 bool ClassLoadingService::set_verbose(bool verbose) { | |
| 202 MutexLocker m(Management_lock); | |
| 203 | |
| 204 // verbose will be set to the previous value | |
| 205 bool succeed = CommandLineFlags::boolAtPut((char*)"TraceClassLoading", &verbose, MANAGEMENT); | |
| 206 assert(succeed, "Setting TraceClassLoading flag fails"); | |
| 207 reset_trace_class_unloading(); | |
| 208 | |
| 209 return verbose; | |
| 210 } | |
| 211 | |
| 212 // Caller to this function must own Management_lock | |
| 213 void ClassLoadingService::reset_trace_class_unloading() { | |
| 214 assert(Management_lock->owned_by_self(), "Must own the Management_lock"); | |
| 215 bool value = MemoryService::get_verbose() || ClassLoadingService::get_verbose(); | |
| 216 bool succeed = CommandLineFlags::boolAtPut((char*)"TraceClassUnloading", &value, MANAGEMENT); | |
| 217 assert(succeed, "Setting TraceClassUnLoading flag fails"); | |
| 218 } | |
| 219 | |
| 220 GrowableArray<KlassHandle>* LoadedClassesEnumerator::_loaded_classes = NULL; | |
| 221 Thread* LoadedClassesEnumerator::_current_thread = NULL; | |
| 222 | |
| 223 LoadedClassesEnumerator::LoadedClassesEnumerator(Thread* cur_thread) { | |
| 224 assert(cur_thread == Thread::current(), "Check current thread"); | |
| 225 | |
| 226 int init_size = ClassLoadingService::loaded_class_count(); | |
| 227 _klass_handle_array = new GrowableArray<KlassHandle>(init_size); | |
| 228 | |
| 229 // For consistency of the loaded classes, grab the SystemDictionary lock | |
| 230 MutexLocker sd_mutex(SystemDictionary_lock); | |
| 231 | |
| 232 // Set _loaded_classes and _current_thread and begin enumerating all classes. | |
| 233 // Only one thread will do the enumeration at a time. | |
| 234 // These static variables are needed and they are used by the static method | |
| 235 // add_loaded_class called from classes_do(). | |
| 236 _loaded_classes = _klass_handle_array; | |
| 237 _current_thread = cur_thread; | |
| 238 | |
| 239 SystemDictionary::classes_do(&add_loaded_class); | |
| 240 | |
| 241 // FIXME: Exclude array klasses for now | |
| 242 // Universe::basic_type_classes_do(&add_loaded_class); | |
| 243 } | |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
244 |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
245 #endif // INCLUDE_MANAGEMENT |