jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/g1/g1StringDedupTable.cpp

-:fd3484fadbe3
+:8adf45218add
 void G1StringDedupEntryCache::free(G1StringDedupEntry* entry, uint worker_id) {
 assert(entry->obj() != NULL, "Double free");
 assert(worker_id < _nlists, "Invalid worker id");
 entry->set_obj(NULL);
-entry->set_java_hash(0);
+entry->set_hash(0);
 if (_cached[worker_id].length() < _max_list_length) {
 // Cache is not full
 _cached[worker_id].add(entry);
 } else {
 assert(_table == NULL, "One string deduplication table allowed");
 _entry_cache = new G1StringDedupEntryCache((size_t)(_min_size * _max_cache_factor));
 _table = new G1StringDedupTable(_min_size);
 }
-void G1StringDedupTable::add(typeArrayOop value, uint64_t hash, G1StringDedupEntry** list) {
+void G1StringDedupTable::add(typeArrayOop value, unsigned int hash, G1StringDedupEntry** list) {
 G1StringDedupEntry* entry = _entry_cache->alloc();
 entry->set_obj(value);
-if (use_java_hash()) {
+entry->set_hash(hash);
-entry->set_java_hash((unsigned int)hash);
-} else {
-entry->set_alt_hash(hash);
-}
 entry->set_next(*list);
 *list = entry;
 _entries++;
 }
 }
 void G1StringDedupTable::transfer(G1StringDedupEntry** pentry, G1StringDedupTable* dest) {
 G1StringDedupEntry* 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);
 G1StringDedupEntry** list = dest->bucket(index);
 entry->set_next(*list);
 *list = entry;
 }
 (!memcmp(value1->base(T_CHAR),
 value2->base(T_CHAR),
 value1->length() * sizeof(jchar)))));
 }
-typeArrayOop G1StringDedupTable::lookup(typeArrayOop value, uint64_t hash,
+typeArrayOop G1StringDedupTable::lookup(typeArrayOop value, unsigned int hash,
 G1StringDedupEntry** list, uintx &count) {
 for (G1StringDedupEntry* entry = *list; entry != NULL; entry = entry->next()) {
-if ((use_java_hash() ? entry->java_hash() : entry->alt_hash()) == hash) {
+if (entry->hash() == hash) {
 typeArrayOop existing_value = entry->obj();
 if (equals(value, existing_value)) {
 // Match found
 return existing_value;
 }
 // Not found
 return NULL;
 }
-typeArrayOop G1StringDedupTable::lookup_or_add_inner(typeArrayOop value, uint64_t hash) {
+typeArrayOop G1StringDedupTable::lookup_or_add_inner(typeArrayOop value, unsigned int hash) {
 size_t index = hash_to_index(hash);
 G1StringDedupEntry** list = bucket(index);
 uintx count = 0;
 // Lookup in list
 }
 return existing_value;
 }
-unsigned int G1StringDedupTable::java_hash_code(typeArrayOop value) {
+unsigned int G1StringDedupTable::hash_code(typeArrayOop value) {
-assert(use_java_hash(), "Should not use java hash code");
 unsigned int hash;
 int length = value->length();
 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 G1StringDedupTable::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 G1StringDedupTable::deduplicate(oop java_string, G1StringDedupStat& stat) {
 assert(java_lang_String::is_instance(java_string), "Must be a string");
 No_Safepoint_Verifier nsv;
 // String has no value
 stat.inc_skipped();
 return;
 }
-uint64_t hash = 0;
+unsigned int hash = 0;
 if (use_java_hash()) {
 // Get hash code from cache
 hash = java_lang_String::hash(java_string);
 }
 if (hash == 0) {
 // Compute hash
-hash = alt_hash_code(value);
+hash = hash_code(value);
 stat.inc_hashed();
 }
 if (use_java_hash() && hash != 0) {
 // Store hash code in cache
 // in the table. We can't transfer entries into the new table
 // at this point since we don't have exclusive access to all
 // 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");
+unsigned int hash = hash_code(value);
-uint64_t hash = alt_hash_code(value);
+(*entry)->set_hash(hash);
-(*entry)->set_alt_hash(hash);
 }
 // Move to next entry
 entry = (*entry)->next_addr();
 }
 typeArrayOop value = (*entry)->obj();
 guarantee(value != NULL, "Object must not be NULL");
 guarantee(Universe::heap()->is_in_reserved(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;
+unsigned int hash = hash_code(value);
-if (use_java_hash()) {
+guarantee((*entry)->hash() == hash, "Table entry has inorrect hash");
-hash = (*entry)->java_hash();
-guarantee(java_hash_code(value) == hash, "Table entry has incorrect hash");
-} else {
-hash = (*entry)->alt_hash();
-guarantee(alt_hash_code(value) == hash, "Table entry has incorrect hash");
-}
 guarantee(_table->hash_to_index(hash) == bucket, "Table entry has incorrect index");
 entry = (*entry)->next_addr();
 }
 // Verify that we do not have entries with identical oops or identical arrays.
 while (*entry1 != NULL) {
 typeArrayOop value1 = (*entry1)->obj();
 G1StringDedupEntry** entry2 = (*entry1)->next_addr();
 while (*entry2 != NULL) {
 typeArrayOop value2 = (*entry2)->obj();
-guarantee(value1 != value2, "Table entries must not have the same array");
+guarantee(!equals(value1, value2), "Table entries must not have identical arrays");
-if (use_java_hash()) {
-guarantee(!equals(value1, value2), "Table entries must not have identical arrays");
-}
 entry2 = (*entry2)->next_addr();
 }
 entry1 = (*entry1)->next_addr();
 }
 }
 "   [Table]\n"
 "      [Memory Usage: " G1_STRDEDUP_BYTES_FORMAT_NS "]\n"
 "      [Size: " SIZE_FORMAT ", Min: " SIZE_FORMAT ", Max: " SIZE_FORMAT "]\n"
 "      [Entries: " UINTX_FORMAT ", Load: " G1_STRDEDUP_PERCENT_FORMAT_NS ", Cached: " UINTX_FORMAT ", Added: " UINTX_FORMAT ", Removed: " UINTX_FORMAT "]\n"
 "      [Resize Count: " UINTX_FORMAT ", Shrink Threshold: " UINTX_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT_NS "), Grow Threshold: " UINTX_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT_NS ")]\n"
-"      [Rehash Count: " UINTX_FORMAT ", Rehash Threshold: " UINTX_FORMAT ", Hash Seed: " UINT64_FORMAT_X "]\n"
+"      [Rehash Count: " UINTX_FORMAT ", Rehash Threshold: " UINTX_FORMAT ", Hash Seed: " UINT64_FORMAT "]\n"
 "      [Age Threshold: " UINTX_FORMAT "]",
 G1_STRDEDUP_BYTES_PARAM(_table->_size * sizeof(G1StringDedupEntry*) + (_table->_entries + _entry_cache->size()) * sizeof(G1StringDedupEntry)),
 _table->_size, _min_size, _max_size,
 _table->_entries, (double)_table->_entries / (double)_table->_size * 100.0, _entry_cache->size(), _entries_added, _entries_removed,
 _resize_count, _table->_shrink_threshold, _shrink_load_factor * 100.0, _table->_grow_threshold, _grow_load_factor * 100.0,

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

comparison: src/share/vm/gc_implementation/g1/g1StringDedupTable.cpp

src/share/vm/gc_implementation/g1/g1StringDedupTable.cpp