Mercurial > hg > graal-compiler
annotate src/share/vm/services/memoryPool.cpp @ 10185:d50cc62e94ff
8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t
Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime.
Reviewed-by: twisti, johnc
Contributed-by: Martin Doerr <martin.doerr@sap.com>
| author | johnc |
|---|---|
| date | Wed, 24 Apr 2013 14:48:43 -0700 |
| parents | 42e370795a39 |
| children | 71963b3f802a |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
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:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
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:
0
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "classfile/vmSymbols.hpp" | |
| 28 #include "oops/oop.inline.hpp" | |
| 29 #include "runtime/handles.inline.hpp" | |
| 30 #include "runtime/javaCalls.hpp" | |
| 31 #include "services/lowMemoryDetector.hpp" | |
| 32 #include "services/management.hpp" | |
| 33 #include "services/memoryManager.hpp" | |
| 34 #include "services/memoryPool.hpp" | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
35 #include "utilities/macros.hpp" |
| 0 | 36 |
| 37 MemoryPool::MemoryPool(const char* name, | |
| 38 PoolType type, | |
| 39 size_t init_size, | |
| 40 size_t max_size, | |
| 41 bool support_usage_threshold, | |
| 42 bool support_gc_threshold) { | |
| 43 _name = name; | |
| 44 _initial_size = init_size; | |
| 45 _max_size = max_size; | |
| 46 _memory_pool_obj = NULL; | |
| 47 _available_for_allocation = true; | |
| 48 _num_managers = 0; | |
| 49 _type = type; | |
| 50 | |
| 51 // initialize the max and init size of collection usage | |
| 52 _after_gc_usage = MemoryUsage(_initial_size, 0, 0, _max_size); | |
| 53 | |
| 54 _usage_sensor = NULL; | |
| 55 _gc_usage_sensor = NULL; | |
| 56 // usage threshold supports both high and low threshold | |
| 57 _usage_threshold = new ThresholdSupport(support_usage_threshold, support_usage_threshold); | |
| 58 // gc usage threshold supports only high threshold | |
| 59 _gc_usage_threshold = new ThresholdSupport(support_gc_threshold, support_gc_threshold); | |
| 60 } | |
| 61 | |
| 62 void MemoryPool::add_manager(MemoryManager* mgr) { | |
| 63 assert(_num_managers < MemoryPool::max_num_managers, "_num_managers exceeds the max"); | |
| 64 if (_num_managers < MemoryPool::max_num_managers) { | |
| 65 _managers[_num_managers] = mgr; | |
| 66 _num_managers++; | |
| 67 } | |
| 68 } | |
| 69 | |
| 70 | |
| 71 // Returns an instanceHandle of a MemoryPool object. | |
| 72 // It creates a MemoryPool instance when the first time | |
| 73 // this function is called. | |
| 74 instanceOop MemoryPool::get_memory_pool_instance(TRAPS) { | |
| 75 // Must do an acquire so as to force ordering of subsequent | |
| 76 // loads from anything _memory_pool_obj points to or implies. | |
| 77 instanceOop pool_obj = (instanceOop)OrderAccess::load_ptr_acquire(&_memory_pool_obj); | |
| 78 if (pool_obj == NULL) { | |
| 79 // It's ok for more than one thread to execute the code up to the locked region. | |
| 80 // Extra pool instances will just be gc'ed. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2426
diff
changeset
|
81 Klass* k = Management::sun_management_ManagementFactory_klass(CHECK_NULL); |
| 0 | 82 instanceKlassHandle ik(THREAD, k); |
| 83 | |
| 84 Handle pool_name = java_lang_String::create_from_str(_name, CHECK_NULL); | |
| 85 jlong usage_threshold_value = (_usage_threshold->is_high_threshold_supported() ? 0 : -1L); | |
| 86 jlong gc_usage_threshold_value = (_gc_usage_threshold->is_high_threshold_supported() ? 0 : -1L); | |
| 87 | |
| 88 JavaValue result(T_OBJECT); | |
| 89 JavaCallArguments args; | |
| 90 args.push_oop(pool_name); // Argument 1 | |
| 91 args.push_int((int) is_heap()); // Argument 2 | |
| 92 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
93 Symbol* method_name = vmSymbols::createMemoryPool_name(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
94 Symbol* signature = vmSymbols::createMemoryPool_signature(); |
| 0 | 95 |
| 96 args.push_long(usage_threshold_value); // Argument 3 | |
| 97 args.push_long(gc_usage_threshold_value); // Argument 4 | |
| 98 | |
| 99 JavaCalls::call_static(&result, | |
| 100 ik, | |
| 101 method_name, | |
| 102 signature, | |
| 103 &args, | |
| 104 CHECK_NULL); | |
| 105 | |
| 106 instanceOop p = (instanceOop) result.get_jobject(); | |
| 107 instanceHandle pool(THREAD, p); | |
| 108 | |
| 109 { | |
| 110 // Get lock since another thread may have create the instance | |
| 111 MutexLocker ml(Management_lock); | |
| 112 | |
| 113 // Check if another thread has created the pool. We reload | |
| 114 // _memory_pool_obj here because some other thread may have | |
| 115 // initialized it while we were executing the code before the lock. | |
| 116 // | |
| 117 // The lock has done an acquire, so the load can't float above it, | |
| 118 // but we need to do a load_acquire as above. | |
| 119 pool_obj = (instanceOop)OrderAccess::load_ptr_acquire(&_memory_pool_obj); | |
| 120 if (pool_obj != NULL) { | |
| 121 return pool_obj; | |
| 122 } | |
| 123 | |
| 124 // Get the address of the object we created via call_special. | |
| 125 pool_obj = pool(); | |
| 126 | |
| 127 // Use store barrier to make sure the memory accesses associated | |
| 128 // with creating the pool are visible before publishing its address. | |
| 129 // The unlock will publish the store to _memory_pool_obj because | |
| 130 // it does a release first. | |
| 131 OrderAccess::release_store_ptr(&_memory_pool_obj, pool_obj); | |
| 132 } | |
| 133 } | |
| 134 | |
| 135 return pool_obj; | |
| 136 } | |
| 137 | |
| 138 inline static size_t get_max_value(size_t val1, size_t val2) { | |
| 139 return (val1 > val2 ? val1 : val2); | |
| 140 } | |
| 141 | |
| 142 void MemoryPool::record_peak_memory_usage() { | |
| 143 // Caller in JDK is responsible for synchronization - | |
| 144 // acquire the lock for this memory pool before calling VM | |
| 145 MemoryUsage usage = get_memory_usage(); | |
| 146 size_t peak_used = get_max_value(usage.used(), _peak_usage.used()); | |
| 147 size_t peak_committed = get_max_value(usage.committed(), _peak_usage.committed()); | |
| 148 size_t peak_max_size = get_max_value(usage.max_size(), _peak_usage.max_size()); | |
| 149 | |
| 150 _peak_usage = MemoryUsage(initial_size(), peak_used, peak_committed, peak_max_size); | |
| 151 } | |
| 152 | |
| 153 static void set_sensor_obj_at(SensorInfo** sensor_ptr, instanceHandle sh) { | |
| 154 assert(*sensor_ptr == NULL, "Should be called only once"); | |
| 155 SensorInfo* sensor = new SensorInfo(); | |
| 156 sensor->set_sensor(sh()); | |
| 157 *sensor_ptr = sensor; | |
| 158 } | |
| 159 | |
| 160 void MemoryPool::set_usage_sensor_obj(instanceHandle sh) { | |
| 161 set_sensor_obj_at(&_usage_sensor, sh); | |
| 162 } | |
| 163 | |
| 164 void MemoryPool::set_gc_usage_sensor_obj(instanceHandle sh) { | |
| 165 set_sensor_obj_at(&_gc_usage_sensor, sh); | |
| 166 } | |
| 167 | |
| 168 void MemoryPool::oops_do(OopClosure* f) { | |
| 169 f->do_oop((oop*) &_memory_pool_obj); | |
| 170 if (_usage_sensor != NULL) { | |
| 171 _usage_sensor->oops_do(f); | |
| 172 } | |
| 173 if (_gc_usage_sensor != NULL) { | |
| 174 _gc_usage_sensor->oops_do(f); | |
| 175 } | |
| 176 } | |
| 177 | |
| 178 ContiguousSpacePool::ContiguousSpacePool(ContiguousSpace* space, | |
| 179 const char* name, | |
| 180 PoolType type, | |
| 181 size_t max_size, | |
| 182 bool support_usage_threshold) : | |
| 183 CollectedMemoryPool(name, type, space->capacity(), max_size, | |
| 184 support_usage_threshold), _space(space) { | |
| 185 } | |
| 186 | |
| 187 MemoryUsage ContiguousSpacePool::get_memory_usage() { | |
| 188 size_t maxSize = (available_for_allocation() ? max_size() : 0); | |
| 189 size_t used = used_in_bytes(); | |
| 190 size_t committed = _space->capacity(); | |
| 191 | |
| 192 return MemoryUsage(initial_size(), used, committed, maxSize); | |
| 193 } | |
| 194 | |
| 195 SurvivorContiguousSpacePool::SurvivorContiguousSpacePool(DefNewGeneration* gen, | |
| 196 const char* name, | |
| 197 PoolType type, | |
| 198 size_t max_size, | |
| 199 bool support_usage_threshold) : | |
| 200 CollectedMemoryPool(name, type, gen->from()->capacity(), max_size, | |
| 201 support_usage_threshold), _gen(gen) { | |
| 202 } | |
| 203 | |
| 204 MemoryUsage SurvivorContiguousSpacePool::get_memory_usage() { | |
| 205 size_t maxSize = (available_for_allocation() ? max_size() : 0); | |
| 206 size_t used = used_in_bytes(); | |
| 207 size_t committed = committed_in_bytes(); | |
| 208 | |
| 209 return MemoryUsage(initial_size(), used, committed, maxSize); | |
| 210 } | |
| 211 | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
212 #if INCLUDE_ALL_GCS |
| 0 | 213 CompactibleFreeListSpacePool::CompactibleFreeListSpacePool(CompactibleFreeListSpace* space, |
| 214 const char* name, | |
| 215 PoolType type, | |
| 216 size_t max_size, | |
| 217 bool support_usage_threshold) : | |
| 218 CollectedMemoryPool(name, type, space->capacity(), max_size, | |
| 219 support_usage_threshold), _space(space) { | |
| 220 } | |
| 221 | |
| 222 MemoryUsage CompactibleFreeListSpacePool::get_memory_usage() { | |
| 223 size_t maxSize = (available_for_allocation() ? max_size() : 0); | |
| 224 size_t used = used_in_bytes(); | |
| 225 size_t committed = _space->capacity(); | |
| 226 | |
| 227 return MemoryUsage(initial_size(), used, committed, maxSize); | |
| 228 } | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
229 #endif // INCLUDE_ALL_GCS |
| 0 | 230 |
| 231 GenerationPool::GenerationPool(Generation* gen, | |
| 232 const char* name, | |
| 233 PoolType type, | |
| 234 bool support_usage_threshold) : | |
| 235 CollectedMemoryPool(name, type, gen->capacity(), gen->max_capacity(), | |
| 236 support_usage_threshold), _gen(gen) { | |
| 237 } | |
| 238 | |
| 239 MemoryUsage GenerationPool::get_memory_usage() { | |
| 240 size_t used = used_in_bytes(); | |
| 241 size_t committed = _gen->capacity(); | |
| 242 size_t maxSize = (available_for_allocation() ? max_size() : 0); | |
| 243 | |
| 244 return MemoryUsage(initial_size(), used, committed, maxSize); | |
| 245 } | |
| 246 | |
| 247 CodeHeapPool::CodeHeapPool(CodeHeap* codeHeap, const char* name, bool support_usage_threshold) : | |
| 248 MemoryPool(name, NonHeap, codeHeap->capacity(), codeHeap->max_capacity(), | |
| 249 support_usage_threshold, false), _codeHeap(codeHeap) { | |
| 250 } | |
| 251 | |
| 252 MemoryUsage CodeHeapPool::get_memory_usage() { | |
| 253 size_t used = used_in_bytes(); | |
| 254 size_t committed = _codeHeap->capacity(); | |
| 255 size_t maxSize = (available_for_allocation() ? max_size() : 0); | |
| 256 | |
| 257 return MemoryUsage(initial_size(), used, committed, maxSize); | |
| 258 } |