src/hotspot/share/utilities/hashtable.cpp
author iklam
Tue, 20 Nov 2018 20:00:15 -0800
changeset 52631 3009ca99de32
parent 52514 f4e3900c8d08
child 52673 61b3b58a1d1d
permissions -rw-r--r--
8213587: Speed up CDS dump time by using resizable hashtables Reviewed-by: jiangli, coleenp, gziemski
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
49818
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
     2
 * Copyright (c) 2003, 2018, 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"
49982
9042ffe5b7fe 8200729: Conditional compilation of GCs
stefank
parents: 49818
diff changeset
    34
#include "logging/log.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    35
#include "memory/allocation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    36
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    37
#include "oops/oop.inline.hpp"
49818
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
    38
#include "oops/weakHandle.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    39
#include "runtime/safepoint.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    40
#include "utilities/dtrace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    41
#include "utilities/hashtable.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    42
#include "utilities/hashtable.inline.hpp"
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
    43
#include "utilities/numberSeq.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    45
26421
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    46
// This hashtable is implemented as an open hash table with a fixed number of buckets.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
26421
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    48
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
    49
  BasicHashtableEntry<F>* entry = NULL;
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    50
  if (_free_list != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
    entry = _free_list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
    _free_list = _free_list->next();
26421
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    53
  }
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    54
  return entry;
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    55
}
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
// 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
    58
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
    59
  BasicHashtableEntry<F>* entry = new_entry_free_list();
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    60
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
    61
  if (entry == NULL) {
1551
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    62
    if (_first_free_entry + _entry_size >= _end_block) {
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    63
      int block_size = MIN2(512, MAX2((int)_table_size / 2, (int)_number_of_entries));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
      int len = _entry_size * block_size;
1551
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    65
      len = 1 << log2_intptr(len); // round down to power of 2
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    66
      assert(len >= _entry_size, "");
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
    67
      _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
    68
      _entry_blocks->append(_first_free_entry);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
      _end_block = _first_free_entry + len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
    }
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
    71
    entry = (BasicHashtableEntry<F>*)_first_free_entry;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
    _first_free_entry += _entry_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
1551
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    75
  assert(_entry_size % HeapWordSize == 0, "");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  entry->set_hash(hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  return entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
    81
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
    82
  HashtableEntry<T, F>* entry;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
    84
  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
    85
  entry->set_literal(obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  return entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
46729
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
    89
// 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
    90
// 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
    91
// 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
    92
// used by each entry
46729
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
    93
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
    94
  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
    95
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
    96
  entry->set_hash(hashValue);
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
    97
  entry->set_literal(obj);
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
    98
  entry->set_next(NULL);
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
    99
  return entry;
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
   100
}
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
   101
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   102
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
   103
  if (NULL != _buckets) {
52514
f4e3900c8d08 8213346: Re-implement shared dictionary using CompactHashtable
iklam
parents: 52416
diff changeset
   104
    FREE_C_HEAP_ARRAY(HashtableBucket, _buckets);
13097
c146b608d91f 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents: 13087
diff changeset
   105
    _buckets = NULL;
c146b608d91f 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents: 13087
diff changeset
   106
  }
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
45114
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   109
template <MEMFLAGS F> void BasicHashtable<F>::BucketUnlinkContext::free_entry(BasicHashtableEntry<F>* entry) {
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   110
  entry->set_next(_removed_head);
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   111
  _removed_head = entry;
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   112
  if (_removed_tail == NULL) {
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   113
    _removed_tail = entry;
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   114
  }
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   115
  _num_removed++;
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   116
}
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   117
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   118
template <MEMFLAGS F> void BasicHashtable<F>::bulk_free_entries(BucketUnlinkContext* context) {
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   119
  if (context->_num_removed == 0) {
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   120
    assert(context->_removed_head == NULL && context->_removed_tail == NULL,
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   121
           "Zero entries in the unlink context, but elements linked from " PTR_FORMAT " to " PTR_FORMAT,
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   122
           p2i(context->_removed_head), p2i(context->_removed_tail));
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   123
    return;
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   124
  }
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   125
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   126
  // MT-safe add of the list of BasicHashTableEntrys from the context to the free list.
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   127
  BasicHashtableEntry<F>* current = _free_list;
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   128
  while (true) {
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   129
    context->_removed_tail->set_next(current);
47634
6a0c42c40cd1 8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents: 47216
diff changeset
   130
    BasicHashtableEntry<F>* old = Atomic::cmpxchg(context->_removed_head, &_free_list, current);
45114
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   131
    if (old == current) {
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   132
      break;
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   133
    }
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   134
    current = old;
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   135
  }
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   136
  Atomic::add(-context->_num_removed, &_number_of_entries);
45644c5f6b8e 8180048: Interned string and symbol table leak memory during parallel unlinking
tschatzl
parents: 42073
diff changeset
   137
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
46742
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   139
// 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
   140
static int literal_size(ConstantPool*) { return 0; }
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   141
static int literal_size(Klass*)        { return 0; }
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   142
static int literal_size(nmethod*)      { return 0; }
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   143
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   144
static int literal_size(Symbol *symbol) {
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   145
  return symbol->size() * HeapWordSize;
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   146
}
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   147
46742
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   148
static int literal_size(oop obj) {
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   149
  // 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
   150
  // 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
   151
  // the String.value array is not shared anymore.
46742
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   152
  if (obj == NULL) {
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   153
    return 0;
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   154
  } else if (obj->klass() == SystemDictionary::String_klass()) {
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   155
    return (obj->size() + java_lang_String::value(obj)->size()) * HeapWordSize;
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   156
  } else {
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   157
    return obj->size();
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   158
  }
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   159
}
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   160
49818
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   161
static int literal_size(ClassLoaderWeakHandle v) {
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   162
  return literal_size(v.peek());
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   163
}
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   164
47774
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   165
template <MEMFLAGS F> bool BasicHashtable<F>::resize(int new_size) {
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   166
  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   167
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   168
  // Allocate new buckets
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   169
  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
   170
  if (buckets_new == NULL) {
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   171
    return false;
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   172
  }
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   173
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   174
  // Clear the new buckets
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   175
  for (int i = 0; i < new_size; i++) {
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   176
    buckets_new[i].clear();
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   177
  }
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   178
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   179
  int table_size_old = _table_size;
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   180
  // hash_to_index() uses _table_size, so switch the sizes now
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   181
  _table_size = new_size;
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   182
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   183
  // Move entries from the old table to a new table
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   184
  for (int index_old = 0; index_old < table_size_old; index_old++) {
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   185
    for (BasicHashtableEntry<F>* p = _buckets[index_old].get_entry(); p != NULL; ) {
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   186
      BasicHashtableEntry<F>* next = p->next();
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   187
      bool keep_shared = p->is_shared();
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   188
      int index_new = hash_to_index(p->hash());
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   189
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   190
      p->set_next(buckets_new[index_new].get_entry());
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   191
      buckets_new[index_new].set_entry(p);
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   192
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   193
      if (keep_shared) {
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   194
        p->set_shared();
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   195
      }
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   196
      p = next;
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   197
    }
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   198
  }
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   199
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   200
  // The old backets now can be released
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   201
  BasicHashtable<F>::free_buckets();
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   202
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   203
  // Switch to the new storage
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   204
  _buckets = buckets_new;
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   205
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   206
  return true;
69c081ca110a 8184765: Dynamically resize SystemDictionary
gziemski
parents: 47634
diff changeset
   207
}
46742
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   208
52631
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   209
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
   210
  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
   211
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   212
  if (table_size() >= max_size) {
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   213
    return false;
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   214
  }
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   215
  if (number_of_entries() / table_size() > load_factor) {
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   216
    resize(MIN2<int>(table_size() * 2, max_size));
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   217
    return true;
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   218
  } else {
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   219
    return false;
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   220
  }
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   221
}
3009ca99de32 8213587: Speed up CDS dump time by using resizable hashtables
iklam
parents: 52514
diff changeset
   222
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   223
// Dump footprint and bucket length statistics
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   224
//
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   225
// Note: if you create a new subclass of Hashtable<MyNewType, F>, you will need to
46742
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   226
// add a new function static int literal_size(MyNewType lit)
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   227
// because I can't get template <class T> int literal_size(T) to pick the specializations for Symbol and oop.
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   228
//
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   229
// The StringTable and SymbolTable dumping print how much footprint is used by the String and Symbol
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   230
// literals.
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   231
46742
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   232
template <class T, MEMFLAGS F> void Hashtable<T, F>::print_table_statistics(outputStream* st,
50233
48d4abe945f1 8203490: StringTable::dump lacks a load barrier
stefank
parents: 50113
diff changeset
   233
                                                                            const char *table_name,
48d4abe945f1 8203490: StringTable::dump lacks a load barrier
stefank
parents: 50113
diff changeset
   234
                                                                            T (*literal_load_barrier)(HashtableEntry<T, F>*)) {
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   235
  NumberSeq summary;
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   236
  int literal_bytes = 0;
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   237
  for (int i = 0; i < this->table_size(); ++i) {
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   238
    int count = 0;
26421
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
   239
    for (HashtableEntry<T, F>* e = this->bucket(i);
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46742
diff changeset
   240
         e != NULL; e = e->next()) {
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   241
      count++;
50233
48d4abe945f1 8203490: StringTable::dump lacks a load barrier
stefank
parents: 50113
diff changeset
   242
      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
   243
      literal_bytes += literal_size(l);
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   244
    }
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   245
    summary.add((double)count);
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   246
  }
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   247
  double num_buckets = summary.num();
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   248
  double num_entries = summary.sum();
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   249
26421
37d88e604ad0 8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents: 24426
diff changeset
   250
  int bucket_bytes = (int)num_buckets * sizeof(HashtableBucket<F>);
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   251
  int entry_bytes  = (int)num_entries * sizeof(HashtableEntry<T, F>);
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   252
  int total_bytes = literal_bytes +  bucket_bytes + entry_bytes;
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   253
46742
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   254
  int bucket_size  = (num_buckets <= 0) ? 0 : (bucket_bytes  / num_buckets);
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   255
  int entry_size   = (num_entries <= 0) ? 0 : (entry_bytes   / num_entries);
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   256
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   257
  st->print_cr("%s statistics:", table_name);
46742
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   258
  st->print_cr("Number of buckets       : %9d = %9d bytes, each %d", (int)num_buckets, bucket_bytes,  bucket_size);
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   259
  st->print_cr("Number of entries       : %9d = %9d bytes, each %d", (int)num_entries, entry_bytes,   entry_size);
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   260
  if (literal_bytes != 0) {
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   261
    double literal_avg = (num_entries <= 0) ? 0 : (literal_bytes / num_entries);
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   262
    st->print_cr("Number of literals      : %9d = %9d bytes, avg %7.3f", (int)num_entries, literal_bytes, literal_avg);
24ec8a039c90 8184994: Add Dictionary size logging and jcmd
coleenp
parents: 46729
diff changeset
   263
  }
17610
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   264
  st->print_cr("Total footprint         : %9s = %9d bytes", "", total_bytes);
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   265
  st->print_cr("Average bucket size     : %9.3f", summary.avg());
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   266
  st->print_cr("Variance of bucket size : %9.3f", summary.variance());
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   267
  st->print_cr("Std. dev. of bucket size: %9.3f", summary.sd());
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   268
  st->print_cr("Maximum bucket size     : %9d", (int)summary.maximum());
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   269
}
c6857feaac47 8014262: PrintStringTableStatistics should include more footprint info
iklam
parents: 13728
diff changeset
   270
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
#ifndef PRODUCT
49818
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   272
template <class T> void print_literal(T l) {
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   273
  l->print();
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   274
}
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   275
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   276
static void print_literal(ClassLoaderWeakHandle l) {
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   277
  l.print();
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   278
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   280
template <class T, MEMFLAGS F> void Hashtable<T, F>::print() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   283
  for (int i = 0; i < BasicHashtable<F>::table_size(); i++) {
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   284
    HashtableEntry<T, F>* entry = bucket(i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
    while(entry != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
      tty->print("%d : ", i);
49818
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   287
      print_literal(entry->literal());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
      tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
      entry = entry->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   294
template <MEMFLAGS F>
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   295
template <class T> void BasicHashtable<F>::verify_table(const char* table_name) {
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   296
  int element_count = 0;
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   297
  int max_bucket_count = 0;
46545
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   298
  int max_bucket_number = 0;
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   299
  for (int index = 0; index < table_size(); index++) {
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   300
    int bucket_count = 0;
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   301
    for (T* probe = (T*)bucket(index); probe != NULL; probe = probe->next()) {
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   302
      probe->verify();
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   303
      bucket_count++;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
    }
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   305
    element_count += bucket_count;
46545
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   306
    if (bucket_count > max_bucket_count) {
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   307
      max_bucket_count = bucket_count;
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   308
      max_bucket_number = index;
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   309
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  }
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   311
  guarantee(number_of_entries() == element_count,
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   312
            "Verify of %s failed", table_name);
46545
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   313
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   314
  // Log some statistics about the hashtable
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   315
  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
   316
                       max_bucket_count, max_bucket_number, _number_of_entries, _table_size);
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   317
  if (_number_of_entries > 0 && log_is_enabled(Debug, hashtables)) {
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   318
    for (int index = 0; index < table_size(); index++) {
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   319
      int bucket_count = 0;
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   320
      for (T* probe = (T*)bucket(index); probe != NULL; probe = probe->next()) {
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   321
        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
   322
        bucket_count++;
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   323
      }
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   324
      if (bucket_count > 0) {
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   325
        log_debug(hashtables)("bucket %d count %d", index, bucket_count);
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   326
      }
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   327
    }
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   328
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
#endif // PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   332
// Explicitly instantiate these types
26422
4ee5901e205e 8048268: G1 Code Root Migration performs poorly
mgerdin
parents: 26421
diff changeset
   333
template class Hashtable<nmethod*, mtGC>;
4ee5901e205e 8048268: G1 Code Root Migration performs poorly
mgerdin
parents: 26421
diff changeset
   334
template class HashtableEntry<nmethod*, mtGC>;
4ee5901e205e 8048268: G1 Code Root Migration performs poorly
mgerdin
parents: 26421
diff changeset
   335
template class BasicHashtable<mtGC>;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13342
diff changeset
   336
template class Hashtable<ConstantPool*, mtClass>;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   337
template class Hashtable<Symbol*, mtSymbol>;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13342
diff changeset
   338
template class Hashtable<Klass*, mtClass>;
34257
4be3504cc03b 8140802: Clean up and refactor of class loading code for CDS
iklam
parents: 30593
diff changeset
   339
template class Hashtable<InstanceKlass*, mtClass>;
49818
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   340
template class Hashtable<ClassLoaderWeakHandle, mtClass>;
46729
c62d2e8b2728 7133093: Improve system dictionary performance
coleenp
parents: 46630
diff changeset
   341
template class Hashtable<Symbol*, mtModule>;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   342
template class Hashtable<oop, mtSymbol>;
49818
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   343
template class Hashtable<ClassLoaderWeakHandle, mtSymbol>;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   344
template class Hashtable<Symbol*, mtClass>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   345
template class HashtableEntry<Symbol*, mtSymbol>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   346
template class HashtableEntry<Symbol*, mtClass>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   347
template class HashtableEntry<oop, mtSymbol>;
49818
e57e6addb978 8201505: Use WeakHandle for ProtectionDomainCacheTable and ResolvedMethodTable
coleenp
parents: 48794
diff changeset
   348
template class HashtableEntry<ClassLoaderWeakHandle, mtSymbol>;
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46742
diff changeset
   349
template class HashtableBucket<mtClass>;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   350
template class BasicHashtableEntry<mtSymbol>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   351
template class BasicHashtableEntry<mtCode>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   352
template class BasicHashtable<mtClass>;
34257
4be3504cc03b 8140802: Clean up and refactor of class loading code for CDS
iklam
parents: 30593
diff changeset
   353
template class BasicHashtable<mtClassShared>;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   354
template class BasicHashtable<mtSymbol>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   355
template class BasicHashtable<mtCode>;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13097
diff changeset
   356
template class BasicHashtable<mtInternal>;
38733
2b65f4db449e 8156156: Add module specific NMT MemoryType
hseigel
parents: 36384
diff changeset
   357
template class BasicHashtable<mtModule>;
30593
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 27880
diff changeset
   358
template class BasicHashtable<mtCompiler>;
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   359
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   360
template void BasicHashtable<mtClass>::verify_table<DictionaryEntry>(char const*);
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   361
template void BasicHashtable<mtModule>::verify_table<ModuleEntry>(char const*);
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   362
template void BasicHashtable<mtModule>::verify_table<PackageEntry>(char const*);
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46435
diff changeset
   363
template void BasicHashtable<mtClass>::verify_table<ProtectionDomainCacheEntry>(char const*);
46545
b970b6e40209 8181450: assert in BasicHashtable::verify_table
coleenp
parents: 46488
diff changeset
   364
template void BasicHashtable<mtClass>::verify_table<PlaceholderEntry>(char const*);