1 /* 2 * Copyright (c) 1997, 2018, 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.inline.hpp" 29 #include "classfile/stringTable.hpp" 30 #include "classfile/systemDictionary.hpp" 31 #include "gc/shared/collectedHeap.hpp" 32 #include "gc/shared/oopStorage.inline.hpp" 33 #include "gc/shared/oopStorageParState.inline.hpp" 34 #include "logging/log.hpp" 35 #include "logging/logStream.hpp" 36 #include "memory/allocation.inline.hpp" 37 #include "memory/filemap.hpp" 38 #include "memory/metaspaceShared.hpp" 39 #include "memory/resourceArea.hpp" 40 #include "memory/universe.hpp" 41 #include "oops/access.inline.hpp" 42 #include "oops/oop.inline.hpp" 43 #include "oops/typeArrayOop.inline.hpp" 44 #include "oops/weakHandle.inline.hpp" 45 #include "runtime/atomic.hpp" 46 #include "runtime/handles.inline.hpp" 47 #include "runtime/mutexLocker.hpp" 48 #include "runtime/safepointVerifiers.hpp" 49 #include "runtime/timerTrace.hpp" 50 #include "runtime/interfaceSupport.inline.hpp" 51 #include "services/diagnosticCommand.hpp" 52 #include "utilities/concurrentHashTable.inline.hpp" 53 #include "utilities/concurrentHashTableTasks.inline.hpp" 54 #include "utilities/macros.hpp" 55 56 // We prefer short chains of avg 2 57 #define PREF_AVG_LIST_LEN 2 58 // 2^24 is max size 59 #define END_SIZE 24 60 // If a chain gets to 32 something might be wrong 61 #define REHASH_LEN 32 62 // If we have as many dead items as 50% of the number of bucket 63 #define CLEAN_DEAD_HIGH_WATER_MARK 0.5 64 65 // -------------------------------------------------------------------------- 66 StringTable* StringTable::_the_table = NULL; 67 CompactHashtable<oop, char> StringTable::_shared_table; 68 volatile bool StringTable::_shared_string_mapped = false; 69 volatile bool StringTable::_alt_hash = false; 70 71 static juint murmur_seed = 0; 72 73 uintx hash_string(const jchar* s, int len, bool useAlt) { 74 return useAlt ? 75 AltHashing::murmur3_32(murmur_seed, s, len) : 76 java_lang_String::hash_code(s, len); 77 } 78 79 class StringTableConfig : public StringTableHash::BaseConfig { 80 private: 81 public: 82 static uintx get_hash(WeakHandle<vm_string_table_data> const& value, 83 bool* is_dead) { 84 EXCEPTION_MARK; 85 oop val_oop = value.peek(); 86 if (val_oop == NULL) { 87 *is_dead = true; 88 return 0; 89 } 90 *is_dead = false; 91 ResourceMark rm(THREAD); 92 // All String oops are hashed as unicode 93 int length; 94 jchar* chars = java_lang_String::as_unicode_string(val_oop, length, THREAD); 95 if (chars != NULL) { 96 return hash_string(chars, length, StringTable::_alt_hash); 97 } 98 vm_exit_out_of_memory(length, OOM_MALLOC_ERROR, "get hash from oop"); 99 return 0; 100 } 101 // We use default allocation/deallocation but counted 102 static void* allocate_node(size_t size, 103 WeakHandle<vm_string_table_data> const& value) { 104 StringTable::item_added(); 105 return StringTableHash::BaseConfig::allocate_node(size, value); 106 } 107 static void free_node(void* memory, 108 WeakHandle<vm_string_table_data> const& value) { 109 value.release(); 110 StringTableHash::BaseConfig::free_node(memory, value); 111 StringTable::item_removed(); 112 } 113 }; 114 115 class StringTableLookupJchar : StackObj { 116 private: 117 Thread* _thread; 118 uintx _hash; 119 int _len; 120 const jchar* _str; 121 Handle _found; 122 123 public: 124 StringTableLookupJchar(Thread* thread, uintx hash, const jchar* key, int len) 125 : _thread(thread), _hash(hash), _len(len), _str(key) { 126 } 127 uintx get_hash() const { 128 return _hash; 129 } 130 bool equals(WeakHandle<vm_string_table_data>* value, bool* is_dead) { 131 oop val_oop = value->peek(); 132 if (val_oop == NULL) { 133 // dead oop, mark this hash dead for cleaning 134 *is_dead = true; 135 return false; 136 } 137 bool equals = java_lang_String::equals(val_oop, (jchar*)_str, _len); 138 if (!equals) { 139 return false; 140 } 141 // Need to resolve weak handle and Handleize through possible safepoint. 142 _found = Handle(_thread, value->resolve()); 143 return true; 144 } 145 }; 146 147 class StringTableLookupOop : public StackObj { 148 private: 149 Thread* _thread; 150 uintx _hash; 151 Handle _find; 152 Handle _found; // Might be a different oop with the same value that's already 153 // in the table, which is the point. 154 public: 155 StringTableLookupOop(Thread* thread, uintx hash, Handle handle) 156 : _thread(thread), _hash(hash), _find(handle) { } 157 158 uintx get_hash() const { 159 return _hash; 160 } 161 162 bool equals(WeakHandle<vm_string_table_data>* value, bool* is_dead) { 163 oop val_oop = value->peek(); 164 if (val_oop == NULL) { 165 // dead oop, mark this hash dead for cleaning 166 *is_dead = true; 167 return false; 168 } 169 bool equals = java_lang_String::equals(_find(), val_oop); 170 if (!equals) { 171 return false; 172 } 173 // Need to resolve weak handle and Handleize through possible safepoint. 174 _found = Handle(_thread, value->resolve()); 175 return true; 176 } 177 }; 178 179 static size_t ceil_log2(size_t val) { 180 size_t ret; 181 for (ret = 1; ((size_t)1 << ret) < val; ++ret); 182 return ret; 183 } 184 185 StringTable::StringTable() : _local_table(NULL), _current_size(0), _has_work(0), 186 _needs_rehashing(false), _weak_handles(NULL), _items_count(0), _uncleaned_items_count(0) { 187 _weak_handles = new OopStorage("StringTable weak", 188 StringTableWeakAlloc_lock, 189 StringTableWeakActive_lock); 190 size_t start_size_log_2 = ceil_log2(StringTableSize); 191 _current_size = ((size_t)1) << start_size_log_2; 192 log_trace(stringtable)("Start size: " SIZE_FORMAT " (" SIZE_FORMAT ")", 193 _current_size, start_size_log_2); 194 _local_table = new StringTableHash(start_size_log_2, END_SIZE, REHASH_LEN); 195 } 196 197 size_t StringTable::item_added() { 198 return Atomic::add((size_t)1, &(the_table()->_items_count)); 199 } 200 201 size_t StringTable::add_items_count_to_clean(size_t ndead) { 202 size_t total = Atomic::add((size_t)ndead, &(the_table()->_uncleaned_items_count)); 203 log_trace(stringtable)( 204 "Uncleaned items:" SIZE_FORMAT " added: " SIZE_FORMAT " total:" SIZE_FORMAT, 205 the_table()->_uncleaned_items_count, ndead, total); 206 return total; 207 } 208 209 void StringTable::item_removed() { 210 Atomic::add((size_t)-1, &(the_table()->_items_count)); 211 } 212 213 double StringTable::get_load_factor() { 214 return (double)_items_count/_current_size; 215 } 216 217 double StringTable::get_dead_factor() { 218 return (double)_uncleaned_items_count/_current_size; 219 } 220 221 size_t StringTable::table_size() { 222 return ((size_t)1) << _local_table->get_size_log2(Thread::current()); 223 } 224 225 void StringTable::trigger_concurrent_work() { 226 MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag); 227 the_table()->_has_work = true; 228 Service_lock->notify_all(); 229 } 230 231 // Probing 232 oop StringTable::lookup(Symbol* symbol) { 233 ResourceMark rm; 234 int length; 235 jchar* chars = symbol->as_unicode(length); 236 return lookup(chars, length); 237 } 238 239 oop StringTable::lookup(jchar* name, int len) { 240 unsigned int hash = java_lang_String::hash_code(name, len); 241 oop string = StringTable::the_table()->lookup_shared(name, len, hash); 242 if (string != NULL) { 243 return string; 244 } 245 if (StringTable::_alt_hash) { 246 hash = hash_string(name, len, true); 247 } 248 return StringTable::the_table()->do_lookup(name, len, hash); 249 } 250 251 class StringTableGet : public StackObj { 252 Thread* _thread; 253 Handle _return; 254 public: 255 StringTableGet(Thread* thread) : _thread(thread) {} 256 void operator()(WeakHandle<vm_string_table_data>* val) { 257 oop result = val->resolve(); 258 assert(result != NULL, "Result should be reachable"); 259 _return = Handle(_thread, result); 260 } 261 oop get_res_oop() { 262 return _return(); 263 } 264 }; 265 266 oop StringTable::do_lookup(jchar* name, int len, uintx hash) { 267 Thread* thread = Thread::current(); 268 StringTableLookupJchar lookup(thread, hash, name, len); 269 StringTableGet stg(thread); 270 bool rehash_warning; 271 _local_table->get(thread, lookup, stg, &rehash_warning); 272 if (rehash_warning) { 273 _needs_rehashing = true; 274 } 275 return stg.get_res_oop(); 276 } 277 278 // Interning 279 oop StringTable::intern(Symbol* symbol, TRAPS) { 280 if (symbol == NULL) return NULL; 281 ResourceMark rm(THREAD); 282 int length; 283 jchar* chars = symbol->as_unicode(length); 284 Handle string; 285 oop result = intern(string, chars, length, CHECK_NULL); 286 return result; 287 } 288 289 oop StringTable::intern(oop string, TRAPS) { 290 if (string == NULL) return NULL; 291 ResourceMark rm(THREAD); 292 int length; 293 Handle h_string (THREAD, string); 294 jchar* chars = java_lang_String::as_unicode_string(string, length, 295 CHECK_NULL); 296 oop result = intern(h_string, chars, length, CHECK_NULL); 297 return result; 298 } 299 300 oop StringTable::intern(const char* utf8_string, TRAPS) { 301 if (utf8_string == NULL) return NULL; 302 ResourceMark rm(THREAD); 303 int length = UTF8::unicode_length(utf8_string); 304 jchar* chars = NEW_RESOURCE_ARRAY(jchar, length); 305 UTF8::convert_to_unicode(utf8_string, chars, length); 306 Handle string; 307 oop result = intern(string, chars, length, CHECK_NULL); 308 return result; 309 } 310 311 oop StringTable::intern(Handle string_or_null_h, jchar* name, int len, TRAPS) { 312 // shared table always uses java_lang_String::hash_code 313 unsigned int hash = java_lang_String::hash_code(name, len); 314 oop found_string = StringTable::the_table()->lookup_shared(name, len, hash); 315 if (found_string != NULL) { 316 return found_string; 317 } 318 if (StringTable::_alt_hash) { 319 hash = hash_string(name, len, true); 320 } 321 return StringTable::the_table()->do_intern(string_or_null_h, name, len, 322 hash, CHECK_NULL); 323 } 324 325 class StringTableCreateEntry : public StackObj { 326 private: 327 Thread* _thread; 328 Handle _return; 329 Handle _store; 330 public: 331 StringTableCreateEntry(Thread* thread, Handle store) 332 : _thread(thread), _store(store) {} 333 334 WeakHandle<vm_string_table_data> operator()() { // No dups found 335 WeakHandle<vm_string_table_data> wh = 336 WeakHandle<vm_string_table_data>::create(_store); 337 return wh; 338 } 339 void operator()(bool inserted, WeakHandle<vm_string_table_data>* val) { 340 oop result = val->resolve(); 341 assert(result != NULL, "Result should be reachable"); 342 _return = Handle(_thread, result); 343 } 344 oop get_return() const { 345 return _return(); 346 } 347 }; 348 349 oop StringTable::do_intern(Handle string_or_null_h, jchar* name, 350 int len, uintx hash, TRAPS) { 351 HandleMark hm(THREAD); // cleanup strings created 352 Handle string_h; 353 354 if (!string_or_null_h.is_null()) { 355 string_h = string_or_null_h; 356 } else { 357 string_h = java_lang_String::create_from_unicode(name, len, CHECK_NULL); 358 } 359 360 // Deduplicate the string before it is interned. Note that we should never 361 // deduplicate a string after it has been interned. Doing so will counteract 362 // compiler optimizations done on e.g. interned string literals. 363 Universe::heap()->deduplicate_string(string_h()); 364 365 assert(java_lang_String::equals(string_h(), name, len), 366 "string must be properly initialized"); 367 assert(len == java_lang_String::length(string_h()), "Must be same length"); 368 StringTableLookupOop lookup(THREAD, hash, string_h); 369 StringTableCreateEntry stc(THREAD, string_h); 370 371 bool rehash_warning; 372 _local_table->get_insert_lazy(THREAD, lookup, stc, stc, &rehash_warning); 373 if (rehash_warning) { 374 _needs_rehashing = true; 375 } 376 return stc.get_return(); 377 } 378 379 // GC support 380 class StringTableIsAliveCounter : public BoolObjectClosure { 381 BoolObjectClosure* _real_boc; 382 public: 383 size_t _count; 384 size_t _count_total; 385 StringTableIsAliveCounter(BoolObjectClosure* boc) : _real_boc(boc), _count(0), 386 _count_total(0) {} 387 bool do_object_b(oop obj) { 388 bool ret = _real_boc->do_object_b(obj); 389 if (!ret) { 390 ++_count; 391 } 392 ++_count_total; 393 return ret; 394 } 395 }; 396 397 void StringTable::unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* f, 398 size_t* processed, size_t* removed) { 399 DoNothingClosure dnc; 400 assert(is_alive != NULL, "No closure"); 401 StringTableIsAliveCounter stiac(is_alive); 402 OopClosure* tmp = f != NULL ? f : &dnc; 403 404 StringTable::the_table()->_weak_handles->weak_oops_do(&stiac, tmp); 405 406 // This is the serial case without ParState. 407 // Just set the correct number and check for a cleaning phase. 408 the_table()->_uncleaned_items_count = stiac._count; 409 StringTable::the_table()->check_concurrent_work(); 410 411 if (processed != NULL) { 412 *processed = stiac._count_total; 413 } 414 if (removed != NULL) { 415 *removed = stiac._count; 416 } 417 } 418 419 void StringTable::oops_do(OopClosure* f) { 420 assert(f != NULL, "No closure"); 421 StringTable::the_table()->_weak_handles->oops_do(f); 422 } 423 424 void StringTable::possibly_parallel_unlink( 425 OopStorage::ParState<false, false>* _par_state_string, BoolObjectClosure* cl, 426 size_t* processed, size_t* removed) 427 { 428 DoNothingClosure dnc; 429 assert(cl != NULL, "No closure"); 430 StringTableIsAliveCounter stiac(cl); 431 432 _par_state_string->weak_oops_do(&stiac, &dnc); 433 434 // Accumulate the dead strings. 435 the_table()->add_items_count_to_clean(stiac._count); 436 437 *processed = stiac._count_total; 438 *removed = stiac._count; 439 } 440 441 void StringTable::possibly_parallel_oops_do( 442 OopStorage::ParState<false /* concurrent */, false /* const */>* 443 _par_state_string, OopClosure* f) 444 { 445 assert(f != NULL, "No closure"); 446 _par_state_string->oops_do(f); 447 } 448 449 // Concurrent work 450 void StringTable::grow(JavaThread* jt) { 451 StringTableHash::GrowTask gt(_local_table); 452 if (!gt.prepare(jt)) { 453 return; 454 } 455 log_trace(stringtable)("Started to grow"); 456 { 457 TraceTime timer("Grow", TRACETIME_LOG(Debug, stringtable, perf)); 458 while (gt.do_task(jt)) { 459 gt.pause(jt); 460 { 461 ThreadBlockInVM tbivm(jt); 462 } 463 gt.cont(jt); 464 } 465 } 466 gt.done(jt); 467 _current_size = table_size(); 468 log_debug(stringtable)("Grown to size:" SIZE_FORMAT, _current_size); 469 } 470 471 struct StringTableDoDelete : StackObj { 472 void operator()(WeakHandle<vm_string_table_data>* val) { 473 /* do nothing */ 474 } 475 }; 476 477 struct StringTableDeleteCheck : StackObj { 478 long _count; 479 long _item; 480 StringTableDeleteCheck() : _count(0), _item(0) {} 481 bool operator()(WeakHandle<vm_string_table_data>* val) { 482 ++_item; 483 oop tmp = val->peek(); 484 if (tmp == NULL) { 485 ++_count; 486 return true; 487 } else { 488 return false; 489 } 490 } 491 }; 492 493 void StringTable::clean_dead_entries(JavaThread* jt) { 494 StringTableHash::BulkDeleteTask bdt(_local_table); 495 if (!bdt.prepare(jt)) { 496 return; 497 } 498 499 StringTableDeleteCheck stdc; 500 StringTableDoDelete stdd; 501 { 502 TraceTime timer("Clean", TRACETIME_LOG(Debug, stringtable, perf)); 503 while(bdt.do_task(jt, stdc, stdd)) { 504 bdt.pause(jt); 505 { 506 ThreadBlockInVM tbivm(jt); 507 } 508 bdt.cont(jt); 509 } 510 bdt.done(jt); 511 } 512 log_debug(stringtable)("Cleaned %ld of %ld", stdc._count, stdc._item); 513 } 514 515 void StringTable::check_concurrent_work() { 516 if (_has_work) { 517 return; 518 } 519 520 double load_factor = StringTable::get_load_factor(); 521 double dead_factor = StringTable::get_dead_factor(); 522 // We should clean/resize if we have more dead than alive, 523 // more items than preferred load factor or 524 // more dead items than water mark. 525 if ((dead_factor > load_factor) || 526 (load_factor > PREF_AVG_LIST_LEN) || 527 (dead_factor > CLEAN_DEAD_HIGH_WATER_MARK)) { 528 log_debug(stringtable)("Concurrent work triggered, live factor:%g dead factor:%g", 529 load_factor, dead_factor); 530 trigger_concurrent_work(); 531 } 532 } 533 534 void StringTable::concurrent_work(JavaThread* jt) { 535 _has_work = false; 536 double load_factor = get_load_factor(); 537 log_debug(stringtable, perf)("Concurrent work, live factor: %g", load_factor); 538 // We prefer growing, since that also removes dead items 539 if (load_factor > PREF_AVG_LIST_LEN && !_local_table->is_max_size_reached()) { 540 grow(jt); 541 } else { 542 clean_dead_entries(jt); 543 } 544 } 545 546 void StringTable::do_concurrent_work(JavaThread* jt) { 547 StringTable::the_table()->concurrent_work(jt); 548 } 549 550 // Rehash 551 bool StringTable::do_rehash() { 552 if (!_local_table->is_safepoint_safe()) { 553 return false; 554 } 555 556 // We use max size 557 StringTableHash* new_table = new StringTableHash(END_SIZE, END_SIZE, REHASH_LEN); 558 // Use alt hash from now on 559 _alt_hash = true; 560 if (!_local_table->try_move_nodes_to(Thread::current(), new_table)) { 561 _alt_hash = false; 562 delete new_table; 563 return false; 564 } 565 566 // free old table 567 delete _local_table; 568 _local_table = new_table; 569 570 return true; 571 } 572 573 void StringTable::try_rehash_table() { 574 static bool rehashed = false; 575 log_debug(stringtable)("Table imbalanced, rehashing called."); 576 577 // Grow instead of rehash. 578 if (get_load_factor() > PREF_AVG_LIST_LEN && 579 !_local_table->is_max_size_reached()) { 580 log_debug(stringtable)("Choosing growing over rehashing."); 581 trigger_concurrent_work(); 582 _needs_rehashing = false; 583 return; 584 } 585 // Already rehashed. 586 if (rehashed) { 587 log_warning(stringtable)("Rehashing already done, still long lists."); 588 trigger_concurrent_work(); 589 _needs_rehashing = false; 590 return; 591 } 592 593 murmur_seed = AltHashing::compute_seed(); 594 { 595 if (do_rehash()) { 596 rehashed = true; 597 } else { 598 log_info(stringtable)("Resizes in progress rehashing skipped."); 599 } 600 } 601 _needs_rehashing = false; 602 } 603 604 void StringTable::rehash_table() { 605 StringTable::the_table()->try_rehash_table(); 606 } 607 608 // Statistics 609 static int literal_size(oop obj) { 610 // NOTE: this would over-count if (pre-JDK8) 611 // java_lang_Class::has_offset_field() is true and the String.value array is 612 // shared by several Strings. However, starting from JDK8, the String.value 613 // array is not shared anymore. 614 if (obj == NULL) { 615 return 0; 616 } else if (obj->klass() == SystemDictionary::String_klass()) { 617 return (obj->size() + java_lang_String::value(obj)->size()) * HeapWordSize; 618 } else { 619 return obj->size(); 620 } 621 } 622 623 struct SizeFunc : StackObj { 624 size_t operator()(WeakHandle<vm_string_table_data>* val) { 625 oop s = val->peek(); 626 if (s == NULL) { 627 // Dead 628 return 0; 629 } 630 return literal_size(s); 631 }; 632 }; 633 634 void StringTable::print_table_statistics(outputStream* st, 635 const char* table_name) { 636 SizeFunc sz; 637 _local_table->statistics_to(Thread::current(), sz, st, table_name); 638 } 639 640 // Verification 641 class VerifyStrings : StackObj { 642 public: 643 bool operator()(WeakHandle<vm_string_table_data>* val) { 644 oop s = val->peek(); 645 if (s != NULL) { 646 assert(java_lang_String::length(s) >= 0, "Length on string must work."); 647 } 648 return true; 649 }; 650 }; 651 652 // This verification is part of Universe::verify() and needs to be quick. 653 void StringTable::verify() { 654 Thread* thr = Thread::current(); 655 VerifyStrings vs; 656 if (!the_table()->_local_table->try_scan(thr, vs)) { 657 log_info(stringtable)("verify unavailable at this moment"); 658 } 659 } 660 661 // Verification and comp 662 class VerifyCompStrings : StackObj { 663 GrowableArray<oop>* _oops; 664 public: 665 size_t _errors; 666 VerifyCompStrings(GrowableArray<oop>* oops) : _oops(oops), _errors(0) {} 667 bool operator()(WeakHandle<vm_string_table_data>* val) { 668 oop s = val->resolve(); 669 if (s == NULL) { 670 return true; 671 } 672 int len = _oops->length(); 673 for (int i = 0; i < len; i++) { 674 bool eq = java_lang_String::equals(s, _oops->at(i)); 675 assert(!eq, "Duplicate strings"); 676 if (eq) { 677 _errors++; 678 } 679 } 680 _oops->push(s); 681 return true; 682 }; 683 }; 684 685 size_t StringTable::verify_and_compare_entries() { 686 Thread* thr = Thread::current(); 687 GrowableArray<oop>* oops = 688 new (ResourceObj::C_HEAP, mtInternal) 689 GrowableArray<oop>((int)the_table()->_current_size, true); 690 691 VerifyCompStrings vcs(oops); 692 if (!the_table()->_local_table->try_scan(thr, vcs)) { 693 log_info(stringtable)("verify unavailable at this moment"); 694 } 695 delete oops; 696 return vcs._errors; 697 } 698 699 // Dumping 700 class PrintString : StackObj { 701 Thread* _thr; 702 outputStream* _st; 703 public: 704 PrintString(Thread* thr, outputStream* st) : _thr(thr), _st(st) {} 705 bool operator()(WeakHandle<vm_string_table_data>* val) { 706 oop s = val->peek(); 707 if (s == NULL) { 708 return true; 709 } 710 typeArrayOop value = java_lang_String::value_no_keepalive(s); 711 int length = java_lang_String::length(s); 712 bool is_latin1 = java_lang_String::is_latin1(s); 713 714 if (length <= 0) { 715 _st->print("%d: ", length); 716 } else { 717 ResourceMark rm(_thr); 718 int utf8_length = length; 719 char* utf8_string; 720 721 if (!is_latin1) { 722 jchar* chars = value->char_at_addr(0); 723 utf8_string = UNICODE::as_utf8(chars, utf8_length); 724 } else { 725 jbyte* bytes = value->byte_at_addr(0); 726 utf8_string = UNICODE::as_utf8(bytes, utf8_length); 727 } 728 729 _st->print("%d: ", utf8_length); 730 HashtableTextDump::put_utf8(_st, utf8_string, utf8_length); 731 } 732 _st->cr(); 733 return true; 734 }; 735 }; 736 737 void StringTable::dump(outputStream* st, bool verbose) { 738 if (!verbose) { 739 the_table()->print_table_statistics(st, "StringTable"); 740 } else { 741 Thread* thr = Thread::current(); 742 ResourceMark rm(thr); 743 st->print_cr("VERSION: 1.1"); 744 PrintString ps(thr, st); 745 if (!the_table()->_local_table->try_scan(thr, ps)) { 746 st->print_cr("dump unavailable at this moment"); 747 } 748 } 749 } 750 751 // Utility for dumping strings 752 StringtableDCmd::StringtableDCmd(outputStream* output, bool heap) : 753 DCmdWithParser(output, heap), 754 _verbose("-verbose", "Dump the content of each string in the table", 755 "BOOLEAN", false, "false") { 756 _dcmdparser.add_dcmd_option(&_verbose); 757 } 758 759 void StringtableDCmd::execute(DCmdSource source, TRAPS) { 760 VM_DumpHashtable dumper(output(), VM_DumpHashtable::DumpStrings, 761 _verbose.value()); 762 VMThread::execute(&dumper); 763 } 764 765 int StringtableDCmd::num_arguments() { 766 ResourceMark rm; 767 StringtableDCmd* dcmd = new StringtableDCmd(NULL, false); 768 if (dcmd != NULL) { 769 DCmdMark mark(dcmd); 770 return dcmd->_dcmdparser.num_arguments(); 771 } else { 772 return 0; 773 } 774 } 775 776 // Sharing 777 #if INCLUDE_CDS_JAVA_HEAP 778 oop StringTable::lookup_shared(jchar* name, int len, unsigned int hash) { 779 assert(hash == java_lang_String::hash_code(name, len), 780 "hash must be computed using java_lang_String::hash_code"); 781 return _shared_table.lookup((const char*)name, hash, len); 782 } 783 784 oop StringTable::create_archived_string(oop s, Thread* THREAD) { 785 assert(DumpSharedSpaces, "this function is only used with -Xshare:dump"); 786 787 if (MetaspaceShared::is_archive_object(s)) { 788 return s; 789 } 790 791 oop new_s = NULL; 792 typeArrayOop v = java_lang_String::value_no_keepalive(s); 793 typeArrayOop new_v = 794 (typeArrayOop)MetaspaceShared::archive_heap_object(v, THREAD); 795 if (new_v == NULL) { 796 return NULL; 797 } 798 new_s = MetaspaceShared::archive_heap_object(s, THREAD); 799 if (new_s == NULL) { 800 return NULL; 801 } 802 803 // adjust the pointer to the 'value' field in the new String oop 804 java_lang_String::set_value_raw(new_s, new_v); 805 return new_s; 806 } 807 808 struct CopyToArchive : StackObj { 809 CompactStringTableWriter* _writer; 810 CopyToArchive(CompactStringTableWriter* writer) : _writer(writer) {} 811 bool operator()(WeakHandle<vm_string_table_data>* val) { 812 oop s = val->peek(); 813 if (s == NULL) { 814 return true; 815 } 816 unsigned int hash = java_lang_String::hash_code(s); 817 if (hash == 0) { 818 return true; 819 } 820 821 java_lang_String::set_hash(s, hash); 822 oop new_s = StringTable::create_archived_string(s, Thread::current()); 823 if (new_s == NULL) { 824 return true; 825 } 826 827 val->replace(new_s); 828 // add to the compact table 829 _writer->add(hash, new_s); 830 return true; 831 } 832 }; 833 834 void StringTable::copy_shared_string_table(CompactStringTableWriter* writer) { 835 assert(MetaspaceShared::is_heap_object_archiving_allowed(), "must be"); 836 837 CopyToArchive copy(writer); 838 StringTable::the_table()->_local_table->do_scan(Thread::current(), copy); 839 } 840 841 void StringTable::write_to_archive() { 842 assert(MetaspaceShared::is_heap_object_archiving_allowed(), "must be"); 843 844 _shared_table.reset(); 845 int num_buckets = the_table()->_items_count / SharedSymbolTableBucketSize; 846 // calculation of num_buckets can result in zero buckets, we need at least one 847 CompactStringTableWriter writer(num_buckets > 1 ? num_buckets : 1, 848 &MetaspaceShared::stats()->string); 849 850 // Copy the interned strings into the "string space" within the java heap 851 copy_shared_string_table(&writer); 852 writer.dump(&_shared_table); 853 } 854 855 void StringTable::serialize(SerializeClosure* soc) { 856 _shared_table.set_type(CompactHashtable<oop, char>::_string_table); 857 _shared_table.serialize(soc); 858 859 if (soc->writing()) { 860 // Sanity. Make sure we don't use the shared table at dump time 861 _shared_table.reset(); 862 } else if (!_shared_string_mapped) { 863 _shared_table.reset(); 864 } 865 } 866 867 void StringTable::shared_oops_do(OopClosure* f) { 868 _shared_table.oops_do(f); 869 } 870 #endif //INCLUDE_CDS_JAVA_HEAP