284
285 enum {
286 rehash_count = 100,
287 rehash_multiple = 60
288 };
289
290 // Check that the table is unbalanced
291 bool check_rehash_table(int count);
292
293 public:
294 RehashableHashtable(int table_size, int entry_size)
295 : Hashtable<T, F>(table_size, entry_size) { }
296
297 RehashableHashtable(int table_size, int entry_size,
298 HashtableBucket<F>* buckets, int number_of_entries)
299 : Hashtable<T, F>(table_size, entry_size, buckets, number_of_entries) { }
300
301
302 // Function to move these elements into the new table.
303 void move_to(RehashableHashtable<T, F>* new_table);
304 static bool use_alternate_hashcode() { return _seed != 0; }
305 static juint seed() { return _seed; }
306
307 static int literal_size(Symbol *symbol);
308 static int literal_size(oop oop);
309
310 // The following two are currently not used, but are needed anyway because some
311 // C++ compilers (MacOS and Solaris) force the instantiation of
312 // Hashtable<ConstantPool*, mtClass>::dump_table() even though we never call this function
313 // in the VM code.
314 static int literal_size(ConstantPool *cp) {Unimplemented(); return 0;}
315 static int literal_size(Klass *k) {Unimplemented(); return 0;}
316
317 void dump_table(outputStream* st, const char *table_name);
318
319 private:
320 static juint _seed;
321 };
322
323
324 // Versions of hashtable where two handles are used to compute the index.
325
326 template <class T, MEMFLAGS F> class TwoOopHashtable : public Hashtable<T, F> {
327 friend class VMStructs;
328 protected:
329 TwoOopHashtable(int table_size, int entry_size)
330 : Hashtable<T, F>(table_size, entry_size) {}
331
332 TwoOopHashtable(int table_size, int entry_size, HashtableBucket<F>* t,
333 int number_of_entries)
334 : Hashtable<T, F>(table_size, entry_size, t, number_of_entries) {}
335
336 public:
337 unsigned int compute_hash(const Symbol* name, const ClassLoaderData* loader_data) const {
338 unsigned int name_hash = name->identity_hash();
339 // loader is null with CDS
340 assert(loader_data != NULL || UseSharedSpaces || DumpSharedSpaces,
341 "only allowed with shared spaces");
342 unsigned int loader_hash = loader_data == NULL ? 0 : loader_data->identity_hash();
|
284
285 enum {
286 rehash_count = 100,
287 rehash_multiple = 60
288 };
289
290 // Check that the table is unbalanced
291 bool check_rehash_table(int count);
292
293 public:
294 RehashableHashtable(int table_size, int entry_size)
295 : Hashtable<T, F>(table_size, entry_size) { }
296
297 RehashableHashtable(int table_size, int entry_size,
298 HashtableBucket<F>* buckets, int number_of_entries)
299 : Hashtable<T, F>(table_size, entry_size, buckets, number_of_entries) { }
300
301
302 // Function to move these elements into the new table.
303 void move_to(RehashableHashtable<T, F>* new_table);
304 static bool use_alternate_hashcode();
305 static juint seed();
306
307 static int literal_size(Symbol *symbol);
308 static int literal_size(oop oop);
309
310 // The following two are currently not used, but are needed anyway because some
311 // C++ compilers (MacOS and Solaris) force the instantiation of
312 // Hashtable<ConstantPool*, mtClass>::dump_table() even though we never call this function
313 // in the VM code.
314 static int literal_size(ConstantPool *cp) {Unimplemented(); return 0;}
315 static int literal_size(Klass *k) {Unimplemented(); return 0;}
316
317 void dump_table(outputStream* st, const char *table_name);
318
319 private:
320 static juint _seed;
321 };
322
323 template <class T, MEMFLAGS F> juint RehashableHashtable<T, F>::_seed = 0;
324 template <class T, MEMFLAGS F> juint RehashableHashtable<T, F>::seed() { return _seed; };
325 template <class T, MEMFLAGS F> bool RehashableHashtable<T, F>::use_alternate_hashcode() { return _seed != 0; };
326
327 // Versions of hashtable where two handles are used to compute the index.
328
329 template <class T, MEMFLAGS F> class TwoOopHashtable : public Hashtable<T, F> {
330 friend class VMStructs;
331 protected:
332 TwoOopHashtable(int table_size, int entry_size)
333 : Hashtable<T, F>(table_size, entry_size) {}
334
335 TwoOopHashtable(int table_size, int entry_size, HashtableBucket<F>* t,
336 int number_of_entries)
337 : Hashtable<T, F>(table_size, entry_size, t, number_of_entries) {}
338
339 public:
340 unsigned int compute_hash(const Symbol* name, const ClassLoaderData* loader_data) const {
341 unsigned int name_hash = name->identity_hash();
342 // loader is null with CDS
343 assert(loader_data != NULL || UseSharedSpaces || DumpSharedSpaces,
344 "only allowed with shared spaces");
345 unsigned int loader_hash = loader_data == NULL ? 0 : loader_data->identity_hash();
|