src/hotspot/share/utilities/hashtable.cpp
author eosterlund
Thu, 05 Sep 2019 08:26:44 +0200
changeset 58014 aba258cd7df8
parent 54764 865ec913f916
child 58084 cddef3bde924
permissions -rw-r--r--
8229189: Improve JFR leak profiler tracing to deal with discontiguous heaps Reviewed-by: mgronlun, egahlin
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
54419
5c7418757bad 8221872: Remove uses of ClassLoaderWeakHandle typedef in protection domain table
coleenp
parents: 52688
diff changeset
     2
 * Copyright (c) 2003, 2019, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1623
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1623
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1623
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    25
#include "precompiled.hpp"
13199
025b0984feea 7181200: JVM new hashing code breaks SA in product mode
coleenp
parents: 13195
diff changeset
    26
#include "classfile/altHashing.hpp"
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
    27
#include "classfile/dictionary.hpp"
35498
392b50de06c6 8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents: 34257
diff changeset
    28
#include "classfile/javaClasses.inline.hpp"
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
    29
#include "classfile/moduleEntry.hpp"
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
    30
#include "classfile/packageEntry.hpp"
46545
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
    31
#include "classfile/placeholders.hpp"
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
    32
#include "classfile/protectionDomainCache.hpp"
24426
0a69c8cdfca9 8038654: Separate SymbolTable and StringTable code
gziemski
parents: 23187
diff changeset
    33
#include "classfile/stringTable.hpp"
52673
61b3b58a1d1d 8214181: safepoint header cleanup
rehn
parents: 52631
diff changeset
    34
#include "code/nmethod.hpp"
49982
9042ffe5b7fe 8200729: Conditional compilation of GCs
stefank
parents: 49818
diff changeset
    35
#include "logging/log.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    36
#include "memory/allocation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    37
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    38
#include "oops/oop.inline.hpp"
49818
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
    39
#include "oops/weakHandle.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    40
#include "runtime/safepoint.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    41
#include "utilities/dtrace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    42
#include "utilities/hashtable.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    43
#include "utilities/hashtable.inline.hpp"
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
    44
#include "utilities/numberSeq.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    46
26421
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    47
// This hashtable is implemented as an open hash table with a fixed number of buckets.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
26421
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    49
template <MEMFLAGS F> BasicHashtableEntry<F>* BasicHashtable<F>::new_entry_free_list() {
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    50
  BasicHashtableEntry<F>* entry = NULL;
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    51
  if (_free_list != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
    entry = _free_list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
    _free_list = _free_list->next();
26421
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    54
  }
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    55
  return entry;
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    56
}
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    57
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    58
// HashtableEntrys are allocated in blocks to reduce the space overhead.
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    59
template <MEMFLAGS F> BasicHashtableEntry<F>* BasicHashtable<F>::new_entry(unsigned int hashValue) {
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    60
  BasicHashtableEntry<F>* entry = new_entry_free_list();
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    61
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    62
  if (entry == NULL) {
1551
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    63
    if (_first_free_entry + _entry_size >= _end_block) {
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    64
      int block_size = MIN2(512, MAX2((int)_table_size / 2, (int)_number_of_entries));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
      int len = _entry_size * block_size;
52675
7d3cde494494 8214206: Fix for JDK-8213419 is broken on 32-bit
roland
parents: 52673
diff changeset
    66
      len = 1 << log2_int(len); // round down to power of 2
1551
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    67
      assert(len >= _entry_size, "");
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
    68
      _first_free_entry = NEW_C_HEAP_ARRAY2(char, len, F, CURRENT_PC);
52631
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
    69
      _entry_blocks->append(_first_free_entry);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
      _end_block = _first_free_entry + len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
    }
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
    72
    entry = (BasicHashtableEntry<F>*)_first_free_entry;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
    _first_free_entry += _entry_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
1551
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    76
  assert(_entry_size % HeapWordSize == 0, "");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  entry->set_hash(hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  return entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
    82
template <class T, MEMFLAGS F> HashtableEntry<T, F>* Hashtable<T, F>::new_entry(unsigned int hashValue, T obj) {
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
    83
  HashtableEntry<T, F>* entry;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
    85
  entry = (HashtableEntry<T, F>*)BasicHashtable<F>::new_entry(hashValue);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    86
  entry->set_literal(obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  return entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
46729
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
    90
// Version of hashtable entry allocation that allocates in the C heap directly.
52631
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
    91
// The block allocator in BasicHashtable has less fragmentation, but the memory is not freed until
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
    92
// the whole table is freed. Use allocate_new_entry() if you want to individually free the memory
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
    93
// used by each entry
46729
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
    94
template <class T, MEMFLAGS F> HashtableEntry<T, F>* Hashtable<T, F>::allocate_new_entry(unsigned int hashValue, T obj) {
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
    95
  HashtableEntry<T, F>* entry = (HashtableEntry<T, F>*) NEW_C_HEAP_ARRAY(char, this->entry_size(), F);
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
    96
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
    97
  entry->set_hash(hashValue);
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
    98
  entry->set_literal(obj);
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
    99
  entry->set_next(NULL);
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
   100
  return entry;
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
   101
}
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
   102
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   103
template <MEMFLAGS F> void BasicHashtable<F>::free_buckets() {
13097
c146b608d91f 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents: 13087
diff changeset
   104
  if (NULL != _buckets) {
52514
f4e3900c8d08 8213346: Re-implement shared dictionary using CompactHashtable
iklam
parents: 52416
diff changeset
   105
    FREE_C_HEAP_ARRAY(HashtableBucket, _buckets);
13097
c146b608d91f 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents: 13087
diff changeset
   106
    _buckets = NULL;
c146b608d91f 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents: 13087
diff changeset
   107
  }
c146b608d91f 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents: 13087
diff changeset
   108
}
c146b608d91f 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents: 13087
diff changeset
   109
46742
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   110
// For oops and Strings the size of the literal is interesting. For other types, nobody cares.
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   111
static int literal_size(ConstantPool*) { return 0; }
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   112
static int literal_size(Klass*)        { return 0; }
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   113
static int literal_size(nmethod*)      { return 0; }
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   114
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   115
static int literal_size(Symbol *symbol) {
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   116
  return symbol->size() * HeapWordSize;
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   117
}
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   118
46742
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   119
static int literal_size(oop obj) {
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   120
  // NOTE: this would over-count if (pre-JDK8) java_lang_Class::has_offset_field() is true,
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   121
  // and the String.value array is shared by several Strings. However, starting from JDK8,
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   122
  // the String.value array is not shared anymore.
46742
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   123
  if (obj == NULL) {
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   124
    return 0;
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   125
  } else if (obj->klass() == SystemDictionary::String_klass()) {
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   126
    return (obj->size() + java_lang_String::value(obj)->size()) * HeapWordSize;
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   127
  } else {
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   128
    return obj->size();
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   129
  }
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   130
}
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   131
54419
5c7418757bad 8221872: Remove uses of ClassLoaderWeakHandle typedef in protection domain table
coleenp
parents: 52688
diff changeset
   132
static int literal_size(WeakHandle<vm_class_loader_data> v) {
49818
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   133
  return literal_size(v.peek());
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   134
}
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   135
47774
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   136
template <MEMFLAGS F> bool BasicHashtable<F>::resize(int new_size) {
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   137
  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   138
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   139
  // Allocate new buckets
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   140
  HashtableBucket<F>* buckets_new = NEW_C_HEAP_ARRAY2_RETURN_NULL(HashtableBucket<F>, new_size, F, CURRENT_PC);
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   141
  if (buckets_new == NULL) {
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   142
    return false;
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   143
  }
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   144
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   145
  // Clear the new buckets
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   146
  for (int i = 0; i < new_size; i++) {
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   147
    buckets_new[i].clear();
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   148
  }
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   149
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   150
  int table_size_old = _table_size;
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   151
  // hash_to_index() uses _table_size, so switch the sizes now
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   152
  _table_size = new_size;
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   153
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   154
  // Move entries from the old table to a new table
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   155
  for (int index_old = 0; index_old < table_size_old; index_old++) {
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   156
    for (BasicHashtableEntry<F>* p = _buckets[index_old].get_entry(); p != NULL; ) {
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   157
      BasicHashtableEntry<F>* next = p->next();
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   158
      bool keep_shared = p->is_shared();
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   159
      int index_new = hash_to_index(p->hash());
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   160
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   161
      p->set_next(buckets_new[index_new].get_entry());
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   162
      buckets_new[index_new].set_entry(p);
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   163
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   164
      if (keep_shared) {
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   165
        p->set_shared();
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   166
      }
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   167
      p = next;
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   168
    }
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   169
  }
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   170
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   171
  // The old backets now can be released
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   172
  BasicHashtable<F>::free_buckets();
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   173
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   174
  // Switch to the new storage
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   175
  _buckets = buckets_new;
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   176
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   177
  return true;
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   178
}
46742
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   179
52631
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   180
template <MEMFLAGS F> bool BasicHashtable<F>::maybe_grow(int max_size, int load_factor) {
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   181
  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   182
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   183
  if (table_size() >= max_size) {
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   184
    return false;
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   185
  }
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   186
  if (number_of_entries() / table_size() > load_factor) {
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   187
    resize(MIN2<int>(table_size() * 2, max_size));
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   188
    return true;
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   189
  } else {
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   190
    return false;
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   191
  }
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   192
}
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   193
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 54419
diff changeset
   194
template <class T, MEMFLAGS F> TableStatistics Hashtable<T, F>::statistics_calculate(T (*literal_load_barrier)(HashtableEntry<T, F>*)) {
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   195
  NumberSeq summary;
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   196
  int literal_bytes = 0;
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   197
  for (int i = 0; i < this->table_size(); ++i) {
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   198
    int count = 0;
26421
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
   199
    for (HashtableEntry<T, F>* e = this->bucket(i);
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46742
diff changeset
   200
         e != NULL; e = e->next()) {
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   201
      count++;
50233
48d4abe945f1 8203490: StringTable::dump lacks a load barrier
stefank
parents: 50113
diff changeset
   202
      T l = (literal_load_barrier != NULL) ? literal_load_barrier(e) : e->literal();
48d4abe945f1 8203490: StringTable::dump lacks a load barrier
stefank
parents: 50113
diff changeset
   203
      literal_bytes += literal_size(l);
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   204
    }
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   205
    summary.add((double)count);
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   206
  }
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 54419
diff changeset
   207
  return TableStatistics(this->_stats_rate, summary, literal_bytes, sizeof(HashtableBucket<F>), sizeof(HashtableEntry<T, F>));
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 54419
diff changeset
   208
}
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   209
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 54419
diff changeset
   210
// Dump footprint and bucket length statistics
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 54419
diff changeset
   211
//
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 54419
diff changeset
   212
// Note: if you create a new subclass of Hashtable<MyNewType, F>, you will need to
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 54419
diff changeset
   213
// add a new function static int literal_size(MyNewType lit)
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 54419
diff changeset
   214
// because I can't get template <class T> int literal_size(T) to pick the specializations for Symbol and oop.
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 54419
diff changeset
   215
template <class T, MEMFLAGS F> void Hashtable<T, F>::print_table_statistics(outputStream* st,
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 54419
diff changeset
   216
                                                                            const char *table_name,
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 54419
diff changeset
   217
                                                                            T (*literal_load_barrier)(HashtableEntry<T, F>*)) {
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 54419
diff changeset
   218
  TableStatistics ts = statistics_calculate(literal_load_barrier);
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 54419
diff changeset
   219
  ts.print(st, table_name);
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   220
}
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   221
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
#ifndef PRODUCT
49818
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   223
template <class T> void print_literal(T l) {
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   224
  l->print();
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   225
}
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   226
54419
5c7418757bad 8221872: Remove uses of ClassLoaderWeakHandle typedef in protection domain table
coleenp
parents: 52688
diff changeset
   227
static void print_literal(WeakHandle<vm_class_loader_data> l) {
49818
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   228
  l.print();
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   229
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   231
template <class T, MEMFLAGS F> void Hashtable<T, F>::print() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   234
  for (int i = 0; i < BasicHashtable<F>::table_size(); i++) {
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   235
    HashtableEntry<T, F>* entry = bucket(i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
    while(entry != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
      tty->print("%d : ", i);
49818
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   238
      print_literal(entry->literal());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
      tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
      entry = entry->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   245
template <MEMFLAGS F>
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   246
template <class T> void BasicHashtable<F>::verify_table(const char* table_name) {
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   247
  int element_count = 0;
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   248
  int max_bucket_count = 0;
46545
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   249
  int max_bucket_number = 0;
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   250
  for (int index = 0; index < table_size(); index++) {
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   251
    int bucket_count = 0;
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   252
    for (T* probe = (T*)bucket(index); probe != NULL; probe = probe->next()) {
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   253
      probe->verify();
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   254
      bucket_count++;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
    }
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   256
    element_count += bucket_count;
46545
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   257
    if (bucket_count > max_bucket_count) {
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   258
      max_bucket_count = bucket_count;
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   259
      max_bucket_number = index;
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   260
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  }
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   262
  guarantee(number_of_entries() == element_count,
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   263
            "Verify of %s failed", table_name);
46545
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   264
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   265
  // Log some statistics about the hashtable
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   266
  log_info(hashtables)("%s max bucket size %d bucket %d element count %d table size %d", table_name,
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   267
                       max_bucket_count, max_bucket_number, _number_of_entries, _table_size);
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   268
  if (_number_of_entries > 0 && log_is_enabled(Debug, hashtables)) {
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   269
    for (int index = 0; index < table_size(); index++) {
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   270
      int bucket_count = 0;
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   271
      for (T* probe = (T*)bucket(index); probe != NULL; probe = probe->next()) {
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   272
        log_debug(hashtables)("bucket %d hash " INTPTR_FORMAT, index, (intptr_t)probe->hash());
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   273
        bucket_count++;
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   274
      }
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   275
      if (bucket_count > 0) {
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   276
        log_debug(hashtables)("bucket %d count %d", index, bucket_count);
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   277
      }
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   278
    }
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   279
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
#endif // PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   283
// Explicitly instantiate these types
26422
4ee5901e205e 8048268: G1 Code Root Migration performs poorly
mgerdin
parents: 26421
diff changeset
   284
template class Hashtable<nmethod*, mtGC>;
4ee5901e205e 8048268: G1 Code Root Migration performs poorly
mgerdin
parents: 26421
diff changeset
   285
template class HashtableEntry<nmethod*, mtGC>;
4ee5901e205e 8048268: G1 Code Root Migration performs poorly
mgerdin
parents: 26421
diff changeset
   286
template class BasicHashtable<mtGC>;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13342
diff changeset
   287
template class Hashtable<ConstantPool*, mtClass>;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   288
template class Hashtable<Symbol*, mtSymbol>;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13342
diff changeset
   289
template class Hashtable<Klass*, mtClass>;
34257
4be3504cc03b 8140802: Clean up and refactor of class loading code for CDS
iklam
parents: 30593
diff changeset
   290
template class Hashtable<InstanceKlass*, mtClass>;
54419
5c7418757bad 8221872: Remove uses of ClassLoaderWeakHandle typedef in protection domain table
coleenp
parents: 52688
diff changeset
   291
template class Hashtable<WeakHandle<vm_class_loader_data>, mtClass>;
46729
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
   292
template class Hashtable<Symbol*, mtModule>;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   293
template class Hashtable<oop, mtSymbol>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   294
template class Hashtable<Symbol*, mtClass>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   295
template class HashtableEntry<Symbol*, mtSymbol>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   296
template class HashtableEntry<Symbol*, mtClass>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   297
template class HashtableEntry<oop, mtSymbol>;
54419
5c7418757bad 8221872: Remove uses of ClassLoaderWeakHandle typedef in protection domain table
coleenp
parents: 52688
diff changeset
   298
template class HashtableEntry<WeakHandle<vm_class_loader_data>, mtClass>;
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46742
diff changeset
   299
template class HashtableBucket<mtClass>;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   300
template class BasicHashtableEntry<mtSymbol>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   301
template class BasicHashtableEntry<mtCode>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   302
template class BasicHashtable<mtClass>;
34257
4be3504cc03b 8140802: Clean up and refactor of class loading code for CDS
iklam
parents: 30593
diff changeset
   303
template class BasicHashtable<mtClassShared>;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   304
template class BasicHashtable<mtSymbol>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   305
template class BasicHashtable<mtCode>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   306
template class BasicHashtable<mtInternal>;
38733
2b65f4db449e 8156156: Add module specific NMT MemoryType
hseigel
parents: 36384
diff changeset
   307
template class BasicHashtable<mtModule>;
30593
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 27880
diff changeset
   308
template class BasicHashtable<mtCompiler>;
58014
aba258cd7df8 8229189: Improve JFR leak profiler tracing to deal with discontiguous heaps
eosterlund
parents: 54764
diff changeset
   309
template class BasicHashtable<mtTracing>;
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   310
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   311
template void BasicHashtable<mtClass>::verify_table<DictionaryEntry>(char const*);
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   312
template void BasicHashtable<mtModule>::verify_table<ModuleEntry>(char const*);
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   313
template void BasicHashtable<mtModule>::verify_table<PackageEntry>(char const*);
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   314
template void BasicHashtable<mtClass>::verify_table<ProtectionDomainCacheEntry>(char const*);
46545
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   315
template void BasicHashtable<mtClass>::verify_table<PlaceholderEntry>(char const*);