jdk8-mips64-public/hotspot: comparison src/share/vm/classfile/symbolTable.hpp

-:4d399f013e5a
+:e9140bf80b4a
 //
 // %note:
 //  - symbolTableEntrys are allocated in blocks to reduce the space overhead.
 class BoolObjectClosure;
+class outputStream;
 // Class to hold a newly created or referenced Symbol* temporarily in scope.
 // new_symbol() and lookup() will create a Symbol* if not already in the
 // symbol table and add to the symbol's reference count.
 private:
 // The symbol table
 static SymbolTable* _the_table;
+// Set if one bucket is out of balance due to hash algorithm deficiency
+static bool _needs_rehashing;
+static jint _seed;
 // For statistics
 static int symbols_removed;
 static int symbols_counted;
 Symbol* allocate_symbol(const u1* name, int len, bool c_heap, TRAPS); // Assumes no characters larger than 0x7F
 // Arena for permanent symbols (null class loader) that are never unloaded
 static Arena*  _arena;
 static Arena* arena() { return _arena; }  // called for statistics
 static void initialize_symbols(int arena_alloc_size = 0);
+static bool use_alternate_hashcode()  { return _seed != 0; }
+static jint seed()                    { return _seed; }
+unsigned int new_hash(Symbol* sym);
 public:
 enum {
 symbol_alloc_batch_size = 8,
 // Pick initial size based on java -version size measurements
 symbol_alloc_arena_size = 360*K
 // if CDS give symbol table a default arena size since most symbols
 // are already allocated in the shared misc section.
 initialize_symbols();
 }
+static unsigned int hash_symbol(const char* s, int len, unsigned int hashValue = 0);
 static Symbol* lookup(const char* name, int len, TRAPS);
 // lookup only, won't add. Also calculate hash.
 static Symbol* lookup_only(const char* name, int len, unsigned int& hash);
 // Only copy to C string to be added if lookup failed.
 static Symbol* lookup(const Symbol* sym, int begin, int end, TRAPS);
 static void print_histogram()     PRODUCT_RETURN;
 static void print()     PRODUCT_RETURN;
 // Debugging
 static void verify();
+static void dump(outputStream* st);
 // Sharing
 static void copy_buckets(char** top, char*end) {
 the_table()->Hashtable<Symbol*>::copy_buckets(top, end);
 }
 the_table()->Hashtable<Symbol*>::copy_table(top, end);
 }
 static void reverse(void* boundary = NULL) {
 the_table()->Hashtable<Symbol*>::reverse(boundary);
 }
+// Rehash the symbol table if it gets out of balance
+static void rehash_table();
+static bool needs_rehashing()         { return _needs_rehashing; }
 };
 class StringTable : public Hashtable<oop> {
 friend class VMStructs;
 private:
 // The string table
 static StringTable* _the_table;
+// Set if one bucket is out of balance due to hash algorithm deficiency
+static bool _needs_rehashing;
+static jint _seed;
 static oop intern(Handle string_or_null, jchar* chars, int length, TRAPS);
 oop basic_add(int index, Handle string_or_null, jchar* name, int len,
 unsigned int hashValue, TRAPS);
 oop lookup(int index, jchar* chars, int length, unsigned int hashValue);
 StringTable(HashtableBucket* t, int number_of_entries)
 : Hashtable<oop>((int)StringTableSize, sizeof (HashtableEntry<oop>), t,
 number_of_entries) {}
+static bool use_alternate_hashcode()  { return _seed != 0; }
+static jint seed()                    { return _seed; }
+unsigned int new_hash(oop s);
 public:
 // The string table
 static StringTable* the_table() { return _the_table; }
 static void create_table() {
 static void unlink(BoolObjectClosure* cl);
 // Invoke "f->do_oop" on the locations of all oops in the table.
 static void oops_do(OopClosure* f);
+// Hashing algorithm, used as the hash value used by the
+//     StringTable for bucket selection and comparison (stored in the
+//     HashtableEntry structures).  This is used in the String.intern() method.
+static unsigned int hash_string(const jchar* s, int len, unsigned int hashValue = 0);
+// Internal test.
+static void test_alt_hash() PRODUCT_RETURN;
 // Probing
 static oop lookup(Symbol* symbol);
 // Interning
 static oop intern(Symbol* symbol, TRAPS);
 static oop intern(oop string, TRAPS);
 static oop intern(const char *utf8_string, TRAPS);
 // Debugging
 static void verify();
+static void dump(outputStream* st);
 // Sharing
 static void copy_buckets(char** top, char*end) {
 the_table()->Hashtable<oop>::copy_buckets(top, end);
 }
 the_table()->Hashtable<oop>::copy_table(top, end);
 }
 static void reverse() {
 the_table()->Hashtable<oop>::reverse();
 }
+// Rehash the symbol table if it gets out of balance
+static void rehash_table();
+static bool needs_rehashing() { return _needs_rehashing; }
 };
 #endif // SHARE_VM_CLASSFILE_SYMBOLTABLE_HPP

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/classfile/symbolTable.hpp

src/share/vm/classfile/symbolTable.hpp