hotspot/src/share/vm/utilities/hashtable.cpp
author trims
Tue, 05 Apr 2011 14:12:31 -0700
changeset 8921 14bfe81f2a9d
parent 8076 96d498ec7ae1
child 10739 91935236600e
permissions -rw-r--r--
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass Summary: Update the copyright to be 2010 on all changed files in OpenJDK Reviewed-by: ohair
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8921
14bfe81f2a9d 7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents: 8076
diff changeset
     2
 * Copyright (c) 2003, 2011, 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"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#include "memory/allocation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    28
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    29
#include "runtime/safepoint.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
#include "utilities/dtrace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    31
#include "utilities/hashtable.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    32
#include "utilities/hashtable.inline.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    34
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
HS_DTRACE_PROBE_DECL4(hs_private, hashtable__new_entry,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    36
  void*, unsigned int, void*, void*);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
// This is a generic hashtable, designed to be used for the symbol
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// and string tables.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// It is implemented as an open hash table with a fixed number of buckets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// %note:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
//  - HashtableEntrys are allocated in blocks to reduce the space overhead.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
BasicHashtableEntry* BasicHashtable::new_entry(unsigned int hashValue) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  BasicHashtableEntry* entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  if (_free_list) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
    entry = _free_list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
    _free_list = _free_list->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  } else {
1551
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    53
    if (_first_free_entry + _entry_size >= _end_block) {
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    54
      int block_size = MIN2(512, MAX2((int)_table_size / 2, (int)_number_of_entries));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
      int len = _entry_size * block_size;
1551
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    56
      len = 1 << log2_intptr(len); // round down to power of 2
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    57
      assert(len >= _entry_size, "");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
      _first_free_entry = NEW_C_HEAP_ARRAY(char, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
      _end_block = _first_free_entry + len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
    entry = (BasicHashtableEntry*)_first_free_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
    _first_free_entry += _entry_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
1551
b431de37a22c 6770949: minor tweaks before 6655638
jrose
parents: 1
diff changeset
    65
  assert(_entry_size % HeapWordSize == 0, "");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  entry->set_hash(hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  return entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    71
template <class T> HashtableEntry<T>* Hashtable<T>::new_entry(unsigned int hashValue, T obj) {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    72
  HashtableEntry<T>* entry;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    74
  entry = (HashtableEntry<T>*)BasicHashtable::new_entry(hashValue);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    75
  entry->set_literal(obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  HS_DTRACE_PROBE4(hs_private, hashtable__new_entry,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
    this, hashValue, obj, entry);
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
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
// Reverse the order of elements in the hash buckets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
void BasicHashtable::reverse() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  for (int i = 0; i < _table_size; ++i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
    BasicHashtableEntry* new_list = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
    BasicHashtableEntry* p = bucket(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
    while (p != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
      BasicHashtableEntry* next = p->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
      p->set_next(new_list);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
      new_list = p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
      p = next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    *bucket_addr(i) = new_list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
// Copy the table to the shared space.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
void BasicHashtable::copy_table(char** top, char* end) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  // Dump the hash table entries.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  intptr_t *plen = (intptr_t*)(*top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  *top += sizeof(*plen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  for (i = 0; i < _table_size; ++i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
    for (BasicHashtableEntry** p = _buckets[i].entry_addr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
                              *p != NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
                               p = (*p)->next_addr()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
      if (*top + entry_size() > end) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   115
        report_out_of_shared_space(SharedMiscData);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
      *p = (BasicHashtableEntry*)memcpy(*top, *p, entry_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
      *top += entry_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  *plen = (char*)(*top) - (char*)plen - sizeof(*plen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  // Set the shared bit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  for (i = 0; i < _table_size; ++i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
    for (BasicHashtableEntry* p = bucket(i); p != NULL; p = p->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
      p->set_shared();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
// Reverse the order of elements in the hash buckets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   136
template <class T> void Hashtable<T>::reverse(void* boundary) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  for (int i = 0; i < table_size(); ++i) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   139
    HashtableEntry<T>* high_list = NULL;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   140
    HashtableEntry<T>* low_list = NULL;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   141
    HashtableEntry<T>* last_low_entry = NULL;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   142
    HashtableEntry<T>* p = bucket(i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    while (p != NULL) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   144
      HashtableEntry<T>* next = p->next();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
      if ((void*)p->literal() >= boundary) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
        p->set_next(high_list);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
        high_list = p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
        p->set_next(low_list);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
        low_list = p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
        if (last_low_entry == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
          last_low_entry = p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
      p = next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
    if (low_list != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
      *bucket_addr(i) = low_list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
      last_low_entry->set_next(high_list);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
      *bucket_addr(i) = high_list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
// Dump the hash table buckets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
void BasicHashtable::copy_buckets(char** top, char* end) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  intptr_t len = _table_size * sizeof(HashtableBucket);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  *(intptr_t*)(*top) = len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  *top += sizeof(intptr_t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  *(intptr_t*)(*top) = _number_of_entries;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  *top += sizeof(intptr_t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  if (*top + len > end) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   178
    report_out_of_shared_space(SharedMiscData);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  _buckets = (HashtableBucket*)memcpy(*top, _buckets, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  *top += len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   187
template <class T> void Hashtable<T>::print() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  for (int i = 0; i < table_size(); i++) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   191
    HashtableEntry<T>* entry = bucket(i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
    while(entry != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
      tty->print("%d : ", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
      entry->literal()->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
      tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
      entry = entry->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
void BasicHashtable::verify() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  int count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  for (int i = 0; i < table_size(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
    for (BasicHashtableEntry* p = bucket(i); p != NULL; p = p->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
      ++count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  assert(count == number_of_entries(), "number of hashtable entries incorrect");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
#endif // PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
void BasicHashtable::verify_lookup_length(double load) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  if ((double)_lookup_length / (double)_lookup_count > load * 2.0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    warning("Performance bug: SystemDictionary lookup_count=%d "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
            "lookup_length=%d average=%lf load=%f",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
            _lookup_count, _lookup_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
            (double) _lookup_length / _lookup_count, load);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
#endif
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   228
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   229
// Explicitly instantiate these types
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   230
template class Hashtable<constantPoolOop>;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   231
template class Hashtable<Symbol*>;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   232
template class Hashtable<klassOop>;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   233
template class Hashtable<oop>;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   234