jdk8-mips64-public/hotspot: src/share/vm/services/mallocSiteTable.cpp@9148fcba5de9 (annotated)

src/share/vm/services/mallocSiteTable.cpp@9148fcba5de9 (annotated)

src/share/vm/services/mallocSiteTable.cpp

Thu, 07 Nov 2019 17:56:14 -0500

author: simonis
date: Thu, 07 Nov 2019 17:56:14 -0500
changeset 9780: 9148fcba5de9
parent 9778: bf6ea7319424
permissions: -rw-r--r--

8206173: MallocSiteTable::initialize() doesn't take function descriptors into account
Reviewed-by: stuefe, zgu

 /*
  * Copyright (c) 2014, 2019, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 #include "precompiled.hpp"
 #include "memory/allocation.inline.hpp"
 #include "runtime/atomic.hpp"
 #include "services/mallocSiteTable.hpp"
 /*
  * Early os::malloc() calls come from initializations of static variables, long before entering any
  * VM code. Upon the arrival of the first os::malloc() call, malloc site hashtable has to be
  * initialized, along with the allocation site for the hashtable entries.
  * To ensure that malloc site hashtable can be initialized without triggering any additional os::malloc()
  * call, the hashtable bucket array and hashtable entry allocation site have to be static.
  * It is not a problem for hashtable bucket, since it is an array of pointer type, C runtime just
  * allocates a block memory and zero the memory for it.
  * But for hashtable entry allocation site object, things get tricky. C runtime not only allocates
  * memory for it, but also calls its constructor at some later time. If we initialize the allocation site
  * at the first os::malloc() call, the object will be reinitialized when its constructor is called
  * by C runtime.
  * To workaround above issue, we declare a static size_t array with the size of the CallsiteHashtableEntry,
  * the memory is used to instantiate CallsiteHashtableEntry for the hashtable entry allocation site.
  * Given it is a primitive type array, C runtime will do nothing other than assign the memory block for the variable,
  * which is exactly what we want.
  * The same trick is also applied to create NativeCallStack object for CallsiteHashtableEntry memory allocation.
  *
  * Note: C++ object usually aligns to particular alignment, depends on compiler implementation, we declare
  * the memory as size_t arrays, to ensure the memory is aligned to native machine word alignment.
  */
 // Reserve enough memory for NativeCallStack and MallocSiteHashtableEntry objects
 size_t MallocSiteTable::_hash_entry_allocation_stack[CALC_OBJ_SIZE_IN_TYPE(NativeCallStack, size_t)];
 size_t MallocSiteTable::_hash_entry_allocation_site[CALC_OBJ_SIZE_IN_TYPE(MallocSiteHashtableEntry, size_t)];
 // Malloc site hashtable buckets
 MallocSiteHashtableEntry*  MallocSiteTable::_table[MallocSiteTable::table_size];
 // concurrent access counter
 volatile int MallocSiteTable::_access_count = 0;
 // Tracking hashtable contention
 NOT_PRODUCT(int MallocSiteTable::_peak_count = 0;)
 /*
  * Initialize malloc site table.
  * Hashtable entry is malloc'd, so it can cause infinite recursion.
  * To avoid above problem, we pre-initialize a hash entry for
  * this allocation site.
  * The method is called during C runtime static variable initialization
  * time, it is in single-threaded mode from JVM perspective.
  */
 bool MallocSiteTable::initialize() {
   assert(sizeof(_hash_entry_allocation_stack) >= sizeof(NativeCallStack), "Sanity Check");
   assert(sizeof(_hash_entry_allocation_site) >= sizeof(MallocSiteHashtableEntry),
     "Sanity Check");
   assert((size_t)table_size <= MAX_MALLOCSITE_TABLE_SIZE, "Hashtable overflow");
   // Fake the call stack for hashtable entry allocation
   assert(NMT_TrackingStackDepth > 1, "At least one tracking stack");
   // Create pseudo call stack for hashtable entry allocation
   address pc[3];
   if (NMT_TrackingStackDepth >= 3) {
     uintx *fp = (uintx*)MallocSiteTable::allocation_at;
     // On ppc64, 'fp' is a pointer to a function descriptor which is a struct  of
     // three native pointers where the first pointer is the real function address.
     // See: http://refspecs.linuxfoundation.org/ELF/ppc64/PPC-elf64abi-1.9.html#FUNC-DES
     pc[2] = (address)(fp PPC64_ONLY(BIG_ENDIAN_ONLY([0])));
   }
   if (NMT_TrackingStackDepth >= 2) {
     uintx *fp = (uintx*)MallocSiteTable::lookup_or_add;
     pc[1] = (address)(fp PPC64_ONLY(BIG_ENDIAN_ONLY([0])));
   }
   uintx *fp = (uintx*)MallocSiteTable::new_entry;
   pc[0] = (address)(fp PPC64_ONLY(BIG_ENDIAN_ONLY([0])));
   // Instantiate NativeCallStack object, have to use placement new operator. (see comments above)
   NativeCallStack* stack = ::new ((void*)_hash_entry_allocation_stack)
     NativeCallStack(pc, MIN2(((int)(sizeof(pc) / sizeof(address))), ((int)NMT_TrackingStackDepth)));
   // Instantiate hash entry for hashtable entry allocation callsite
   MallocSiteHashtableEntry* entry = ::new ((void*)_hash_entry_allocation_site)
     MallocSiteHashtableEntry(*stack, mtNMT);
   // Add the allocation site to hashtable.
   int index = hash_to_index(stack->hash());
   _table[index] = entry;
   return true;
 }
 // Walks entries in the hashtable.
 // It stops walk if the walker returns false.
 bool MallocSiteTable::walk(MallocSiteWalker* walker) {
   MallocSiteHashtableEntry* head;
   for (int index = 0; index < table_size; index ++) {
     head = _table[index];
     while (head != NULL) {
       if (!walker->do_malloc_site(head->peek())) {
         return false;
       }
       head = (MallocSiteHashtableEntry*)head->next();
     }
   }
   return true;
 }
 /*
  *  The hashtable does not have deletion policy on individual entry,
  *  and each linked list node is inserted via compare-and-swap,
  *  so each linked list is stable, the contention only happens
  *  at the end of linked list.
  *  This method should not return NULL under normal circumstance.
  *  If NULL is returned, it indicates:
  *    1. Out of memory, it cannot allocate new hash entry.
  *    2. Overflow hash bucket.
  *  Under any of above circumstances, caller should handle the situation.
  */
 MallocSite* MallocSiteTable::lookup_or_add(const NativeCallStack& key, size_t* bucket_idx,
   size_t* pos_idx, MEMFLAGS flags) {
   assert(flags != mtNone, "Should have a real memory type");
   unsigned int index = hash_to_index(key.hash());
   assert(index >= 0, "Negative index");
   *bucket_idx = (size_t)index;
   *pos_idx = 0;
   // First entry for this hash bucket
   if (_table[index] == NULL) {
     MallocSiteHashtableEntry* entry = new_entry(key, flags);
     // OOM check
     if (entry == NULL) return NULL;
     // swap in the head
     if (Atomic::cmpxchg_ptr((void*)entry, (volatile void *)&_table[index], NULL) == NULL) {
       return entry->data();
     }
     delete entry;
   }
   MallocSiteHashtableEntry* head = _table[index];
   while (head != NULL && (*pos_idx) <= MAX_BUCKET_LENGTH) {
     MallocSite* site = head->data();
     if (site->flag() == flags && site->equals(key)) {
       return head->data();
     }
     if (head->next() == NULL && (*pos_idx) < MAX_BUCKET_LENGTH) {
       MallocSiteHashtableEntry* entry = new_entry(key, flags);
       // OOM check
       if (entry == NULL) return NULL;
       if (head->atomic_insert(entry)) {
         (*pos_idx) ++;
         return entry->data();
       }
       // contended, other thread won
       delete entry;
     }
     head = (MallocSiteHashtableEntry*)head->next();
     (*pos_idx) ++;
   }
   return NULL;
 }
 // Access malloc site
 MallocSite* MallocSiteTable::malloc_site(size_t bucket_idx, size_t pos_idx) {
   assert(bucket_idx < table_size, "Invalid bucket index");
   MallocSiteHashtableEntry* head = _table[bucket_idx];
   for (size_t index = 0; index < pos_idx && head != NULL;
     index ++, head = (MallocSiteHashtableEntry*)head->next());
   assert(head != NULL, "Invalid position index");
   return head->data();
 }
 // Allocates MallocSiteHashtableEntry object. Special call stack
 // (pre-installed allocation site) has to be used to avoid infinite
 // recursion.
 MallocSiteHashtableEntry* MallocSiteTable::new_entry(const NativeCallStack& key, MEMFLAGS flags) {
   void* p = AllocateHeap(sizeof(MallocSiteHashtableEntry), mtNMT,
     *hash_entry_allocation_stack(), AllocFailStrategy::RETURN_NULL);
   return ::new (p) MallocSiteHashtableEntry(key, flags);
 }
 void MallocSiteTable::reset() {
   for (int index = 0; index < table_size; index ++) {
     MallocSiteHashtableEntry* head = _table[index];
     _table[index] = NULL;
     delete_linked_list(head);
   }
 }
 void MallocSiteTable::delete_linked_list(MallocSiteHashtableEntry* head) {
   MallocSiteHashtableEntry* p;
   while (head != NULL) {
     p = head;
     head = (MallocSiteHashtableEntry*)head->next();
     if (p != (MallocSiteHashtableEntry*)_hash_entry_allocation_site) {
       delete p;
     }
   }
 }
 void MallocSiteTable::shutdown() {
   AccessLock locker(&_access_count);
   locker.exclusiveLock();
   reset();
 }
 bool MallocSiteTable::walk_malloc_site(MallocSiteWalker* walker) {
   assert(walker != NULL, "NuLL walker");
   AccessLock locker(&_access_count);
   if (locker.sharedLock()) {
     NOT_PRODUCT(_peak_count = MAX2(_peak_count, _access_count);)
     return walk(walker);
   }
   return false;
 }
 void MallocSiteTable::AccessLock::exclusiveLock() {
   jint target;
   jint val;
   assert(_lock_state != ExclusiveLock, "Can only call once");
   assert(*_lock >= 0, "Can not content exclusive lock");
   // make counter negative to block out shared locks
   do {
     val = *_lock;
     target = _MAGIC_ + *_lock;
   } while (Atomic::cmpxchg(target, _lock, val) != val);
   // wait for all readers to exit
   while (*_lock != _MAGIC_) {
 #ifdef _WINDOWS
     os::naked_short_sleep(1);
 #else
     os::NakedYield();
 #endif
   }
   _lock_state = ExclusiveLock;
 }

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/services/mallocSiteTable.cpp@9148fcba5de9 (annotated)

src/share/vm/services/mallocSiteTable.cpp