1 /*
2 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/altHashing.hpp"
27 #include "classfile/compactHashtable.inline.hpp"
28 #include "classfile/javaClasses.hpp"
29 #include "classfile/symbolTable.hpp"
30 #include "classfile/systemDictionary.hpp"
31 #include "gc/shared/collectedHeap.inline.hpp"
32 #include "gc/shared/gcLocker.inline.hpp"
33 #include "memory/allocation.inline.hpp"
34 #include "memory/filemap.hpp"
35 #include "memory/resourceArea.hpp"
36 #include "oops/oop.inline.hpp"
37 #include "runtime/atomic.inline.hpp"
38 #include "runtime/mutexLocker.hpp"
39 #include "utilities/hashtable.inline.hpp"
40
41 // --------------------------------------------------------------------------
42 // the number of buckets a thread claims
43 const int ClaimChunkSize = 32;
44
45 SymbolTable* SymbolTable::_the_table = NULL;
46 // Static arena for symbols that are not deallocated
47 Arena* SymbolTable::_arena = NULL;
48 bool SymbolTable::_needs_rehashing = false;
49 bool SymbolTable::_lookup_shared_first = false;
50
51 CompactHashtable<Symbol*, char> SymbolTable::_shared_table;
52
53 Symbol* SymbolTable::allocate_symbol(const u1* name, int len, bool c_heap, TRAPS) {
54 assert (len <= Symbol::max_length(), "should be checked by caller");
55
56 Symbol* sym;
57
58 if (DumpSharedSpaces) {
59 // Allocate all symbols to CLD shared metaspace
60 sym = new (len, ClassLoaderData::the_null_class_loader_data(), THREAD) Symbol(name, len, PERM_REFCOUNT);
61 } else if (c_heap) {
62 // refcount starts as 1
63 sym = new (len, THREAD) Symbol(name, len, 1);
64 assert(sym != NULL, "new should call vm_exit_out_of_memory if C_HEAP is exhausted");
65 } else {
66 // Allocate to global arena
67 sym = new (len, arena(), THREAD) Symbol(name, len, PERM_REFCOUNT);
68 }
69 return sym;
70 }
71
72 void SymbolTable::initialize_symbols(int arena_alloc_size) {
73 // Initialize the arena for global symbols, size passed in depends on CDS.
74 if (arena_alloc_size == 0) {
75 _arena = new (mtSymbol) Arena(mtSymbol);
76 } else {
77 _arena = new (mtSymbol) Arena(mtSymbol, arena_alloc_size);
78 }
79 }
80
81 // Call function for all symbols in the symbol table.
82 void SymbolTable::symbols_do(SymbolClosure *cl) {
83 // all symbols from shared table
84 _shared_table.symbols_do(cl);
85
86 // all symbols from the dynamic table
87 const int n = the_table()->table_size();
88 for (int i = 0; i < n; i++) {
89 for (HashtableEntry<Symbol*, mtSymbol>* p = the_table()->bucket(i);
90 p != NULL;
91 p = p->next()) {
92 cl->do_symbol(p->literal_addr());
93 }
94 }
95 }
96
97 int SymbolTable::_symbols_removed = 0;
98 int SymbolTable::_symbols_counted = 0;
99 volatile int SymbolTable::_parallel_claimed_idx = 0;
100
101 void SymbolTable::buckets_unlink(int start_idx, int end_idx, int* processed, int* removed) {
102 for (int i = start_idx; i < end_idx; ++i) {
103 HashtableEntry<Symbol*, mtSymbol>** p = the_table()->bucket_addr(i);
104 HashtableEntry<Symbol*, mtSymbol>* entry = the_table()->bucket(i);
105 while (entry != NULL) {
106 // Shared entries are normally at the end of the bucket and if we run into
107 // a shared entry, then there is nothing more to remove. However, if we
108 // have rehashed the table, then the shared entries are no longer at the
109 // end of the bucket.
110 if (entry->is_shared() && !use_alternate_hashcode()) {
111 break;
112 }
113 Symbol* s = entry->literal();
114 (*processed)++;
115 assert(s != NULL, "just checking");
116 // If reference count is zero, remove.
117 if (s->refcount() == 0) {
118 assert(!entry->is_shared(), "shared entries should be kept live");
119 delete s;
120 (*removed)++;
121 *p = entry->next();
122 the_table()->free_entry(entry);
123 } else {
124 p = entry->next_addr();
125 }
126 // get next entry
127 entry = (HashtableEntry<Symbol*, mtSymbol>*)HashtableEntry<Symbol*, mtSymbol>::make_ptr(*p);
128 }
129 }
130 }
131
132 // Remove unreferenced symbols from the symbol table
133 // This is done late during GC.
134 void SymbolTable::unlink(int* processed, int* removed) {
135 size_t memory_total = 0;
136 buckets_unlink(0, the_table()->table_size(), processed, removed);
137 _symbols_removed += *removed;
138 _symbols_counted += *processed;
139 }
140
141 void SymbolTable::possibly_parallel_unlink(int* processed, int* removed) {
142 const int limit = the_table()->table_size();
143
144 size_t memory_total = 0;
145
146 for (;;) {
147 // Grab next set of buckets to scan
148 int start_idx = Atomic::add(ClaimChunkSize, &_parallel_claimed_idx) - ClaimChunkSize;
149 if (start_idx >= limit) {
150 // End of table
151 break;
152 }
153
154 int end_idx = MIN2(limit, start_idx + ClaimChunkSize);
155 buckets_unlink(start_idx, end_idx, processed, removed);
156 }
157 Atomic::add(*processed, &_symbols_counted);
158 Atomic::add(*removed, &_symbols_removed);
159 }
160
161 // Create a new table and using alternate hash code, populate the new table
162 // with the existing strings. Set flag to use the alternate hash code afterwards.
163 void SymbolTable::rehash_table() {
164 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
165 // This should never happen with -Xshare:dump but it might in testing mode.
166 if (DumpSharedSpaces) return;
167 // Create a new symbol table
168 SymbolTable* new_table = new SymbolTable();
169
170 the_table()->move_to(new_table);
171
172 // Delete the table and buckets (entries are reused in new table).
173 delete _the_table;
174 // Don't check if we need rehashing until the table gets unbalanced again.
175 // Then rehash with a new global seed.
176 _needs_rehashing = false;
177 _the_table = new_table;
178 }
179
180 // Lookup a symbol in a bucket.
181
182 Symbol* SymbolTable::lookup_dynamic(int index, const char* name,
183 int len, unsigned int hash) {
184 int count = 0;
185 for (HashtableEntry<Symbol*, mtSymbol>* e = bucket(index); e != NULL; e = e->next()) {
186 count++; // count all entries in this bucket, not just ones with same hash
187 if (e->hash() == hash) {
188 Symbol* sym = e->literal();
189 if (sym->equals(name, len)) {
190 // something is referencing this symbol now.
191 sym->increment_refcount();
192 return sym;
193 }
194 }
195 }
196 // If the bucket size is too deep check if this hash code is insufficient.
197 if (count >= rehash_count && !needs_rehashing()) {
198 _needs_rehashing = check_rehash_table(count);
199 }
200 return NULL;
201 }
202
203 Symbol* SymbolTable::lookup_shared(const char* name,
204 int len, unsigned int hash) {
205 return _shared_table.lookup(name, hash, len);
206 }
207
208 Symbol* SymbolTable::lookup(int index, const char* name,
209 int len, unsigned int hash) {
210 Symbol* sym;
211 if (_lookup_shared_first) {
212 sym = lookup_shared(name, len, hash);
213 if (sym != NULL) {
214 return sym;
215 }
216 _lookup_shared_first = false;
217 return lookup_dynamic(index, name, len, hash);
218 } else {
219 sym = lookup_dynamic(index, name, len, hash);
220 if (sym != NULL) {
221 return sym;
222 }
223 sym = lookup_shared(name, len, hash);
224 if (sym != NULL) {
225 _lookup_shared_first = true;
226 }
227 return sym;
228 }
229 }
230
231 // Pick hashing algorithm.
232 unsigned int SymbolTable::hash_symbol(const char* s, int len) {
233 return use_alternate_hashcode() ?
234 AltHashing::murmur3_32(seed(), (const jbyte*)s, len) :
235 java_lang_String::hash_code((const jbyte*)s, len);
236 }
237
238
239 // We take care not to be blocking while holding the
240 // SymbolTable_lock. Otherwise, the system might deadlock, since the
241 // symboltable is used during compilation (VM_thread) The lock free
242 // synchronization is simplified by the fact that we do not delete
243 // entries in the symbol table during normal execution (only during
244 // safepoints).
245
246 Symbol* SymbolTable::lookup(const char* name, int len, TRAPS) {
247 unsigned int hashValue = hash_symbol(name, len);
248 int index = the_table()->hash_to_index(hashValue);
249
250 Symbol* s = the_table()->lookup(index, name, len, hashValue);
251
252 // Found
253 if (s != NULL) return s;
254
255 // Grab SymbolTable_lock first.
256 MutexLocker ml(SymbolTable_lock, THREAD);
257
258 // Otherwise, add to symbol to table
259 return the_table()->basic_add(index, (u1*)name, len, hashValue, true, THREAD);
260 }
261
262 Symbol* SymbolTable::lookup(const Symbol* sym, int begin, int end, TRAPS) {
263 char* buffer;
264 int index, len;
265 unsigned int hashValue;
266 char* name;
267 {
268 debug_only(NoSafepointVerifier nsv;)
269
270 name = (char*)sym->base() + begin;
271 len = end - begin;
272 hashValue = hash_symbol(name, len);
273 index = the_table()->hash_to_index(hashValue);
274 Symbol* s = the_table()->lookup(index, name, len, hashValue);
275
276 // Found
277 if (s != NULL) return s;
278 }
279
280 // Otherwise, add to symbol to table. Copy to a C string first.
281 char stack_buf[128];
282 ResourceMark rm(THREAD);
283 if (len <= 128) {
284 buffer = stack_buf;
285 } else {
286 buffer = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);
287 }
288 for (int i=0; i<len; i++) {
289 buffer[i] = name[i];
290 }
291 // Make sure there is no safepoint in the code above since name can't move.
292 // We can't include the code in NoSafepointVerifier because of the
293 // ResourceMark.
294
295 // Grab SymbolTable_lock first.
296 MutexLocker ml(SymbolTable_lock, THREAD);
297
298 return the_table()->basic_add(index, (u1*)buffer, len, hashValue, true, THREAD);
299 }
300
301 Symbol* SymbolTable::lookup_only(const char* name, int len,
302 unsigned int& hash) {
303 hash = hash_symbol(name, len);
304 int index = the_table()->hash_to_index(hash);
305
306 Symbol* s = the_table()->lookup(index, name, len, hash);
307 return s;
308 }
309
310 // Look up the address of the literal in the SymbolTable for this Symbol*
311 // Do not create any new symbols
312 // Do not increment the reference count to keep this alive
313 Symbol** SymbolTable::lookup_symbol_addr(Symbol* sym){
314 unsigned int hash = hash_symbol((char*)sym->bytes(), sym->utf8_length());
315 int index = the_table()->hash_to_index(hash);
316
317 for (HashtableEntry<Symbol*, mtSymbol>* e = the_table()->bucket(index); e != NULL; e = e->next()) {
318 if (e->hash() == hash) {
319 Symbol* literal_sym = e->literal();
320 if (sym == literal_sym) {
321 return e->literal_addr();
322 }
323 }
324 }
325 return NULL;
326 }
327
328 // Suggestion: Push unicode-based lookup all the way into the hashing
329 // and probing logic, so there is no need for convert_to_utf8 until
330 // an actual new Symbol* is created.
331 Symbol* SymbolTable::lookup_unicode(const jchar* name, int utf16_length, TRAPS) {
332 int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length);
333 char stack_buf[128];
334 if (utf8_length < (int) sizeof(stack_buf)) {
335 char* chars = stack_buf;
336 UNICODE::convert_to_utf8(name, utf16_length, chars);
337 return lookup(chars, utf8_length, THREAD);
338 } else {
339 ResourceMark rm(THREAD);
340 char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);;
341 UNICODE::convert_to_utf8(name, utf16_length, chars);
342 return lookup(chars, utf8_length, THREAD);
343 }
344 }
345
346 Symbol* SymbolTable::lookup_only_unicode(const jchar* name, int utf16_length,
347 unsigned int& hash) {
348 int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length);
349 char stack_buf[128];
350 if (utf8_length < (int) sizeof(stack_buf)) {
351 char* chars = stack_buf;
352 UNICODE::convert_to_utf8(name, utf16_length, chars);
353 return lookup_only(chars, utf8_length, hash);
354 } else {
355 ResourceMark rm;
356 char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);;
357 UNICODE::convert_to_utf8(name, utf16_length, chars);
358 return lookup_only(chars, utf8_length, hash);
359 }
360 }
361
362 void SymbolTable::add(ClassLoaderData* loader_data, const constantPoolHandle& cp,
363 int names_count,
364 const char** names, int* lengths, int* cp_indices,
365 unsigned int* hashValues, TRAPS) {
366 // Grab SymbolTable_lock first.
367 MutexLocker ml(SymbolTable_lock, THREAD);
368
369 SymbolTable* table = the_table();
370 bool added = table->basic_add(loader_data, cp, names_count, names, lengths,
371 cp_indices, hashValues, CHECK);
372 if (!added) {
373 // do it the hard way
374 for (int i=0; i<names_count; i++) {
375 int index = table->hash_to_index(hashValues[i]);
376 bool c_heap = !loader_data->is_the_null_class_loader_data();
377 Symbol* sym = table->basic_add(index, (u1*)names[i], lengths[i], hashValues[i], c_heap, CHECK);
378 cp->symbol_at_put(cp_indices[i], sym);
379 }
380 }
381 }
382
383 Symbol* SymbolTable::new_permanent_symbol(const char* name, TRAPS) {
384 unsigned int hash;
385 Symbol* result = SymbolTable::lookup_only((char*)name, (int)strlen(name), hash);
386 if (result != NULL) {
387 return result;
388 }
389 // Grab SymbolTable_lock first.
390 MutexLocker ml(SymbolTable_lock, THREAD);
391
392 SymbolTable* table = the_table();
393 int index = table->hash_to_index(hash);
394 return table->basic_add(index, (u1*)name, (int)strlen(name), hash, false, THREAD);
395 }
396
397 Symbol* SymbolTable::basic_add(int index_arg, u1 *name, int len,
398 unsigned int hashValue_arg, bool c_heap, TRAPS) {
399 assert(!Universe::heap()->is_in_reserved(name),
400 "proposed name of symbol must be stable");
401
402 // Don't allow symbols to be created which cannot fit in a Symbol*.
403 if (len > Symbol::max_length()) {
404 THROW_MSG_0(vmSymbols::java_lang_InternalError(),
405 "name is too long to represent");
406 }
407
408 // Cannot hit a safepoint in this function because the "this" pointer can move.
409 NoSafepointVerifier nsv;
410
411 // Check if the symbol table has been rehashed, if so, need to recalculate
412 // the hash value and index.
413 unsigned int hashValue;
414 int index;
415 if (use_alternate_hashcode()) {
416 hashValue = hash_symbol((const char*)name, len);
417 index = hash_to_index(hashValue);
418 } else {
419 hashValue = hashValue_arg;
420 index = index_arg;
421 }
422
423 // Since look-up was done lock-free, we need to check if another
424 // thread beat us in the race to insert the symbol.
425 Symbol* test = lookup(index, (char*)name, len, hashValue);
426 if (test != NULL) {
427 // A race occurred and another thread introduced the symbol.
428 assert(test->refcount() != 0, "lookup should have incremented the count");
429 return test;
430 }
431
432 // Create a new symbol.
433 Symbol* sym = allocate_symbol(name, len, c_heap, CHECK_NULL);
434 assert(sym->equals((char*)name, len), "symbol must be properly initialized");
435
436 HashtableEntry<Symbol*, mtSymbol>* entry = new_entry(hashValue, sym);
437 add_entry(index, entry);
438 return sym;
439 }
440
441 // This version of basic_add adds symbols in batch from the constant pool
442 // parsing.
443 bool SymbolTable::basic_add(ClassLoaderData* loader_data, const constantPoolHandle& cp,
444 int names_count,
445 const char** names, int* lengths,
446 int* cp_indices, unsigned int* hashValues,
447 TRAPS) {
448
449 // Check symbol names are not too long. If any are too long, don't add any.
450 for (int i = 0; i< names_count; i++) {
451 if (lengths[i] > Symbol::max_length()) {
452 THROW_MSG_0(vmSymbols::java_lang_InternalError(),
453 "name is too long to represent");
454 }
455 }
456
457 // Cannot hit a safepoint in this function because the "this" pointer can move.
458 NoSafepointVerifier nsv;
459
460 for (int i=0; i<names_count; i++) {
461 // Check if the symbol table has been rehashed, if so, need to recalculate
462 // the hash value.
463 unsigned int hashValue;
464 if (use_alternate_hashcode()) {
465 hashValue = hash_symbol(names[i], lengths[i]);
466 } else {
467 hashValue = hashValues[i];
468 }
469 // Since look-up was done lock-free, we need to check if another
470 // thread beat us in the race to insert the symbol.
471 int index = hash_to_index(hashValue);
472 Symbol* test = lookup(index, names[i], lengths[i], hashValue);
473 if (test != NULL) {
474 // A race occurred and another thread introduced the symbol, this one
475 // will be dropped and collected. Use test instead.
476 cp->symbol_at_put(cp_indices[i], test);
477 assert(test->refcount() != 0, "lookup should have incremented the count");
478 } else {
479 // Create a new symbol. The null class loader is never unloaded so these
480 // are allocated specially in a permanent arena.
481 bool c_heap = !loader_data->is_the_null_class_loader_data();
482 Symbol* sym = allocate_symbol((const u1*)names[i], lengths[i], c_heap, CHECK_(false));
483 assert(sym->equals(names[i], lengths[i]), "symbol must be properly initialized"); // why wouldn't it be???
484 HashtableEntry<Symbol*, mtSymbol>* entry = new_entry(hashValue, sym);
485 add_entry(index, entry);
486 cp->symbol_at_put(cp_indices[i], sym);
487 }
488 }
489 return true;
490 }
491
492
493 void SymbolTable::verify() {
494 for (int i = 0; i < the_table()->table_size(); ++i) {
495 HashtableEntry<Symbol*, mtSymbol>* p = the_table()->bucket(i);
496 for ( ; p != NULL; p = p->next()) {
497 Symbol* s = (Symbol*)(p->literal());
498 guarantee(s != NULL, "symbol is NULL");
499 unsigned int h = hash_symbol((char*)s->bytes(), s->utf8_length());
500 guarantee(p->hash() == h, "broken hash in symbol table entry");
501 guarantee(the_table()->hash_to_index(h) == i,
502 "wrong index in symbol table");
503 }
504 }
505 }
506
507 void SymbolTable::dump(outputStream* st, bool verbose) {
508 if (!verbose) {
509 the_table()->dump_table(st, "SymbolTable");
510 } else {
511 st->print_cr("VERSION: 1.0");
512 for (int i = 0; i < the_table()->table_size(); ++i) {
513 HashtableEntry<Symbol*, mtSymbol>* p = the_table()->bucket(i);
514 for ( ; p != NULL; p = p->next()) {
515 Symbol* s = (Symbol*)(p->literal());
516 const char* utf8_string = (const char*)s->bytes();
517 int utf8_length = s->utf8_length();
518 st->print("%d %d: ", utf8_length, s->refcount());
519 HashtableTextDump::put_utf8(st, utf8_string, utf8_length);
520 st->cr();
521 }
522 }
523 }
524 }
525
526 bool SymbolTable::copy_compact_table(char** top, char*end) {
527 #if INCLUDE_CDS
528 CompactHashtableWriter ch_table(CompactHashtable<Symbol*, char>::_symbol_table,
529 the_table()->number_of_entries(),
530 &MetaspaceShared::stats()->symbol);
531 if (*top + ch_table.get_required_bytes() > end) {
532 // not enough space left
533 return false;
534 }
535
536 for (int i = 0; i < the_table()->table_size(); ++i) {
537 HashtableEntry<Symbol*, mtSymbol>* p = the_table()->bucket(i);
538 for ( ; p != NULL; p = p->next()) {
539 Symbol* s = (Symbol*)(p->literal());
540 unsigned int fixed_hash = hash_symbol((char*)s->bytes(), s->utf8_length());
541 assert(fixed_hash == p->hash(), "must not rehash during dumping");
542 ch_table.add(fixed_hash, s);
543 }
544 }
545
546 ch_table.dump(top, end);
547
548 *top = (char*)align_ptr_up(*top, sizeof(void*));
549 #endif
550 return true;
551 }
552
553 const char* SymbolTable::init_shared_table(const char* buffer) {
554 const char* end = _shared_table.init(
555 CompactHashtable<Symbol*, char>::_symbol_table, buffer);
556 return (const char*)align_ptr_up(end, sizeof(void*));
557 }
558
559 //---------------------------------------------------------------------------
560 // Non-product code
561
562 #ifndef PRODUCT
563
564 void SymbolTable::print_histogram() {
565 MutexLocker ml(SymbolTable_lock);
566 const int results_length = 100;
567 int counts[results_length];
568 int sizes[results_length];
569 int i,j;
570
571 // initialize results to zero
572 for (j = 0; j < results_length; j++) {
573 counts[j] = 0;
574 sizes[j] = 0;
575 }
576
577 int total_size = 0;
578 int total_count = 0;
579 int total_length = 0;
580 int max_length = 0;
581 int out_of_range_count = 0;
582 int out_of_range_size = 0;
583 for (i = 0; i < the_table()->table_size(); i++) {
584 HashtableEntry<Symbol*, mtSymbol>* p = the_table()->bucket(i);
585 for ( ; p != NULL; p = p->next()) {
586 int size = p->literal()->size();
587 int len = p->literal()->utf8_length();
588 if (len < results_length) {
589 counts[len]++;
590 sizes[len] += size;
591 } else {
592 out_of_range_count++;
593 out_of_range_size += size;
594 }
595 total_count++;
596 total_size += size;
597 total_length += len;
598 max_length = MAX2(max_length, len);
599 }
600 }
601 tty->print_cr("Symbol Table Histogram:");
602 tty->print_cr(" Total number of symbols %7d", total_count);
603 tty->print_cr(" Total size in memory %7dK",
604 (total_size*wordSize)/1024);
605 tty->print_cr(" Total counted %7d", _symbols_counted);
606 tty->print_cr(" Total removed %7d", _symbols_removed);
607 if (_symbols_counted > 0) {
608 tty->print_cr(" Percent removed %3.2f",
609 ((float)_symbols_removed/(float)_symbols_counted)* 100);
610 }
611 tty->print_cr(" Reference counts %7d", Symbol::_total_count);
612 tty->print_cr(" Symbol arena used " SIZE_FORMAT_W(7) "K", arena()->used()/1024);
613 tty->print_cr(" Symbol arena size " SIZE_FORMAT_W(7) "K", arena()->size_in_bytes()/1024);
614 tty->print_cr(" Total symbol length %7d", total_length);
615 tty->print_cr(" Maximum symbol length %7d", max_length);
616 tty->print_cr(" Average symbol length %7.2f", ((float) total_length / (float) total_count));
617 tty->print_cr(" Symbol length histogram:");
618 tty->print_cr(" %6s %10s %10s", "Length", "#Symbols", "Size");
619 for (i = 0; i < results_length; i++) {
620 if (counts[i] > 0) {
621 tty->print_cr(" %6d %10d %10dK", i, counts[i], (sizes[i]*wordSize)/1024);
622 }
623 }
624 tty->print_cr(" >=%6d %10d %10dK\n", results_length,
625 out_of_range_count, (out_of_range_size*wordSize)/1024);
626 }
627
628 void SymbolTable::print() {
629 for (int i = 0; i < the_table()->table_size(); ++i) {
630 HashtableEntry<Symbol*, mtSymbol>** p = the_table()->bucket_addr(i);
631 HashtableEntry<Symbol*, mtSymbol>* entry = the_table()->bucket(i);
632 if (entry != NULL) {
633 while (entry != NULL) {
634 tty->print(PTR_FORMAT " ", p2i(entry->literal()));
635 entry->literal()->print();
636 tty->print(" %d", entry->literal()->refcount());
637 p = entry->next_addr();
638 entry = (HashtableEntry<Symbol*, mtSymbol>*)HashtableEntry<Symbol*, mtSymbol>::make_ptr(*p);
639 }
640 tty->cr();
641 }
642 }
643 }
644 #endif // PRODUCT
645
646
647 // Utility for dumping symbols
648 SymboltableDCmd::SymboltableDCmd(outputStream* output, bool heap) :
649 DCmdWithParser(output, heap),
650 _verbose("-verbose", "Dump the content of each symbol in the table",
651 "BOOLEAN", false, "false") {
652 _dcmdparser.add_dcmd_option(&_verbose);
653 }
654
655 void SymboltableDCmd::execute(DCmdSource source, TRAPS) {
656 VM_DumpHashtable dumper(output(), VM_DumpHashtable::DumpSymbols,
657 _verbose.value());
658 VMThread::execute(&dumper);
659 }
660
661 int SymboltableDCmd::num_arguments() {
662 ResourceMark rm;
663 SymboltableDCmd* dcmd = new SymboltableDCmd(NULL, false);
664 if (dcmd != NULL) {
665 DCmdMark mark(dcmd);
666 return dcmd->_dcmdparser.num_arguments();
667 } else {
668 return 0;
669 }
670 }
671
672 #ifndef PRODUCT
673 // Internal test of TempNewSymbol
674 void Test_TempNewSymbol() {
675 // Assert messages assume these symbols are unique, and the refcounts start at
676 // one, but code does not rely on this.
677 Thread* THREAD = Thread::current();
678 Symbol* abc = SymbolTable::new_symbol("abc", CATCH);
679 int abccount = abc->refcount();
680 TempNewSymbol ss = abc;
681 assert(ss->refcount() == abccount, "only one abc");
682 assert(ss->refcount() == abc->refcount(), "should match TempNewSymbol");
683
684 Symbol* efg = SymbolTable::new_symbol("efg", CATCH);
685 Symbol* hij = SymbolTable::new_symbol("hij", CATCH);
686 int efgcount = efg->refcount();
687 int hijcount = hij->refcount();
688
689 TempNewSymbol s1 = efg;
690 TempNewSymbol s2 = hij;
691 assert(s1->refcount() == efgcount, "one efg");
692 assert(s2->refcount() == hijcount, "one hij");
693
694 // Assignment operator
695 s1 = s2;
696 assert(hij->refcount() == hijcount + 1, "should be two hij");
697 assert(efg->refcount() == efgcount - 1, "should be no efg");
698
699 s1 = ss; // s1 is abc
700 assert(s1->refcount() == abccount + 1, "should be two abc (s1 and ss)");
701 assert(hij->refcount() == hijcount, "should only have one hij now (s2)");
702
703 s1 = s1; // self assignment
704 assert(s1->refcount() == abccount + 1, "should still be two abc (s1 and ss)");
705
706 TempNewSymbol s3;
707 Symbol* klm = SymbolTable::new_symbol("klm", CATCH);
708 int klmcount = klm->refcount();
709 s3 = klm; // assignment
710 assert(s3->refcount() == klmcount, "only one klm now");
711
712 Symbol* xyz = SymbolTable::new_symbol("xyz", CATCH);
713 int xyzcount = xyz->refcount();
714 { // inner scope
715 TempNewSymbol s_inner = xyz;
716 }
717 assert(xyz->refcount() == (xyzcount - 1),
718 "Should have been decremented by dtor in inner scope");
719 }
720 #endif // PRODUCT