8244955: Additional Fix for JDK-8240124

Reviewed-by: rehn, pliden, smarks

Author: coleenp

src/hotspot/share/classfile/altHashing.cpp

@@ -116,6 +116,12 @@ static void halfsiphash_init64(uint32_t v[4], uint64_t seed) {
   v[1] ^= 0xee;
 }
 
+uint32_t halfsiphash_finish32(uint32_t v[4], int rounds) {
+  v[2] ^= 0xff;
+  halfsiphash_rounds(v, rounds);
+  return (v[1] ^ v[3]);
+}
+
 static uint64_t halfsiphash_finish64(uint32_t v[4], int rounds) {
   uint64_t rv;
   v[2] ^= 0xee;
@@ -127,14 +133,14 @@ static uint64_t halfsiphash_finish64(uint32_t v[4], int rounds) {
   return rv;
 }
 
-// HalfSipHash-2-4 (64-bit output) for Symbols
-uint64_t AltHashing::halfsiphash_64(uint64_t seed, const int8_t* data, int len) {
+// HalfSipHash-2-4 (32-bit output) for Symbols
+uint32_t AltHashing::halfsiphash_32(uint64_t seed, const uint8_t* data, int len) {
   uint32_t v[4];
   uint32_t newdata;
   int off = 0;
   int count = len;
 
-  halfsiphash_init64(v, seed);
+  halfsiphash_init32(v, seed);
 
   // body
   while (count >= 4) {
@@ -171,17 +177,17 @@ uint64_t AltHashing::halfsiphash_64(uint64_t seed, const int8_t* data, int len)
   halfsiphash_adddata(v, newdata, 2);
 
   // finalization
-  return halfsiphash_finish64(v, 4);
+  return halfsiphash_finish32(v, 4);
 }
 
-// HalfSipHash-2-4 (64-bit output) for Strings
-uint64_t AltHashing::halfsiphash_64(uint64_t seed, const uint16_t* data, int len) {
+// HalfSipHash-2-4 (32-bit output) for Strings
+uint32_t AltHashing::halfsiphash_32(uint64_t seed, const uint16_t* data, int len) {
   uint32_t v[4];
   uint32_t newdata;
   int off = 0;
   int count = len;
 
-  halfsiphash_init64(v, seed);
+  halfsiphash_init32(v, seed);
 
   // body
   while (count >= 2) {
@@ -202,7 +208,7 @@ uint64_t AltHashing::halfsiphash_64(uint64_t seed, const uint16_t* data, int len
   halfsiphash_adddata(v, newdata, 2);
 
   // finalization
-  return halfsiphash_finish64(v, 4);
+  return halfsiphash_finish32(v, 4);
 }
 
 // HalfSipHash-2-4 (64-bit output) for integers (used to create seed)

src/hotspot/share/classfile/altHashing.hpp

@@ -43,8 +43,8 @@ class AltHashing : AllStatic {
   static uint64_t compute_seed();
 
   // For Symbols
-  static uint64_t halfsiphash_64(uint64_t seed, const int8_t* data, int len);
+  static uint32_t halfsiphash_32(uint64_t seed, const uint8_t* data, int len);
   // For Strings
-  static uint64_t halfsiphash_64(uint64_t seed, const uint16_t* data, int len);
+  static uint32_t halfsiphash_32(uint64_t seed, const uint16_t* data, int len);
 };
 #endif // SHARE_CLASSFILE_ALTHASHING_HPP

src/hotspot/share/classfile/stringTable.cpp

@@ -95,7 +95,7 @@ static uint64_t _alt_hash_seed = 0;
 
 uintx hash_string(const jchar* s, int len, bool useAlt) {
   return  useAlt ?
-    AltHashing::halfsiphash_64(_alt_hash_seed, s, len) :
+    AltHashing::halfsiphash_32(_alt_hash_seed, s, len) :
     java_lang_String::hash_code(s, len);
 }
 

src/hotspot/share/classfile/symbolTable.cpp

@@ -108,7 +108,7 @@ static inline void log_trace_symboltable_helper(Symbol* sym, const char* msg) {
 // Pick hashing algorithm.
 static uintx hash_symbol(const char* s, int len, bool useAlt) {
   return useAlt ?
-  AltHashing::halfsiphash_64(_alt_hash_seed, (const int8_t*)s, len) :
+  AltHashing::halfsiphash_32(_alt_hash_seed, (const uint8_t*)s, len) :
   java_lang_String::hash_code((const jbyte*)s, len);
 }
 

src/hotspot/share/gc/shared/stringdedup/stringDedupTable.cpp

@@ -156,7 +156,7 @@ void StringDedupEntryCache::free(StringDedupEntry* entry, uint worker_id) {
   assert(worker_id < _nlists, "Invalid worker id");
 
   entry->set_obj(NULL);
-  entry->set_java_hash(0, false /* latin1 */);
+  entry->set_hash(0);
 
   if (_cached[worker_id].length() < _max_list_length) {
     // Cache is not full
@@ -246,14 +246,11 @@ void StringDedupTable::create() {
   _table = new StringDedupTable(_min_size);
 }
 
-void StringDedupTable::add(typeArrayOop value, bool latin1, uint64_t hash, StringDedupEntry** list) {
+void StringDedupTable::add(typeArrayOop value, bool latin1, unsigned int hash, StringDedupEntry** list) {
   StringDedupEntry* entry = _entry_cache->alloc();
   entry->set_obj(value);
-  if (use_java_hash()) {
-    entry->set_java_hash((unsigned int)hash, latin1);
-  } else {
-    entry->set_alt_hash(hash);
-  }
+  entry->set_hash(hash);
+  entry->set_latin1(latin1);
   entry->set_next(*list);
   *list = entry;
   _entries++;
@@ -268,18 +265,17 @@ void StringDedupTable::remove(StringDedupEntry** pentry, uint worker_id) {
 void StringDedupTable::transfer(StringDedupEntry** pentry, StringDedupTable* dest) {
   StringDedupEntry* entry = *pentry;
   *pentry = entry->next();
-  uint64_t hash = use_java_hash() ? entry->java_hash() : entry->alt_hash();
+  unsigned int hash = entry->hash();
   size_t index = dest->hash_to_index(hash);
   StringDedupEntry** list = dest->bucket(index);
   entry->set_next(*list);
   *list = entry;
 }
 
-typeArrayOop StringDedupTable::lookup(typeArrayOop value, bool latin1, uint64_t hash,
+typeArrayOop StringDedupTable::lookup(typeArrayOop value, bool latin1, unsigned int hash,
                                       StringDedupEntry** list, uintx &count) {
   for (StringDedupEntry* entry = *list; entry != NULL; entry = entry->next()) {
-    if ((use_java_hash() && entry->java_hash() == hash && entry->java_hash_latin1() == latin1) ||
-        (!use_java_hash() && entry->alt_hash() == hash)) {
+    if (entry->hash() == hash && entry->latin1() == latin1) {
       oop* obj_addr = (oop*)entry->obj_addr();
       oop obj = NativeAccess<ON_PHANTOM_OOP_REF | AS_NO_KEEPALIVE>::oop_load(obj_addr);
       if (obj != NULL && java_lang_String::value_equals(value, static_cast<typeArrayOop>(obj))) {
@@ -294,7 +290,7 @@ typeArrayOop StringDedupTable::lookup(typeArrayOop value, bool latin1, uint64_t
   return NULL;
 }
 
-typeArrayOop StringDedupTable::lookup_or_add_inner(typeArrayOop value, bool latin1, uint64_t hash) {
+typeArrayOop StringDedupTable::lookup_or_add_inner(typeArrayOop value, bool latin1, unsigned int hash) {
   size_t index = hash_to_index(hash);
   StringDedupEntry** list = bucket(index);
   uintx count = 0;
@@ -318,31 +314,29 @@ typeArrayOop StringDedupTable::lookup_or_add_inner(typeArrayOop value, bool lati
   return existing_value;
 }
 
-unsigned int StringDedupTable::java_hash_code(typeArrayOop value, bool latin1) {
-  assert(use_java_hash(), "Should not use java hash code");
-
+unsigned int StringDedupTable::hash_code(typeArrayOop value, bool latin1) {
   unsigned int hash;
   int length = value->length();
   if (latin1) {
     const jbyte* data = (jbyte*)value->base(T_BYTE);
-    hash = java_lang_String::hash_code(data, length);
+    if (use_java_hash()) {
+      hash = java_lang_String::hash_code(data, length);
+    } else {
+      hash = AltHashing::halfsiphash_32(_table->_hash_seed, (const uint8_t*)data, length);
+    }
   } else {
     length /= sizeof(jchar) / sizeof(jbyte); // Convert number of bytes to number of chars
     const jchar* data = (jchar*)value->base(T_CHAR);
-    hash = java_lang_String::hash_code(data, length);
+    if (use_java_hash()) {
+      hash = java_lang_String::hash_code(data, length);
+    } else {
+      hash = AltHashing::halfsiphash_32(_table->_hash_seed, (const uint16_t*)data, length);
+    }
   }
 
   return hash;
 }
 
-uint64_t StringDedupTable::alt_hash_code(typeArrayOop value) {
-  assert(!use_java_hash(), "Should not use alt hash code");
-
-  int length = value->length();
-  const jbyte* data = (jbyte*)value->base(T_BYTE);
-  return AltHashing::halfsiphash_64(_table->_hash_seed, (const int8_t*)data, length);
-}
-
 void StringDedupTable::deduplicate(oop java_string, StringDedupStat* stat) {
   assert(java_lang_String::is_instance(java_string), "Must be a string");
   NoSafepointVerifier nsv;
@@ -357,7 +351,7 @@ void StringDedupTable::deduplicate(oop java_string, StringDedupStat* stat) {
   }
 
   bool latin1 = java_lang_String::is_latin1(java_string);
-  uint64_t hash = 0;
+  unsigned int hash = 0;
 
   if (use_java_hash()) {
     if (!java_lang_String::hash_is_set(java_string)) {
@@ -366,7 +360,7 @@ void StringDedupTable::deduplicate(oop java_string, StringDedupStat* stat) {
     hash = java_lang_String::hash_code(java_string);
   } else {
     // Compute hash
-    hash = alt_hash_code(value);
+    hash = hash_code(value, latin1);
     stat->inc_hashed();
   }
 
@@ -516,9 +510,9 @@ uintx StringDedupTable::unlink_or_oops_do(StringDedupUnlinkOrOopsDoClosure* cl,
             // destination partitions. finish_rehash() will do a single
             // threaded transfer of all entries.
             typeArrayOop value = (typeArrayOop)*p;
-            assert(!use_java_hash(), "Should not be using Java hash");
-            uint64_t hash = alt_hash_code(value);
-            (*entry)->set_alt_hash(hash);
+            bool latin1 = (*entry)->latin1();
+            unsigned int hash = hash_code(value, latin1);
+            (*entry)->set_hash(hash);
           }
 
           // Move to next entry
@@ -612,14 +606,9 @@ void StringDedupTable::verify() {
       guarantee(Universe::heap()->is_in(value), "Object must be on the heap");
       guarantee(!value->is_forwarded(), "Object must not be forwarded");
       guarantee(value->is_typeArray(), "Object must be a typeArrayOop");
-      uint64_t hash;
-      if (use_java_hash()) {
-        hash = (*entry)->java_hash();
-        guarantee(java_hash_code(value, (*entry)->java_hash_latin1()) == hash, "Table entry has incorrect hash");
-      } else {
-        hash = (*entry)->alt_hash();
-        guarantee(alt_hash_code(value) == hash, "Table entry has incorrect hash");
-      }
+      bool latin1 = (*entry)->latin1();
+      unsigned int hash = hash_code(value, latin1);
+      guarantee((*entry)->hash() == hash, "Table entry has inorrect hash");
       guarantee(_table->hash_to_index(hash) == bucket, "Table entry has incorrect index");
       entry = (*entry)->next_addr();
     }
@@ -631,14 +620,12 @@ void StringDedupTable::verify() {
     StringDedupEntry** entry1 = _table->bucket(bucket);
     while (*entry1 != NULL) {
       typeArrayOop value1 = (*entry1)->obj();
+      bool latin1_1 = (*entry1)->latin1();
       StringDedupEntry** entry2 = (*entry1)->next_addr();
       while (*entry2 != NULL) {
         typeArrayOop value2 = (*entry2)->obj();
-        guarantee(value1 != value2, "Table entries must not have the same array");
-        if (use_java_hash()) {
-          guarantee((*entry1)->java_hash_latin1() != (*entry2)->java_hash_latin1() ||
-                    !java_lang_String::value_equals(value1, value2), "Table entries must not have identical arrays");
-        }
+        bool latin1_2 = (*entry2)->latin1();
+        guarantee(latin1_1 != latin1_2 || !java_lang_String::value_equals(value1, value2), "Table entries must not have identical arrays");
         entry2 = (*entry2)->next_addr();
       }
       entry1 = (*entry1)->next_addr();
@@ -660,6 +647,6 @@ void StringDedupTable::print_statistics() {
             _table->_entries, percent_of((size_t)_table->_entries, _table->_size), _entry_cache->size(), _entries_added, _entries_removed);
   log.debug("    Resize Count: " UINTX_FORMAT ", Shrink Threshold: " UINTX_FORMAT "(" STRDEDUP_PERCENT_FORMAT_NS "), Grow Threshold: " UINTX_FORMAT "(" STRDEDUP_PERCENT_FORMAT_NS ")",
             _resize_count, _table->_shrink_threshold, _shrink_load_factor * 100.0, _table->_grow_threshold, _grow_load_factor * 100.0);
-  log.debug("    Rehash Count: " UINTX_FORMAT ", Rehash Threshold: " UINTX_FORMAT ", Hash Seed: " UINT64_FORMAT_X, _rehash_count, _rehash_threshold, _table->_hash_seed);
+  log.debug("    Rehash Count: " UINTX_FORMAT ", Rehash Threshold: " UINTX_FORMAT ", Hash Seed: " UINT64_FORMAT, _rehash_count, _rehash_threshold, _table->_hash_seed);
   log.debug("    Age Threshold: " UINTX_FORMAT, StringDeduplicationAgeThreshold);
 }

src/hotspot/share/gc/shared/stringdedup/stringDedupTable.hpp

@@ -39,16 +39,15 @@ class StringDedupUnlinkOrOopsDoClosure;
 class StringDedupEntry : public CHeapObj<mtGC> {
 private:
   StringDedupEntry* _next;
-  uint64_t          _hash;
+  unsigned int      _hash;
+  bool              _latin1;
   typeArrayOop      _obj;
 
-  static const uint64_t java_hash_mask = ((uint64_t)1 << 32) - 1;
-  static const uint64_t java_latin1_mask = (uint64_t)1 << 63;
-
 public:
   StringDedupEntry() :
     _next(NULL),
     _hash(0),
+    _latin1(false),
     _obj(NULL) {
   }
 
@@ -64,27 +63,20 @@ class StringDedupEntry : public CHeapObj<mtGC> {
     _next = next;
   }
 
-  unsigned int java_hash() {
-    return (unsigned int)(_hash & java_hash_mask);
-  }
-
-  bool java_hash_latin1() {
-    return (_hash & java_latin1_mask) != 0;
+  unsigned int hash() {
+    return _hash;
   }
 
-  void set_java_hash(unsigned int hash, bool latin1) {
+  void set_hash(unsigned int hash) {
     _hash = hash;
-    if (latin1) {
-      _hash |= java_latin1_mask;
-    }
   }
 
-  uint64_t alt_hash() {
-    return _hash;
+  bool latin1() {
+    return _latin1;
   }
 
-  void set_alt_hash(uint64_t hash) {
-    _hash = hash;
+  void set_latin1(bool latin1) {
+    _latin1 = latin1;
   }
 
   typeArrayOop obj() {
@@ -138,7 +130,7 @@ class StringDedupTable : public CHeapObj<mtGC> {
   // The hash seed also dictates which hash function to use. A
   // zero hash seed means we will use the Java compatible hash
   // function (which doesn't use a seed), and a non-zero hash
-  // seed means we use the alternate and better hash function.
+  // seed means we use the murmur3 hash function.
   uint64_t                        _hash_seed;
 
   // Constants governing table resize/rehash/cache.
@@ -170,12 +162,12 @@ class StringDedupTable : public CHeapObj<mtGC> {
   }
 
   // Returns the hash bucket index for the given hash code.
-  size_t hash_to_index(uint64_t hash) {
+  size_t hash_to_index(unsigned int hash) {
     return (size_t)hash & (_size - 1);
   }
 
   // Adds a new table entry to the given hash bucket.
-  void add(typeArrayOop value, bool latin1, uint64_t hash, StringDedupEntry** list);
+  void add(typeArrayOop value, bool latin1, unsigned int hash, StringDedupEntry** list);
 
   // Removes the given table entry from the table.
   void remove(StringDedupEntry** pentry, uint worker_id);
@@ -185,15 +177,15 @@ class StringDedupTable : public CHeapObj<mtGC> {
 
   // Returns an existing character array in the given hash bucket, or NULL
   // if no matching character array exists.
-  typeArrayOop lookup(typeArrayOop value, bool latin1, uint64_t hash,
+  typeArrayOop lookup(typeArrayOop value, bool latin1, unsigned int hash,
                       StringDedupEntry** list, uintx &count);
 
   // Returns an existing character array in the table, or inserts a new
   // table entry if no matching character array exists.
-  typeArrayOop lookup_or_add_inner(typeArrayOop value, bool latin1, uint64_t hash);
+  typeArrayOop lookup_or_add_inner(typeArrayOop value, bool latin1, unsigned int hash);
 
   // Thread safe lookup or add of table entry
-  static typeArrayOop lookup_or_add(typeArrayOop value, bool latin1, uint64_t hash) {
+  static typeArrayOop lookup_or_add(typeArrayOop value, bool latin1, unsigned int hash) {
     // Protect the table from concurrent access. Also note that this lock
     // acts as a fence for _table, which could have been replaced by a new
     // instance if the table was resized or rehashed.
@@ -209,8 +201,7 @@ class StringDedupTable : public CHeapObj<mtGC> {
 
   // Computes the hash code for the given character array, using the
   // currently active hash function and hash seed.
-  static unsigned int java_hash_code(typeArrayOop value, bool latin1);
-  static uint64_t alt_hash_code(typeArrayOop value);
+  static unsigned int hash_code(typeArrayOop value, bool latin1);
 
   static uintx unlink_or_oops_do(StringDedupUnlinkOrOopsDoClosure* cl,
                                  size_t partition_begin,

src/hotspot/share/memory/filemap.cpp

@@ -150,13 +150,13 @@ template <int N> static void get_header_version(char (&header_version) [N]) {
   } else {
     // Get the hash value.  Use a static seed because the hash needs to return the same
     // value over multiple jvm invocations.
-    uint64_t hash = AltHashing::halfsiphash_64(8191, (const int8_t*)vm_version, version_len);
+    uint32_t hash = AltHashing::halfsiphash_32(8191, (const uint8_t*)vm_version, version_len);
 
-    // Truncate the ident, saving room for the 16 hex character hash value.
-    strncpy(header_version, vm_version, JVM_IDENT_MAX-17);
+    // Truncate the ident, saving room for the 8 hex character hash value.
+    strncpy(header_version, vm_version, JVM_IDENT_MAX-9);
 
-    // Append the hash code as 16 hex digits.
-    sprintf(&header_version[JVM_IDENT_MAX-17], "%016" PRIx64, hash);
+    // Append the hash code as eight hex digits.
+    sprintf(&header_version[JVM_IDENT_MAX-9], "%08x", hash);
     header_version[JVM_IDENT_MAX-1] = 0;  // Null terminate.
   }