77 u1 check_buf[sizeof(_save_buf)];
78 int check_size = sample(check_buf);
79 return (0 == memcmp(_save_buf, check_buf, check_size));
80 }
81
82 void set_region(const void* region) { _region = (address) region; }
83 };
84 #endif
85
86
87 // --------------------------------------------------------------------------
88 StringTable* StringTable::_the_table = NULL;
89 bool StringTable::_ignore_shared_strings = false;
90 bool StringTable::_needs_rehashing = false;
91
92 volatile int StringTable::_parallel_claimed_idx = 0;
93
94 CompactHashtable<oop, char> StringTable::_shared_table;
95
96 // Pick hashing algorithm
97 unsigned int StringTable::hash_string(const jchar* s, int len) {
98 return use_alternate_hashcode() ? AltHashing::murmur3_32(seed(), s, len) :
99 java_lang_String::hash_code(s, len);
100 }
101
102 oop StringTable::lookup_shared(jchar* name, int len) {
103 // java_lang_String::hash_code() was used to compute hash values in the shared table. Don't
104 // use the hash value from StringTable::hash_string() as it might use alternate hashcode.
105 return _shared_table.lookup((const char*)name,
106 java_lang_String::hash_code(name, len), len);
107 }
108
109 oop StringTable::lookup_in_main_table(int index, jchar* name,
110 int len, unsigned int hash) {
111 int count = 0;
112 for (HashtableEntry<oop, mtSymbol>* l = bucket(index); l != NULL; l = l->next()) {
113 count++;
114 if (l->hash() == hash) {
115 if (java_lang_String::equals(l->literal(), name, len)) {
116 return l->literal();
117 }
118 }
119 }
120 // If the bucket size is too deep check if this hash code is insufficient.
121 if (count >= rehash_count && !needs_rehashing()) {
392 guarantee(s != NULL, "interned string is NULL");
393 unsigned int h = java_lang_String::hash_string(s);
394 guarantee(p->hash() == h, "broken hash in string table entry");
395 guarantee(the_table()->hash_to_index(h) == i,
396 "wrong index in string table");
397 }
398 }
399 }
400
401 void StringTable::dump(outputStream* st, bool verbose) {
402 if (!verbose) {
403 the_table()->dump_table(st, "StringTable");
404 } else {
405 Thread* THREAD = Thread::current();
406 st->print_cr("VERSION: 1.1");
407 for (int i = 0; i < the_table()->table_size(); ++i) {
408 HashtableEntry<oop, mtSymbol>* p = the_table()->bucket(i);
409 for ( ; p != NULL; p = p->next()) {
410 oop s = p->literal();
411 typeArrayOop value = java_lang_String::value(s);
412 int offset = java_lang_String::offset(s);
413 int length = java_lang_String::length(s);
414
415 if (length <= 0) {
416 st->print("%d: ", length);
417 } else {
418 ResourceMark rm(THREAD);
419 jchar* chars = (jchar*)value->char_at_addr(offset);
420 int utf8_length = UNICODE::utf8_length(chars, length);
421 char* utf8_string = NEW_RESOURCE_ARRAY(char, utf8_length + 1);
422 UNICODE::convert_to_utf8(chars, length, utf8_string);
423
424 st->print("%d: ", utf8_length);
425 HashtableTextDump::put_utf8(st, utf8_string, utf8_length);
426 }
427 st->cr();
428 }
429 }
430 }
431 }
432
433 StringTable::VerifyRetTypes StringTable::compare_entries(
434 int bkt1, int e_cnt1,
435 HashtableEntry<oop, mtSymbol>* e_ptr1,
436 int bkt2, int e_cnt2,
437 HashtableEntry<oop, mtSymbol>* e_ptr2) {
438 // These entries are sanity checked by verify_and_compare_entries()
439 // before this function is called.
440 oop str1 = e_ptr1->literal();
441 oop str2 = e_ptr2->literal();
442
|
77 u1 check_buf[sizeof(_save_buf)];
78 int check_size = sample(check_buf);
79 return (0 == memcmp(_save_buf, check_buf, check_size));
80 }
81
82 void set_region(const void* region) { _region = (address) region; }
83 };
84 #endif
85
86
87 // --------------------------------------------------------------------------
88 StringTable* StringTable::_the_table = NULL;
89 bool StringTable::_ignore_shared_strings = false;
90 bool StringTable::_needs_rehashing = false;
91
92 volatile int StringTable::_parallel_claimed_idx = 0;
93
94 CompactHashtable<oop, char> StringTable::_shared_table;
95
96 // Pick hashing algorithm
97 template<typename T>
98 unsigned int StringTable::hash_string(const T* s, int len) {
99 return use_alternate_hashcode() ? AltHashing::murmur3_32(seed(), s, len) :
100 java_lang_String::hash_code(s, len);
101 }
102
103 // Explicit instantiation for all supported types.
104 template unsigned int StringTable::hash_string<jchar>(const jchar* s, int len);
105 template unsigned int StringTable::hash_string<jbyte>(const jbyte* s, int len);
106
107 oop StringTable::lookup_shared(jchar* name, int len) {
108 // java_lang_String::hash_code() was used to compute hash values in the shared table. Don't
109 // use the hash value from StringTable::hash_string() as it might use alternate hashcode.
110 return _shared_table.lookup((const char*)name,
111 java_lang_String::hash_code(name, len), len);
112 }
113
114 oop StringTable::lookup_in_main_table(int index, jchar* name,
115 int len, unsigned int hash) {
116 int count = 0;
117 for (HashtableEntry<oop, mtSymbol>* l = bucket(index); l != NULL; l = l->next()) {
118 count++;
119 if (l->hash() == hash) {
120 if (java_lang_String::equals(l->literal(), name, len)) {
121 return l->literal();
122 }
123 }
124 }
125 // If the bucket size is too deep check if this hash code is insufficient.
126 if (count >= rehash_count && !needs_rehashing()) {
397 guarantee(s != NULL, "interned string is NULL");
398 unsigned int h = java_lang_String::hash_string(s);
399 guarantee(p->hash() == h, "broken hash in string table entry");
400 guarantee(the_table()->hash_to_index(h) == i,
401 "wrong index in string table");
402 }
403 }
404 }
405
406 void StringTable::dump(outputStream* st, bool verbose) {
407 if (!verbose) {
408 the_table()->dump_table(st, "StringTable");
409 } else {
410 Thread* THREAD = Thread::current();
411 st->print_cr("VERSION: 1.1");
412 for (int i = 0; i < the_table()->table_size(); ++i) {
413 HashtableEntry<oop, mtSymbol>* p = the_table()->bucket(i);
414 for ( ; p != NULL; p = p->next()) {
415 oop s = p->literal();
416 typeArrayOop value = java_lang_String::value(s);
417 int length = java_lang_String::length(s);
418 bool is_latin1 = java_lang_String::is_latin1(s);
419
420 if (length <= 0) {
421 st->print("%d: ", length);
422 } else {
423 ResourceMark rm(THREAD);
424 int utf8_length;
425 char* utf8_string;
426
427 if (!is_latin1) {
428 jchar* chars = value->char_at_addr(0);
429 utf8_length = UNICODE::utf8_length(chars, length);
430 utf8_string = UNICODE::as_utf8(chars, length);
431 } else {
432 jbyte* bytes = value->byte_at_addr(0);
433 utf8_length = UNICODE::utf8_length(bytes, length);
434 utf8_string = UNICODE::as_utf8(bytes, length);
435 }
436
437 st->print("%d: ", utf8_length);
438 HashtableTextDump::put_utf8(st, utf8_string, utf8_length);
439 }
440 st->cr();
441 }
442 }
443 }
444 }
445
446 StringTable::VerifyRetTypes StringTable::compare_entries(
447 int bkt1, int e_cnt1,
448 HashtableEntry<oop, mtSymbol>* e_ptr1,
449 int bkt2, int e_cnt2,
450 HashtableEntry<oop, mtSymbol>* e_ptr2) {
451 // These entries are sanity checked by verify_and_compare_entries()
452 // before this function is called.
453 oop str1 = e_ptr1->literal();
454 oop str2 = e_ptr2->literal();
455
|