graal-jvmci-8: src/share/vm/classfile/symbolTable.cpp comparison

comparison src/share/vm/classfile/symbolTable.cpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	4ca6dc0799b6 78bbf4d43a14
children	7848fc12602b

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 /*
-* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #include "memory/gcLocker.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/oop.inline2.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "utilities/hashtable.inline.hpp"
+#if INCLUDE_ALL_GCS
+#include "gc_implementation/g1/g1StringDedup.hpp"
+#endif
+PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
 // --------------------------------------------------------------------------
+// the number of buckets a thread claims
+const int ClaimChunkSize = 32;
 SymbolTable* SymbolTable::_the_table = NULL;
 // Static arena for symbols that are not deallocated
 Arena* SymbolTable::_arena = NULL;
 bool SymbolTable::_needs_rehashing = false;
 cl->do_symbol(p->literal_addr());
 }
 }
 }
-int SymbolTable::symbols_removed = 0;
+int SymbolTable::_symbols_removed = 0;
-int SymbolTable::symbols_counted = 0;
+int SymbolTable::_symbols_counted = 0;
+volatile int SymbolTable::_parallel_claimed_idx = 0;
-// Remove unreferenced symbols from the symbol table
-// This is done late during GC.
+void SymbolTable::buckets_unlink(int start_idx, int end_idx, int* processed, int* removed, size_t* memory_total) {
-void SymbolTable::unlink() {
+for (int i = start_idx; i < end_idx; ++i) {
-int removed = 0;
-int total = 0;
-size_t memory_total = 0;
-for (int i = 0; i < the_table()->table_size(); ++i) {
 HashtableEntry<Symbol*, mtSymbol>** p = the_table()->bucket_addr(i);
 HashtableEntry<Symbol*, mtSymbol>* entry = the_table()->bucket(i);
 while (entry != NULL) {
 // Shared entries are normally at the end of the bucket and if we run into
 // a shared entry, then there is nothing more to remove. However, if we
 // end of the bucket.
 if (entry->is_shared() && !use_alternate_hashcode()) {
 break;
 }
 Symbol* s = entry->literal();
-memory_total += s->size();
+(*memory_total) += s->size();
-total++;
+(*processed)++;
 assert(s != NULL, "just checking");
 // If reference count is zero, remove.
 if (s->refcount() == 0) {
 assert(!entry->is_shared(), "shared entries should be kept live");
 delete s;
-removed++;
+(*removed)++;
 *p = entry->next();
 the_table()->free_entry(entry);
 } else {
 p = entry->next_addr();
 }
 // get next entry
 entry = (HashtableEntry<Symbol*, mtSymbol>*)HashtableEntry<Symbol*, mtSymbol>::make_ptr(*p);
 }
 }
-symbols_removed += removed;
+}
-symbols_counted += total;
+// Remove unreferenced symbols from the symbol table
+// This is done late during GC.
+void SymbolTable::unlink(int* processed, int* removed) {
+size_t memory_total = 0;
+buckets_unlink(0, the_table()->table_size(), processed, removed, &memory_total);
+_symbols_removed += *removed;
+_symbols_counted += *processed;
 // Exclude printing for normal PrintGCDetails because people parse
 // this output.
 if (PrintGCDetails && Verbose && WizardMode) {
-gclog_or_tty->print(" [Symbols=%d size=" SIZE_FORMAT "K] ", total,
+gclog_or_tty->print(" [Symbols=%d size=" SIZE_FORMAT "K] ", *processed,
+(memory_total*HeapWordSize)/1024);
+}
+}
+void SymbolTable::possibly_parallel_unlink(int* processed, int* removed) {
+const int limit = the_table()->table_size();
+size_t memory_total = 0;
+for (;;) {
+// Grab next set of buckets to scan
+int start_idx = Atomic::add(ClaimChunkSize, &_parallel_claimed_idx) - ClaimChunkSize;
+if (start_idx >= limit) {
+// End of table
+break;
+}
+int end_idx = MIN2(limit, start_idx + ClaimChunkSize);
+buckets_unlink(start_idx, end_idx, processed, removed, &memory_total);
+}
+Atomic::add(*processed, &_symbols_counted);
+Atomic::add(*removed, &_symbols_removed);
+// Exclude printing for normal PrintGCDetails because people parse
+// this output.
+if (PrintGCDetails && Verbose && WizardMode) {
+gclog_or_tty->print(" [Symbols: scanned=%d removed=%d size=" SIZE_FORMAT "K] ", *processed, *removed,
 (memory_total*HeapWordSize)/1024);
 }
 }
 // Create a new table and using alternate hash code, populate the new table
 }
 tty->print_cr("Symbol Table:");
 tty->print_cr("Total number of symbols  %5d", count);
 tty->print_cr("Total size in memory     %5dK",
 (memory_total*HeapWordSize)/1024);
-tty->print_cr("Total counted            %5d", symbols_counted);
+tty->print_cr("Total counted            %5d", _symbols_counted);
-tty->print_cr("Total removed            %5d", symbols_removed);
+tty->print_cr("Total removed            %5d", _symbols_removed);
-if (symbols_counted > 0) {
+if (_symbols_counted > 0) {
 tty->print_cr("Percent removed          %3.2f",
-((float)symbols_removed/(float)symbols_counted)* 100);
+((float)_symbols_removed/(float)_symbols_counted)* 100);
 }
 tty->print_cr("Reference counts         %5d", Symbol::_total_count);
 tty->print_cr("Symbol arena size        %5d used %5d",
 arena()->size_in_bytes(), arena()->used());
 tty->print_cr("Histogram of symbol length:");
 string = string_or_null;
 } else {
 string = java_lang_String::create_from_unicode(name, len, CHECK_NULL);
 }
+#if INCLUDE_ALL_GCS
+if (G1StringDedup::is_enabled()) {
+// Deduplicate the string before it is interned. Note that we should never
+// deduplicate a string after it has been interned. Doing so will counteract
+// compiler optimizations done on e.g. interned string literals.
+G1StringDedup::deduplicate(string());
+}
+#endif
 // Grab the StringTable_lock before getting the_table() because it could
 // change at safepoint.
 MutexLocker ml(StringTable_lock, THREAD);
 // Otherwise, add to symbol to table
 Handle string;
 oop result = intern(string, chars, length, CHECK_NULL);
 return result;
 }
-void StringTable::unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* f) {
+void StringTable::unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* f, int* processed, int* removed) {
+buckets_unlink_or_oops_do(is_alive, f, 0, the_table()->table_size(), processed, removed);
+}
+void StringTable::possibly_parallel_unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* f, int* processed, int* removed) {
 // Readers of the table are unlocked, so we should only be removing
 // entries at a safepoint.
 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
-for (int i = 0; i < the_table()->table_size(); ++i) {
+const int limit = the_table()->table_size();
+for (;;) {
+// Grab next set of buckets to scan
+int start_idx = Atomic::add(ClaimChunkSize, &_parallel_claimed_idx) - ClaimChunkSize;
+if (start_idx >= limit) {
+// End of table
+break;
+}
+int end_idx = MIN2(limit, start_idx + ClaimChunkSize);
+buckets_unlink_or_oops_do(is_alive, f, start_idx, end_idx, processed, removed);
+}
+}
+void StringTable::buckets_oops_do(OopClosure* f, int start_idx, int end_idx) {
+const int limit = the_table()->table_size();
+assert(0 <= start_idx && start_idx <= limit,
+err_msg("start_idx (" INT32_FORMAT ") is out of bounds", start_idx));
+assert(0 <= end_idx && end_idx <= limit,
+err_msg("end_idx (" INT32_FORMAT ") is out of bounds", end_idx));
+assert(start_idx <= end_idx,
+err_msg("Index ordering: start_idx=" INT32_FORMAT", end_idx=" INT32_FORMAT,
+start_idx, end_idx));
+for (int i = start_idx; i < end_idx; i += 1) {
+HashtableEntry<oop, mtSymbol>* entry = the_table()->bucket(i);
+while (entry != NULL) {
+assert(!entry->is_shared(), "CDS not used for the StringTable");
+f->do_oop((oop*)entry->literal_addr());
+entry = entry->next();
+}
+}
+}
+void StringTable::buckets_unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* f, int start_idx, int end_idx, int* processed, int* removed) {
+const int limit = the_table()->table_size();
+assert(0 <= start_idx && start_idx <= limit,
+err_msg("start_idx (" INT32_FORMAT ") is out of bounds", start_idx));
+assert(0 <= end_idx && end_idx <= limit,
+err_msg("end_idx (" INT32_FORMAT ") is out of bounds", end_idx));
+assert(start_idx <= end_idx,
+err_msg("Index ordering: start_idx=" INT32_FORMAT", end_idx=" INT32_FORMAT,
+start_idx, end_idx));
+for (int i = start_idx; i < end_idx; ++i) {
 HashtableEntry<oop, mtSymbol>** p = the_table()->bucket_addr(i);
 HashtableEntry<oop, mtSymbol>* entry = the_table()->bucket(i);
 while (entry != NULL) {
 assert(!entry->is_shared(), "CDS not used for the StringTable");
 }
 p = entry->next_addr();
 } else {
 *p = entry->next();
 the_table()->free_entry(entry);
-}
+(*removed)++;
+}
+(*processed)++;
 entry = *p;
 }
 }
 }
-void StringTable::buckets_do(OopClosure* f, int start_idx, int end_idx) {
-const int limit = the_table()->table_size();
-assert(0 <= start_idx && start_idx <= limit,
-err_msg("start_idx (" INT32_FORMAT ") oob?", start_idx));
-assert(0 <= end_idx && end_idx <= limit,
-err_msg("end_idx (" INT32_FORMAT ") oob?", end_idx));
-assert(start_idx <= end_idx,
-err_msg("Ordering: start_idx=" INT32_FORMAT", end_idx=" INT32_FORMAT,
-start_idx, end_idx));
-for (int i = start_idx; i < end_idx; i += 1) {
-HashtableEntry<oop, mtSymbol>* entry = the_table()->bucket(i);
-while (entry != NULL) {
-assert(!entry->is_shared(), "CDS not used for the StringTable");
-f->do_oop((oop*)entry->literal_addr());
-entry = entry->next();
-}
-}
-}
 void StringTable::oops_do(OopClosure* f) {
-buckets_do(f, 0, the_table()->table_size());
+buckets_oops_do(f, 0, the_table()->table_size());
 }
 void StringTable::possibly_parallel_oops_do(OopClosure* f) {
-const int ClaimChunkSize = 32;
 const int limit = the_table()->table_size();
 for (;;) {
 // Grab next set of buckets to scan
 int start_idx = Atomic::add(ClaimChunkSize, &_parallel_claimed_idx) - ClaimChunkSize;
 // End of table
 break;
 }
 int end_idx = MIN2(limit, start_idx + ClaimChunkSize);
-buckets_do(f, start_idx, end_idx);
+buckets_oops_do(f, start_idx, end_idx);
 }
 }
 // This verification is part of Universe::verify() and needs to be quick.
 // See StringTable::verify_and_compare() below for exhaustive verification.

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/classfile/symbolTable.cpp @ 18041:52b4284cb496