1/*
2 * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25#ifndef SHARE_VM_UTILITIES_HASHTABLE_HPP
26#define SHARE_VM_UTILITIES_HASHTABLE_HPP
27
28#include "classfile/classLoaderData.hpp"
29#include "memory/allocation.hpp"
30#include "oops/oop.hpp"
31#include "oops/symbol.hpp"
32#include "runtime/handles.hpp"
33
34// This is a generic hashtable, designed to be used for the symbol
35// and string tables.
36//
37// It is implemented as an open hash table with a fixed number of buckets.
38//
39// %note:
40//  - TableEntrys are allocated in blocks to reduce the space overhead.
41
42
43
44template <MEMFLAGS F> class BasicHashtableEntry : public CHeapObj<F> {
45  friend class VMStructs;
46private:
47  unsigned int         _hash;           // 32-bit hash for item
48
49  // Link to next element in the linked list for this bucket.  EXCEPT
50  // bit 0 set indicates that this entry is shared and must not be
51  // unlinked from the table. Bit 0 is set during the dumping of the
52  // archive. Since shared entries are immutable, _next fields in the
53  // shared entries will not change.  New entries will always be
54  // unshared and since pointers are align, bit 0 will always remain 0
55  // with no extra effort.
56  BasicHashtableEntry<F>* _next;
57
58  // Windows IA64 compiler requires subclasses to be able to access these
59protected:
60  // Entry objects should not be created, they should be taken from the
61  // free list with BasicHashtable.new_entry().
62  BasicHashtableEntry() { ShouldNotReachHere(); }
63  // Entry objects should not be destroyed.  They should be placed on
64  // the free list instead with BasicHashtable.free_entry().
65  ~BasicHashtableEntry() { ShouldNotReachHere(); }
66
67public:
68
69  unsigned int hash() const             { return _hash; }
70  void set_hash(unsigned int hash)      { _hash = hash; }
71  unsigned int* hash_addr()             { return &_hash; }
72
73  static BasicHashtableEntry<F>* make_ptr(BasicHashtableEntry<F>* p) {
74    return (BasicHashtableEntry*)((intptr_t)p & -2);
75  }
76
77  BasicHashtableEntry<F>* next() const {
78    return make_ptr(_next);
79  }
80
81  void set_next(BasicHashtableEntry<F>* next) {
82    _next = next;
83  }
84
85  BasicHashtableEntry<F>** next_addr() {
86    return &_next;
87  }
88
89  bool is_shared() const {
90    return ((intptr_t)_next & 1) != 0;
91  }
92
93  void set_shared() {
94    _next = (BasicHashtableEntry<F>*)((intptr_t)_next | 1);
95  }
96};
97
98
99
100template <class T, MEMFLAGS F> class HashtableEntry : public BasicHashtableEntry<F> {
101  friend class VMStructs;
102private:
103  T               _literal;          // ref to item in table.
104
105public:
106  // Literal
107  T literal() const                   { return _literal; }
108  T* literal_addr()                   { return &_literal; }
109  void set_literal(T s)               { _literal = s; }
110
111  HashtableEntry* next() const {
112    return (HashtableEntry*)BasicHashtableEntry<F>::next();
113  }
114  HashtableEntry** next_addr() {
115    return (HashtableEntry**)BasicHashtableEntry<F>::next_addr();
116  }
117};
118
119
120
121template <MEMFLAGS F> class HashtableBucket : public CHeapObj<F> {
122  friend class VMStructs;
123private:
124  // Instance variable
125  BasicHashtableEntry<F>*       _entry;
126
127public:
128  // Accessing
129  void clear()                        { _entry = NULL; }
130
131  // The following methods use order access methods to avoid race
132  // conditions in multiprocessor systems.
133  BasicHashtableEntry<F>* get_entry() const;
134  void set_entry(BasicHashtableEntry<F>* l);
135
136  // The following method is not MT-safe and must be done under lock.
137  BasicHashtableEntry<F>** entry_addr()  { return &_entry; }
138
139};
140
141
142template <MEMFLAGS F> class BasicHashtable : public CHeapObj<F> {
143  friend class VMStructs;
144
145public:
146  BasicHashtable(int table_size, int entry_size);
147  BasicHashtable(int table_size, int entry_size,
148                 HashtableBucket<F>* buckets, int number_of_entries);
149
150  // Sharing support.
151  size_t count_bytes_for_buckets();
152  size_t count_bytes_for_table();
153  void copy_buckets(char* top, char* end);
154  void copy_table(char* top, char* end);
155
156  // Bucket handling
157  int hash_to_index(unsigned int full_hash) const {
158    int h = full_hash % _table_size;
159    assert(h >= 0 && h < _table_size, "Illegal hash value");
160    return h;
161  }
162
163private:
164  // Instance variables
165  int               _table_size;
166  HashtableBucket<F>*     _buckets;
167  BasicHashtableEntry<F>* volatile _free_list;
168  char*             _first_free_entry;
169  char*             _end_block;
170  int               _entry_size;
171  volatile int      _number_of_entries;
172
173protected:
174
175  void initialize(int table_size, int entry_size, int number_of_entries);
176
177  // Accessor
178  int entry_size() const { return _entry_size; }
179
180  // The following method is MT-safe and may be used with caution.
181  BasicHashtableEntry<F>* bucket(int i) const;
182
183  // The following method is not MT-safe and must be done under lock.
184  BasicHashtableEntry<F>** bucket_addr(int i) { return _buckets[i].entry_addr(); }
185
186  // Attempt to get an entry from the free list
187  BasicHashtableEntry<F>* new_entry_free_list();
188
189  // Table entry management
190  BasicHashtableEntry<F>* new_entry(unsigned int hashValue);
191
192  // Used when moving the entry to another table
193  // Clean up links, but do not add to free_list
194  void unlink_entry(BasicHashtableEntry<F>* entry) {
195    entry->set_next(NULL);
196    --_number_of_entries;
197  }
198
199  // Move over freelist and free block for allocation
200  void copy_freelist(BasicHashtable* src) {
201    _free_list = src->_free_list;
202    src->_free_list = NULL;
203    _first_free_entry = src->_first_free_entry;
204    src->_first_free_entry = NULL;
205    _end_block = src->_end_block;
206    src->_end_block = NULL;
207  }
208
209  // Free the buckets in this hashtable
210  void free_buckets();
211
212  // Helper data structure containing context for the bucket entry unlink process,
213  // storing the unlinked buckets in a linked list.
214  // Also avoids the need to pass around these four members as parameters everywhere.
215  struct BucketUnlinkContext {
216    int _num_processed;
217    int _num_removed;
218    // Head and tail pointers for the linked list of removed entries.
219    BasicHashtableEntry<F>* _removed_head;
220    BasicHashtableEntry<F>* _removed_tail;
221
222    BucketUnlinkContext() : _num_processed(0), _num_removed(0), _removed_head(NULL), _removed_tail(NULL) {
223    }
224
225    void free_entry(BasicHashtableEntry<F>* entry);
226  };
227  // Add of bucket entries linked together in the given context to the global free list. This method
228  // is mt-safe wrt. to other calls of this method.
229  void bulk_free_entries(BucketUnlinkContext* context);
230public:
231  int table_size() const { return _table_size; }
232  void set_entry(int index, BasicHashtableEntry<F>* entry);
233
234  void add_entry(int index, BasicHashtableEntry<F>* entry);
235
236  void free_entry(BasicHashtableEntry<F>* entry);
237
238  int number_of_entries() const { return _number_of_entries; }
239
240  template <class T> void verify_table(const char* table_name) PRODUCT_RETURN;
241};
242
243
244template <class T, MEMFLAGS F> class Hashtable : public BasicHashtable<F> {
245  friend class VMStructs;
246
247public:
248  Hashtable(int table_size, int entry_size)
249    : BasicHashtable<F>(table_size, entry_size) { }
250
251  Hashtable(int table_size, int entry_size,
252                   HashtableBucket<F>* buckets, int number_of_entries)
253    : BasicHashtable<F>(table_size, entry_size, buckets, number_of_entries) { }
254
255  // Debugging
256  void print()               PRODUCT_RETURN;
257
258  unsigned int compute_hash(const Symbol* name) const {
259    return (unsigned int) name->identity_hash();
260  }
261
262  int index_for(const Symbol* name) const {
263    return this->hash_to_index(compute_hash(name));
264  }
265
266  void print_table_statistics(outputStream* st, const char *table_name);
267
268 protected:
269
270  // Table entry management
271  HashtableEntry<T, F>* new_entry(unsigned int hashValue, T obj);
272  // Don't create and use freelist of HashtableEntry.
273  HashtableEntry<T, F>* allocate_new_entry(unsigned int hashValue, T obj);
274
275  // The following method is MT-safe and may be used with caution.
276  HashtableEntry<T, F>* bucket(int i) const {
277    return (HashtableEntry<T, F>*)BasicHashtable<F>::bucket(i);
278  }
279
280  // The following method is not MT-safe and must be done under lock.
281  HashtableEntry<T, F>** bucket_addr(int i) {
282    return (HashtableEntry<T, F>**)BasicHashtable<F>::bucket_addr(i);
283  }
284
285};
286
287template <class T, MEMFLAGS F> class RehashableHashtable : public Hashtable<T, F> {
288 friend class VMStructs;
289 protected:
290
291  enum {
292    rehash_count = 100,
293    rehash_multiple = 60
294  };
295
296  // Check that the table is unbalanced
297  bool check_rehash_table(int count);
298
299 public:
300  RehashableHashtable(int table_size, int entry_size)
301    : Hashtable<T, F>(table_size, entry_size) { }
302
303  RehashableHashtable(int table_size, int entry_size,
304                   HashtableBucket<F>* buckets, int number_of_entries)
305    : Hashtable<T, F>(table_size, entry_size, buckets, number_of_entries) { }
306
307
308  // Function to move these elements into the new table.
309  void move_to(RehashableHashtable<T, F>* new_table);
310  static bool use_alternate_hashcode();
311  static juint seed();
312
313 private:
314  static juint _seed;
315};
316
317template <class T, MEMFLAGS F> juint RehashableHashtable<T, F>::_seed = 0;
318template <class T, MEMFLAGS F> juint RehashableHashtable<T, F>::seed() { return _seed; };
319template <class T, MEMFLAGS F> bool  RehashableHashtable<T, F>::use_alternate_hashcode() { return _seed != 0; };
320
321#endif // SHARE_VM_UTILITIES_HASHTABLE_HPP
322