42 #include "oops/typeArrayOop.inline.hpp" 43 #include "prims/jvmtiEventController.hpp" 44 #include "prims/jvmtiEventController.inline.hpp" 45 #include "prims/jvmtiExport.hpp" 46 #include "prims/jvmtiImpl.hpp" 47 #include "prims/jvmtiTagMap.hpp" 48 #include "runtime/biasedLocking.hpp" 49 #include "runtime/frame.inline.hpp" 50 #include "runtime/handles.inline.hpp" 51 #include "runtime/javaCalls.hpp" 52 #include "runtime/jniHandles.inline.hpp" 53 #include "runtime/mutex.hpp" 54 #include "runtime/mutexLocker.hpp" 55 #include "runtime/reflectionUtils.hpp" 56 #include "runtime/thread.inline.hpp" 57 #include "runtime/threadSMR.hpp" 58 #include "runtime/vframe.hpp" 59 #include "runtime/vmThread.hpp" 60 #include "runtime/vm_operations.hpp" 61 #include "utilities/macros.hpp" 62 63 // JvmtiTagHashmapEntry 64 // 65 // Each entry encapsulates a reference to the tagged object 66 // and the tag value. In addition an entry includes a next pointer which 67 // is used to chain entries together. 68 69 class JvmtiTagHashmapEntry : public CHeapObj<mtInternal> { 70 private: 71 friend class JvmtiTagMap; 72 73 oop _object; // tagged object 74 jlong _tag; // the tag 75 JvmtiTagHashmapEntry* _next; // next on the list 76 77 inline void init(oop object, jlong tag) { 78 _object = object; 79 _tag = tag; 80 _next = NULL; 81 } 161 _size_index = size_index; 162 _size = initial_size; 163 _entry_count = 0; 164 _trace_threshold = initial_trace_threshold; 165 _load_factor = load_factor; 166 _resize_threshold = (int)(_load_factor * _size); 167 _resizing_enabled = true; 168 size_t s = initial_size * sizeof(JvmtiTagHashmapEntry*); 169 _table = (JvmtiTagHashmapEntry**)os::malloc(s, mtInternal); 170 if (_table == NULL) { 171 vm_exit_out_of_memory(s, OOM_MALLOC_ERROR, 172 "unable to allocate initial hashtable for jvmti object tags"); 173 } 174 for (int i=0; i<initial_size; i++) { 175 _table[i] = NULL; 176 } 177 } 178 179 // hash a given key (oop) with the specified size 180 static unsigned int hash(oop key, int size) { 181 // shift right to get better distribution (as these bits will be zero 182 // with aligned addresses) 183 unsigned int addr = (unsigned int)(cast_from_oop<intptr_t>(key)); 184 #ifdef _LP64 185 return (addr >> 3) % size; 186 #else 187 return (addr >> 2) % size; 188 #endif 189 } 190 191 // hash a given key (oop) 192 unsigned int hash(oop key) { 193 return hash(key, _size); 194 } 195 196 // resize the hashmap - allocates a large table and re-hashes 197 // all entries into the new table. 198 void resize() { 199 int new_size_index = _size_index+1; 200 int new_size = _sizes[new_size_index]; | 42 #include "oops/typeArrayOop.inline.hpp" 43 #include "prims/jvmtiEventController.hpp" 44 #include "prims/jvmtiEventController.inline.hpp" 45 #include "prims/jvmtiExport.hpp" 46 #include "prims/jvmtiImpl.hpp" 47 #include "prims/jvmtiTagMap.hpp" 48 #include "runtime/biasedLocking.hpp" 49 #include "runtime/frame.inline.hpp" 50 #include "runtime/handles.inline.hpp" 51 #include "runtime/javaCalls.hpp" 52 #include "runtime/jniHandles.inline.hpp" 53 #include "runtime/mutex.hpp" 54 #include "runtime/mutexLocker.hpp" 55 #include "runtime/reflectionUtils.hpp" 56 #include "runtime/thread.inline.hpp" 57 #include "runtime/threadSMR.hpp" 58 #include "runtime/vframe.hpp" 59 #include "runtime/vmThread.hpp" 60 #include "runtime/vm_operations.hpp" 61 #include "utilities/macros.hpp" 62 #if INCLUDE_ZGC 63 #include "gc/z/zGlobals.hpp" 64 #endif 65 66 // JvmtiTagHashmapEntry 67 // 68 // Each entry encapsulates a reference to the tagged object 69 // and the tag value. In addition an entry includes a next pointer which 70 // is used to chain entries together. 71 72 class JvmtiTagHashmapEntry : public CHeapObj<mtInternal> { 73 private: 74 friend class JvmtiTagMap; 75 76 oop _object; // tagged object 77 jlong _tag; // the tag 78 JvmtiTagHashmapEntry* _next; // next on the list 79 80 inline void init(oop object, jlong tag) { 81 _object = object; 82 _tag = tag; 83 _next = NULL; 84 } 164 _size_index = size_index; 165 _size = initial_size; 166 _entry_count = 0; 167 _trace_threshold = initial_trace_threshold; 168 _load_factor = load_factor; 169 _resize_threshold = (int)(_load_factor * _size); 170 _resizing_enabled = true; 171 size_t s = initial_size * sizeof(JvmtiTagHashmapEntry*); 172 _table = (JvmtiTagHashmapEntry**)os::malloc(s, mtInternal); 173 if (_table == NULL) { 174 vm_exit_out_of_memory(s, OOM_MALLOC_ERROR, 175 "unable to allocate initial hashtable for jvmti object tags"); 176 } 177 for (int i=0; i<initial_size; i++) { 178 _table[i] = NULL; 179 } 180 } 181 182 // hash a given key (oop) with the specified size 183 static unsigned int hash(oop key, int size) { 184 ZGC_ONLY(assert(ZAddressMetadataShift >= sizeof(unsigned int) * BitsPerByte, "cast removes the metadata bits");) 185 186 // shift right to get better distribution (as these bits will be zero 187 // with aligned addresses) 188 unsigned int addr = (unsigned int)(cast_from_oop<intptr_t>(key)); 189 #ifdef _LP64 190 return (addr >> 3) % size; 191 #else 192 return (addr >> 2) % size; 193 #endif 194 } 195 196 // hash a given key (oop) 197 unsigned int hash(oop key) { 198 return hash(key, _size); 199 } 200 201 // resize the hashmap - allocates a large table and re-hashes 202 // all entries into the new table. 203 void resize() { 204 int new_size_index = _size_index+1; 205 int new_size = _sizes[new_size_index]; |