1 /*

     2  * Copyright (c) 1997, 2017, 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.inline.hpp"

    32 #include "gc/shared/gcLocker.inline.hpp"

    33 #include "logging/log.hpp"

    34 #include "memory/allocation.inline.hpp"

    35 #include "memory/filemap.hpp"

    36 #include "memory/metaspaceShared.hpp"

    37 #include "memory/resourceArea.hpp"

    38 #include "oops/oop.inline.hpp"

    39 #include "runtime/atomic.hpp"

    40 #include "runtime/mutexLocker.hpp"

    41 #include "services/diagnosticCommand.hpp"

    42 #include "utilities/hashtable.inline.hpp"

    43 #include "utilities/macros.hpp"

    44 #if INCLUDE_ALL_GCS

    45 #include "gc/g1/g1CollectedHeap.hpp"

    46 #include "gc/g1/g1SATBCardTableModRefBS.hpp"

    47 #include "gc/g1/g1StringDedup.hpp"

    48 #endif

    49 

    50 // the number of buckets a thread claims

    51 const int ClaimChunkSize = 32;

    52 

    53 #ifdef ASSERT

    54 class StableMemoryChecker : public StackObj {

    55   enum { _bufsize = wordSize*4 };

    56 

    57   address _region;

    58   jint    _size;

    59   u1      _save_buf[_bufsize];

    60 

    61   int sample(u1* save_buf) {

    62     if (_size <= _bufsize) {

    63       memcpy(save_buf, _region, _size);

    64       return _size;

    65     } else {

    66       // copy head and tail

    67       memcpy(&save_buf[0],          _region,                      _bufsize/2);

    68       memcpy(&save_buf[_bufsize/2], _region + _size - _bufsize/2, _bufsize/2);

    69       return (_bufsize/2)*2;

    70     }

    71   }

    72 

    73  public:

    74   StableMemoryChecker(const void* region, jint size) {

    75     _region = (address) region;

    76     _size   = size;

    77     sample(_save_buf);

    78   }

    79 

    80   bool verify() {

    81     u1 check_buf[sizeof(_save_buf)];

    82     int check_size = sample(check_buf);

    83     return (0 == memcmp(_save_buf, check_buf, check_size));

    84   }

    85 

    86   void set_region(const void* region) { _region = (address) region; }

    87 };

    88 #endif

    89 

    90 

    91 // --------------------------------------------------------------------------

    92 StringTable* StringTable::_the_table = NULL;

    93 bool StringTable::_shared_string_mapped = false;

    94 bool StringTable::_needs_rehashing = false;

    95 

    96 volatile int StringTable::_parallel_claimed_idx = 0;

    97 

    98 CompactHashtable<oop, char> StringTable::_shared_table;

    99 

   100 // Pick hashing algorithm

   101 unsigned int StringTable::hash_string(const jchar* s, int len) {

   102   return use_alternate_hashcode() ? alt_hash_string(s, len) :

   103                                     java_lang_String::hash_code(s, len);

   104 }

   105 

   106 unsigned int StringTable::alt_hash_string(const jchar* s, int len) {

   107   return AltHashing::murmur3_32(seed(), s, len);

   108 }

   109 

   110 unsigned int StringTable::hash_string(oop string) {

   111   EXCEPTION_MARK;

   112   if (string == NULL) {

   113     return hash_string((jchar*)NULL, 0);

   114   }

   115   ResourceMark rm(THREAD);

   116   // All String oops are hashed as unicode

   117   int length;

   118   jchar* chars = java_lang_String::as_unicode_string(string, length, THREAD);

   119   if (chars != NULL) {

   120     return hash_string(chars, length);

   121   } else {

   122     vm_exit_out_of_memory(length, OOM_MALLOC_ERROR, "unable to create Unicode string for verification");

   123     return 0;

   124   }

   125 }

   126 

   127 oop StringTable::lookup_shared(jchar* name, int len, unsigned int hash) {

   128   assert(hash == java_lang_String::hash_code(name, len),

   129          "hash must be computed using java_lang_String::hash_code");

   130   return _shared_table.lookup((const char*)name, hash, len);

   131 }

   132 

   133 oop StringTable::lookup_in_main_table(int index, jchar* name,

   134                                 int len, unsigned int hash) {

   135   int count = 0;

   136   for (HashtableEntry<oop, mtSymbol>* l = bucket(index); l != NULL; l = l->next()) {

   137     count++;

   138     if (l->hash() == hash) {

   139       if (java_lang_String::equals(l->literal(), name, len)) {

   140         return l->literal();

   141       }

   142     }

   143   }

   144   // If the bucket size is too deep check if this hash code is insufficient.

   145   if (count >= rehash_count && !needs_rehashing()) {

   146     _needs_rehashing = check_rehash_table(count);

   147   }

   148   return NULL;

   149 }

   150 

   151 

   152 oop StringTable::basic_add(int index_arg, Handle string, jchar* name,

   153                            int len, unsigned int hashValue_arg, TRAPS) {

   154 

   155   assert(java_lang_String::equals(string(), name, len),

   156          "string must be properly initialized");

   157   // Cannot hit a safepoint in this function because the "this" pointer can move.

   158   NoSafepointVerifier nsv;

   159 

   160   // Check if the symbol table has been rehashed, if so, need to recalculate

   161   // the hash value and index before second lookup.

   162   unsigned int hashValue;

   163   int index;

   164   if (use_alternate_hashcode()) {

   165     hashValue = alt_hash_string(name, len);

   166     index = hash_to_index(hashValue);

   167   } else {

   168     hashValue = hashValue_arg;

   169     index = index_arg;

   170   }

   171 

   172   // Since look-up was done lock-free, we need to check if another

   173   // thread beat us in the race to insert the symbol.

   174 

   175   // No need to lookup the shared table from here since the caller (intern()) already did

   176   oop test = lookup_in_main_table(index, name, len, hashValue); // calls lookup(u1*, int)

   177   if (test != NULL) {

   178     // Entry already added

   179     return test;

   180   }

   181 

   182   HashtableEntry<oop, mtSymbol>* entry = new_entry(hashValue, string());

   183   add_entry(index, entry);

   184   return string();

   185 }

   186 

   187 

   188 oop StringTable::lookup(Symbol* symbol) {

   189   ResourceMark rm;

   190   int length;

   191   jchar* chars = symbol->as_unicode(length);

   192   return lookup(chars, length);

   193 }

   194 

   195 // Tell the GC that this string was looked up in the StringTable.

   196 static void ensure_string_alive(oop string) {

   197   // A lookup in the StringTable could return an object that was previously

   198   // considered dead. The SATB part of G1 needs to get notified about this

   199   // potential resurrection, otherwise the marking might not find the object.

   200 #if INCLUDE_ALL_GCS

   201   if (UseG1GC && string != NULL) {

   202     G1SATBCardTableModRefBS::enqueue(string);

   203   }

   204 #endif

   205 }

   206 

   207 oop StringTable::lookup(jchar* name, int len) {

   208   // shared table always uses java_lang_String::hash_code

   209   unsigned int hash = java_lang_String::hash_code(name, len);

   210   oop string = lookup_shared(name, len, hash);

   211   if (string != NULL) {

   212     return string;

   213   }

   214   if (use_alternate_hashcode()) {

   215     hash = alt_hash_string(name, len);

   216   }

   217   int index = the_table()->hash_to_index(hash);

   218   string = the_table()->lookup_in_main_table(index, name, len, hash);

   219 

   220   ensure_string_alive(string);

   221 

   222   return string;

   223 }

   224 

   225 oop StringTable::intern(Handle string_or_null, jchar* name,

   226                         int len, TRAPS) {

   227   // shared table always uses java_lang_String::hash_code

   228   unsigned int hashValue = java_lang_String::hash_code(name, len);

   229   oop found_string = lookup_shared(name, len, hashValue);

   230   if (found_string != NULL) {

   231     return found_string;

   232   }

   233   if (use_alternate_hashcode()) {

   234     hashValue = alt_hash_string(name, len);

   235   }

   236   int index = the_table()->hash_to_index(hashValue);

   237   found_string = the_table()->lookup_in_main_table(index, name, len, hashValue);

   238 

   239   // Found

   240   if (found_string != NULL) {

   241     if (found_string != string_or_null()) {

   242       ensure_string_alive(found_string);

   243     }

   244     return found_string;

   245   }

   246 

   247   debug_only(StableMemoryChecker smc(name, len * sizeof(name[0])));

   248   assert(!Universe::heap()->is_in_reserved(name),

   249          "proposed name of symbol must be stable");

   250 

   251   HandleMark hm(THREAD);  // cleanup strings created

   252   Handle string;

   253   // try to reuse the string if possible

   254   if (!string_or_null.is_null()) {

   255     string = string_or_null;

   256   } else {

   257     string = java_lang_String::create_from_unicode(name, len, CHECK_NULL);

   258   }

   259 

   260 #if INCLUDE_ALL_GCS

   261   if (G1StringDedup::is_enabled()) {

   262     // Deduplicate the string before it is interned. Note that we should never

   263     // deduplicate a string after it has been interned. Doing so will counteract

   264     // compiler optimizations done on e.g. interned string literals.

   265     G1StringDedup::deduplicate(string());

   266   }

   267 #endif

   268 

   269   // Grab the StringTable_lock before getting the_table() because it could

   270   // change at safepoint.

   271   oop added_or_found;

   272   {

   273     MutexLocker ml(StringTable_lock, THREAD);

   274     // Otherwise, add to symbol to table

   275     added_or_found = the_table()->basic_add(index, string, name, len,

   276                                   hashValue, CHECK_NULL);

   277   }

   278 

   279   if (added_or_found != string()) {

   280     ensure_string_alive(added_or_found);

   281   }

   282 

   283   return added_or_found;

   284 }

   285 

   286 oop StringTable::intern(Symbol* symbol, TRAPS) {

   287   if (symbol == NULL) return NULL;

   288   ResourceMark rm(THREAD);

   289   int length;

   290   jchar* chars = symbol->as_unicode(length);

   291   Handle string;

   292   oop result = intern(string, chars, length, CHECK_NULL);

   293   return result;

   294 }

   295 

   296 

   297 oop StringTable::intern(oop string, TRAPS)

   298 {

   299   if (string == NULL) return NULL;

   300   ResourceMark rm(THREAD);

   301   int length;

   302   Handle h_string (THREAD, string);

   303   jchar* chars = java_lang_String::as_unicode_string(string, length, CHECK_NULL);

   304   oop result = intern(h_string, chars, length, CHECK_NULL);

   305   return result;

   306 }

   307 

   308 

   309 oop StringTable::intern(const char* utf8_string, TRAPS) {

   310   if (utf8_string == NULL) return NULL;

   311   ResourceMark rm(THREAD);

   312   int length = UTF8::unicode_length(utf8_string);

   313   jchar* chars = NEW_RESOURCE_ARRAY(jchar, length);

   314   UTF8::convert_to_unicode(utf8_string, chars, length);

   315   Handle string;

   316   oop result = intern(string, chars, length, CHECK_NULL);

   317   return result;

   318 }

   319 

   320 void StringTable::unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* f, int* processed, int* removed) {

   321   BucketUnlinkContext context;

   322   buckets_unlink_or_oops_do(is_alive, f, 0, the_table()->table_size(), &context);

   323   _the_table->bulk_free_entries(&context);

   324   *processed = context._num_processed;

   325   *removed = context._num_removed;

   326 }

   327 

   328 void StringTable::possibly_parallel_unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* f, int* processed, int* removed) {

   329   // Readers of the table are unlocked, so we should only be removing

   330   // entries at a safepoint.

   331   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");

   332   const int limit = the_table()->table_size();

   333 

   334   BucketUnlinkContext context;

   335   for (;;) {

   336     // Grab next set of buckets to scan

   337     int start_idx = Atomic::add(ClaimChunkSize, &_parallel_claimed_idx) - ClaimChunkSize;

   338     if (start_idx >= limit) {

   339       // End of table

   340       break;

   341     }

   342 

   343     int end_idx = MIN2(limit, start_idx + ClaimChunkSize);

   344     buckets_unlink_or_oops_do(is_alive, f, start_idx, end_idx, &context);

   345   }

   346   _the_table->bulk_free_entries(&context);

   347   *processed = context._num_processed;

   348   *removed = context._num_removed;

   349 }

   350 

   351 void StringTable::buckets_oops_do(OopClosure* f, int start_idx, int end_idx) {

   352   const int limit = the_table()->table_size();

   353 

   354   assert(0 <= start_idx && start_idx <= limit,

   355          "start_idx (%d) is out of bounds", start_idx);

   356   assert(0 <= end_idx && end_idx <= limit,

   357          "end_idx (%d) is out of bounds", end_idx);

   358   assert(start_idx <= end_idx,

   359          "Index ordering: start_idx=%d, end_idx=%d",

   360          start_idx, end_idx);

   361 

   362   for (int i = start_idx; i < end_idx; i += 1) {

   363     HashtableEntry<oop, mtSymbol>* entry = the_table()->bucket(i);

   364     while (entry != NULL) {

   365       assert(!entry->is_shared(), "CDS not used for the StringTable");

   366 

   367       f->do_oop((oop*)entry->literal_addr());

   368 

   369       entry = entry->next();

   370     }

   371   }

   372 }

   373 

   374 void StringTable::buckets_unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* f, int start_idx, int end_idx, BucketUnlinkContext* context) {

   375   const int limit = the_table()->table_size();

   376 

   377   assert(0 <= start_idx && start_idx <= limit,

   378          "start_idx (%d) is out of bounds", start_idx);

   379   assert(0 <= end_idx && end_idx <= limit,

   380          "end_idx (%d) is out of bounds", end_idx);

   381   assert(start_idx <= end_idx,

   382          "Index ordering: start_idx=%d, end_idx=%d",

   383          start_idx, end_idx);

   384 

   385   for (int i = start_idx; i < end_idx; ++i) {

   386     HashtableEntry<oop, mtSymbol>** p = the_table()->bucket_addr(i);

   387     HashtableEntry<oop, mtSymbol>* entry = the_table()->bucket(i);

   388     while (entry != NULL) {

   389       assert(!entry->is_shared(), "CDS not used for the StringTable");

   390 

   391       if (is_alive->do_object_b(entry->literal())) {

   392         if (f != NULL) {

   393           f->do_oop((oop*)entry->literal_addr());

   394         }

   395         p = entry->next_addr();

   396       } else {

   397         *p = entry->next();

   398         context->free_entry(entry);

   399       }

   400       context->_num_processed++;

   401       entry = *p;

   402     }

   403   }

   404 }

   405 

   406 void StringTable::oops_do(OopClosure* f) {

   407   buckets_oops_do(f, 0, the_table()->table_size());

   408 }

   409 

   410 void StringTable::possibly_parallel_oops_do(OopClosure* f) {

   411   const int limit = the_table()->table_size();

   412 

   413   for (;;) {

   414     // Grab next set of buckets to scan

   415     int start_idx = Atomic::add(ClaimChunkSize, &_parallel_claimed_idx) - ClaimChunkSize;

   416     if (start_idx >= limit) {

   417       // End of table

   418       break;

   419     }

   420 

   421     int end_idx = MIN2(limit, start_idx + ClaimChunkSize);

   422     buckets_oops_do(f, start_idx, end_idx);

   423   }

   424 }

   425 

   426 // This verification is part of Universe::verify() and needs to be quick.

   427 // See StringTable::verify_and_compare() below for exhaustive verification.

   428 void StringTable::verify() {

   429   for (int i = 0; i < the_table()->table_size(); ++i) {

   430     HashtableEntry<oop, mtSymbol>* p = the_table()->bucket(i);

   431     for ( ; p != NULL; p = p->next()) {

   432       oop s = p->literal();

   433       guarantee(s != NULL, "interned string is NULL");

   434       unsigned int h = hash_string(s);

   435       guarantee(p->hash() == h, "broken hash in string table entry");

   436       guarantee(the_table()->hash_to_index(h) == i,

   437                 "wrong index in string table");

   438     }

   439   }

   440 }

   441 

   442 void StringTable::dump(outputStream* st, bool verbose) {

   443   if (!verbose) {

   444     the_table()->print_table_statistics(st, "StringTable");

   445   } else {

   446     Thread* THREAD = Thread::current();

   447     st->print_cr("VERSION: 1.1");

   448     for (int i = 0; i < the_table()->table_size(); ++i) {

   449       HashtableEntry<oop, mtSymbol>* p = the_table()->bucket(i);

   450       for ( ; p != NULL; p = p->next()) {

   451         oop s = p->literal();

   452         typeArrayOop value  = java_lang_String::value(s);

   453         int          length = java_lang_String::length(s);

   454         bool      is_latin1 = java_lang_String::is_latin1(s);

   455 

   456         if (length <= 0) {

   457           st->print("%d: ", length);

   458         } else {

   459           ResourceMark rm(THREAD);

   460           int utf8_length = length;

   461           char* utf8_string;

   462 

   463           if (!is_latin1) {

   464             jchar* chars = value->char_at_addr(0);

   465             utf8_string = UNICODE::as_utf8(chars, utf8_length);

   466           } else {

   467             jbyte* bytes = value->byte_at_addr(0);

   468             utf8_string = UNICODE::as_utf8(bytes, utf8_length);

   469           }

   470 

   471           st->print("%d: ", utf8_length);

   472           HashtableTextDump::put_utf8(st, utf8_string, utf8_length);

   473         }

   474         st->cr();

   475       }

   476     }

   477   }

   478 }

   479 

   480 StringTable::VerifyRetTypes StringTable::compare_entries(

   481                                       int bkt1, int e_cnt1,

   482                                       HashtableEntry<oop, mtSymbol>* e_ptr1,

   483                                       int bkt2, int e_cnt2,

   484                                       HashtableEntry<oop, mtSymbol>* e_ptr2) {

   485   // These entries are sanity checked by verify_and_compare_entries()

   486   // before this function is called.

   487   oop str1 = e_ptr1->literal();

   488   oop str2 = e_ptr2->literal();

   489 

   490   if (str1 == str2) {

   491     tty->print_cr("ERROR: identical oop values (0x" PTR_FORMAT ") "

   492                   "in entry @ bucket[%d][%d] and entry @ bucket[%d][%d]",

   493                   p2i(str1), bkt1, e_cnt1, bkt2, e_cnt2);

   494     return _verify_fail_continue;

   495   }

   496 

   497   if (java_lang_String::equals(str1, str2)) {

   498     tty->print_cr("ERROR: identical String values in entry @ "

   499                   "bucket[%d][%d] and entry @ bucket[%d][%d]",

   500                   bkt1, e_cnt1, bkt2, e_cnt2);

   501     return _verify_fail_continue;

   502   }

   503 

   504   return _verify_pass;

   505 }

   506 

   507 StringTable::VerifyRetTypes StringTable::verify_entry(int bkt, int e_cnt,

   508                                       HashtableEntry<oop, mtSymbol>* e_ptr,

   509                                       StringTable::VerifyMesgModes mesg_mode) {

   510 

   511   VerifyRetTypes ret = _verify_pass;  // be optimistic

   512 

   513   oop str = e_ptr->literal();

   514   if (str == NULL) {

   515     if (mesg_mode == _verify_with_mesgs) {

   516       tty->print_cr("ERROR: NULL oop value in entry @ bucket[%d][%d]", bkt,

   517                     e_cnt);

   518     }

   519     // NULL oop means no more verifications are possible

   520     return _verify_fail_done;

   521   }

   522 

   523   if (str->klass() != SystemDictionary::String_klass()) {

   524     if (mesg_mode == _verify_with_mesgs) {

   525       tty->print_cr("ERROR: oop is not a String in entry @ bucket[%d][%d]",

   526                     bkt, e_cnt);

   527     }

   528     // not a String means no more verifications are possible

   529     return _verify_fail_done;

   530   }

   531 

   532   unsigned int h = hash_string(str);

   533   if (e_ptr->hash() != h) {

   534     if (mesg_mode == _verify_with_mesgs) {

   535       tty->print_cr("ERROR: broken hash value in entry @ bucket[%d][%d], "

   536                     "bkt_hash=%d, str_hash=%d", bkt, e_cnt, e_ptr->hash(), h);

   537     }

   538     ret = _verify_fail_continue;

   539   }

   540 

   541   if (the_table()->hash_to_index(h) != bkt) {

   542     if (mesg_mode == _verify_with_mesgs) {

   543       tty->print_cr("ERROR: wrong index value for entry @ bucket[%d][%d], "

   544                     "str_hash=%d, hash_to_index=%d", bkt, e_cnt, h,

   545                     the_table()->hash_to_index(h));

   546     }

   547     ret = _verify_fail_continue;

   548   }

   549 

   550   return ret;

   551 }

   552 

   553 // See StringTable::verify() above for the quick verification that is

   554 // part of Universe::verify(). This verification is exhaustive and

   555 // reports on every issue that is found. StringTable::verify() only

   556 // reports on the first issue that is found.

   557 //

   558 // StringTable::verify_entry() checks:

   559 // - oop value != NULL (same as verify())

   560 // - oop value is a String

   561 // - hash(String) == hash in entry (same as verify())

   562 // - index for hash == index of entry (same as verify())

   563 //

   564 // StringTable::compare_entries() checks:

   565 // - oops are unique across all entries

   566 // - String values are unique across all entries

   567 //

   568 int StringTable::verify_and_compare_entries() {

   569   assert(StringTable_lock->is_locked(), "sanity check");

   570 

   571   int  fail_cnt = 0;

   572 

   573   // first, verify all the entries individually:

   574   for (int bkt = 0; bkt < the_table()->table_size(); bkt++) {

   575     HashtableEntry<oop, mtSymbol>* e_ptr = the_table()->bucket(bkt);

   576     for (int e_cnt = 0; e_ptr != NULL; e_ptr = e_ptr->next(), e_cnt++) {

   577       VerifyRetTypes ret = verify_entry(bkt, e_cnt, e_ptr, _verify_with_mesgs);

   578       if (ret != _verify_pass) {

   579         fail_cnt++;

   580       }

   581     }

   582   }

   583 

   584   // Optimization: if the above check did not find any failures, then

   585   // the comparison loop below does not need to call verify_entry()

   586   // before calling compare_entries(). If there were failures, then we

   587   // have to call verify_entry() to see if the entry can be passed to

   588   // compare_entries() safely. When we call verify_entry() in the loop

   589   // below, we do so quietly to void duplicate messages and we don't

   590   // increment fail_cnt because the failures have already been counted.

   591   bool need_entry_verify = (fail_cnt != 0);

   592 

   593   // second, verify all entries relative to each other:

   594   for (int bkt1 = 0; bkt1 < the_table()->table_size(); bkt1++) {

   595     HashtableEntry<oop, mtSymbol>* e_ptr1 = the_table()->bucket(bkt1);

   596     for (int e_cnt1 = 0; e_ptr1 != NULL; e_ptr1 = e_ptr1->next(), e_cnt1++) {

   597       if (need_entry_verify) {

   598         VerifyRetTypes ret = verify_entry(bkt1, e_cnt1, e_ptr1,

   599                                           _verify_quietly);

   600         if (ret == _verify_fail_done) {

   601           // cannot use the current entry to compare against other entries

   602           continue;

   603         }

   604       }

   605 

   606       for (int bkt2 = bkt1; bkt2 < the_table()->table_size(); bkt2++) {

   607         HashtableEntry<oop, mtSymbol>* e_ptr2 = the_table()->bucket(bkt2);

   608         int e_cnt2;

   609         for (e_cnt2 = 0; e_ptr2 != NULL; e_ptr2 = e_ptr2->next(), e_cnt2++) {

   610           if (bkt1 == bkt2 && e_cnt2 <= e_cnt1) {

   611             // skip the entries up to and including the one that

   612             // we're comparing against

   613             continue;

   614           }

   615 

   616           if (need_entry_verify) {

   617             VerifyRetTypes ret = verify_entry(bkt2, e_cnt2, e_ptr2,

   618                                               _verify_quietly);

   619             if (ret == _verify_fail_done) {

   620               // cannot compare against this entry

   621               continue;

   622             }

   623           }

   624 

   625           // compare two entries, report and count any failures:

   626           if (compare_entries(bkt1, e_cnt1, e_ptr1, bkt2, e_cnt2, e_ptr2)

   627               != _verify_pass) {

   628             fail_cnt++;

   629           }

   630         }

   631       }

   632     }

   633   }

   634   return fail_cnt;

   635 }

   636 

   637 // Create a new table and using alternate hash code, populate the new table

   638 // with the existing strings.   Set flag to use the alternate hash code afterwards.

   639 void StringTable::rehash_table() {

   640   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");

   641   // This should never happen with -Xshare:dump but it might in testing mode.

   642   if (DumpSharedSpaces) return;

   643   StringTable* new_table = new StringTable();

   644 

   645   // Rehash the table

   646   the_table()->move_to(new_table);

   647 

   648   // Delete the table and buckets (entries are reused in new table).

   649   delete _the_table;

   650   // Don't check if we need rehashing until the table gets unbalanced again.

   651   // Then rehash with a new global seed.

   652   _needs_rehashing = false;

   653   _the_table = new_table;

   654 }

   655 

   656 // Utility for dumping strings

   657 StringtableDCmd::StringtableDCmd(outputStream* output, bool heap) :

   658                                  DCmdWithParser(output, heap),

   659   _verbose("-verbose", "Dump the content of each string in the table",

   660            "BOOLEAN", false, "false") {

   661   _dcmdparser.add_dcmd_option(&_verbose);

   662 }

   663 

   664 void StringtableDCmd::execute(DCmdSource source, TRAPS) {

   665   VM_DumpHashtable dumper(output(), VM_DumpHashtable::DumpStrings,

   666                          _verbose.value());

   667   VMThread::execute(&dumper);

   668 }

   669 

   670 int StringtableDCmd::num_arguments() {

   671   ResourceMark rm;

   672   StringtableDCmd* dcmd = new StringtableDCmd(NULL, false);

   673   if (dcmd != NULL) {

   674     DCmdMark mark(dcmd);

   675     return dcmd->_dcmdparser.num_arguments();

   676   } else {

   677     return 0;

   678   }

   679 }

   680 

   681 #if INCLUDE_CDS_JAVA_HEAP

   682 // Sharing

   683 oop StringTable::create_archived_string(oop s, Thread* THREAD) {

   684   assert(DumpSharedSpaces, "this function is only used with -Xshare:dump");

   685 

   686   oop new_s = NULL;

   687   typeArrayOop v = java_lang_String::value(s);

   688   typeArrayOop new_v = (typeArrayOop)MetaspaceShared::archive_heap_object(v, THREAD);

   689   if (new_v == NULL) {

   690     return NULL;

   691   }

   692   new_s = MetaspaceShared::archive_heap_object(s, THREAD);

   693   if (new_s == NULL) {

   694     return NULL;

   695   }

   696 

   697   // adjust the pointer to the 'value' field in the new String oop

   698   java_lang_String::set_value_raw(new_s, new_v);

   699   return new_s;

   700 }

   701 

   702 bool StringTable::copy_shared_string(GrowableArray<MemRegion> *string_space,

   703                                      CompactStringTableWriter* writer) {

   704   assert(MetaspaceShared::is_heap_object_archiving_allowed(), "must be");

   705 

   706   Thread* THREAD = Thread::current();

   707   G1CollectedHeap::heap()->begin_archive_alloc_range();

   708   for (int i = 0; i < the_table()->table_size(); ++i) {

   709     HashtableEntry<oop, mtSymbol>* bucket = the_table()->bucket(i);

   710     for ( ; bucket != NULL; bucket = bucket->next()) {

   711       oop s = bucket->literal();

   712       unsigned int hash = java_lang_String::hash_code(s);

   713       if (hash == 0) {

   714         continue;

   715       }

   716 

   717       java_lang_String::set_hash(s, hash);

   718       oop new_s = create_archived_string(s, THREAD);

   719       if (new_s == NULL) {

   720         continue;

   721       }

   722 

   723       // set the archived string in bucket

   724       bucket->set_literal(new_s);

   725 

   726       // add to the compact table

   727       writer->add(hash, new_s);

   728     }

   729   }

   730 

   731   G1CollectedHeap::heap()->end_archive_alloc_range(string_space, os::vm_allocation_granularity());

   732   return true;

   733 }

   734 

   735 void StringTable::write_to_archive(GrowableArray<MemRegion> *string_space) {

   736   assert(MetaspaceShared::is_heap_object_archiving_allowed(), "must be");

   737 

   738   _shared_table.reset();

   739   int num_buckets = the_table()->number_of_entries() /

   740                          SharedSymbolTableBucketSize;

   741   // calculation of num_buckets can result in zero buckets, we need at least one

   742   CompactStringTableWriter writer(num_buckets > 1 ? num_buckets : 1,

   743                                   &MetaspaceShared::stats()->string);

   744 

   745   // Copy the interned strings into the "string space" within the java heap

   746   if (copy_shared_string(string_space, &writer)) {

   747     writer.dump(&_shared_table);

   748   }

   749 }

   750 

   751 void StringTable::serialize(SerializeClosure* soc) {

   752   _shared_table.set_type(CompactHashtable<oop, char>::_string_table);

   753   _shared_table.serialize(soc);

   754 

   755   if (soc->writing()) {

   756     _shared_table.reset(); // Sanity. Make sure we don't use the shared table at dump time

   757   } else if (!_shared_string_mapped) {

   758     _shared_table.reset();

   759   }

   760 }

   761 

   762 void StringTable::shared_oops_do(OopClosure* f) {

   763   _shared_table.oops_do(f);

   764 }

   765 #endif //INCLUDE_CDS_JAVA_HEAP

   766