truffle: src/share/vm/utilities/hashtable.cpp annotate

annotate src/share/vm/utilities/hashtable.cpp @ 14649:f6301b007a16

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	cd6b3f1a94ff
children	524b54a7f1b5 152cf4afc11f

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
14340 cd6b3f1a94ff 8033792: AltHashing used jint for imprecise bit shifting minqi parents: 12316 diff changeset	2 * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 470 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 470 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 470 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #include "precompiled.hpp"
6201 ace99a6ffc83 7181200: JVM new hashing code breaks SA in product mode coleenp parents: 6197 diff changeset	26 #include "classfile/altHashing.hpp"
ace99a6ffc83 7181200: JVM new hashing code breaks SA in product mode coleenp parents: 6197 diff changeset	27 #include "classfile/javaClasses.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "memory/allocation.inline.hpp"
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	29 #include "memory/filemap.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "runtime/safepoint.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	33 #include "utilities/dtrace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34 #include "utilities/hashtable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	35 #include "utilities/hashtable.inline.hpp"
10312 a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	36 #include "utilities/numberSeq.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	37
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	38
0 a61af66fc99e Initial load duke parents: diff changeset	39 // This is a generic hashtable, designed to be used for the symbol
a61af66fc99e Initial load duke parents: diff changeset	40 // and string tables.
a61af66fc99e Initial load duke parents: diff changeset	41 //
a61af66fc99e Initial load duke parents: diff changeset	42 // It is implemented as an open hash table with a fixed number of buckets.
a61af66fc99e Initial load duke parents: diff changeset	43 //
a61af66fc99e Initial load duke parents: diff changeset	44 // %note:
a61af66fc99e Initial load duke parents: diff changeset	45 // - HashtableEntrys are allocated in blocks to reduce the space overhead.
a61af66fc99e Initial load duke parents: diff changeset	46
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	47 template <MEMFLAGS F> BasicHashtableEntry<F>* BasicHashtable<F>::new_entry(unsigned int hashValue) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	48 BasicHashtableEntry<F>* entry;
0 a61af66fc99e Initial load duke parents: diff changeset	49
a61af66fc99e Initial load duke parents: diff changeset	50 if (_free_list) {
a61af66fc99e Initial load duke parents: diff changeset	51 entry = _free_list;
a61af66fc99e Initial load duke parents: diff changeset	52 _free_list = _free_list->next();
a61af66fc99e Initial load duke parents: diff changeset	53 } else {
432 275a3b7ff0d6 6770949: minor tweaks before 6655638 jrose parents: 0 diff changeset	54 if (_first_free_entry + _entry_size >= _end_block) {
275a3b7ff0d6 6770949: minor tweaks before 6655638 jrose parents: 0 diff changeset	55 int block_size = MIN2(512, MAX2((int)_table_size / 2, (int)_number_of_entries));
0 a61af66fc99e Initial load duke parents: diff changeset	56 int len = _entry_size * block_size;
432 275a3b7ff0d6 6770949: minor tweaks before 6655638 jrose parents: 0 diff changeset	57 len = 1 << log2_intptr(len); // round down to power of 2
275a3b7ff0d6 6770949: minor tweaks before 6655638 jrose parents: 0 diff changeset	58 assert(len >= _entry_size, "");
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	59 _first_free_entry = NEW_C_HEAP_ARRAY2(char, len, F, CURRENT_PC);
0 a61af66fc99e Initial load duke parents: diff changeset	60 _end_block = _first_free_entry + len;
a61af66fc99e Initial load duke parents: diff changeset	61 }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	62 entry = (BasicHashtableEntry<F>*)_first_free_entry;
0 a61af66fc99e Initial load duke parents: diff changeset	63 _first_free_entry += _entry_size;
a61af66fc99e Initial load duke parents: diff changeset	64 }
a61af66fc99e Initial load duke parents: diff changeset	65
432 275a3b7ff0d6 6770949: minor tweaks before 6655638 jrose parents: 0 diff changeset	66 assert(_entry_size % HeapWordSize == 0, "");
0 a61af66fc99e Initial load duke parents: diff changeset	67 entry->set_hash(hashValue);
a61af66fc99e Initial load duke parents: diff changeset	68 return entry;
a61af66fc99e Initial load duke parents: diff changeset	69 }
a61af66fc99e Initial load duke parents: diff changeset	70
a61af66fc99e Initial load duke parents: diff changeset	71
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	72 template <class T, MEMFLAGS F> HashtableEntry<T, F>* Hashtable<T, F>::new_entry(unsigned int hashValue, T obj) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	73 HashtableEntry<T, F>* entry;
0 a61af66fc99e Initial load duke parents: diff changeset	74
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	75 entry = (HashtableEntry<T, F>*)BasicHashtable<F>::new_entry(hashValue);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	76 entry->set_literal(obj);
0 a61af66fc99e Initial load duke parents: diff changeset	77 return entry;
a61af66fc99e Initial load duke parents: diff changeset	78 }
a61af66fc99e Initial load duke parents: diff changeset	79
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	80 // Check to see if the hashtable is unbalanced. The caller set a flag to
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	81 // rehash at the next safepoint. If this bucket is 60 times greater than the
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	82 // expected average bucket length, it's an unbalanced hashtable.
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	83 // This is somewhat an arbitrary heuristic but if one bucket gets to
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	84 // rehash_count which is currently 100, there's probably something wrong.
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	85
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	86 template <MEMFLAGS F> bool BasicHashtable<F>::check_rehash_table(int count) {
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	87 assert(table_size() != 0, "underflow");
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	88 if (count > (((double)number_of_entries()/(double)table_size())*rehash_multiple)) {
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	89 // Set a flag for the next safepoint, which should be at some guaranteed
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	90 // safepoint interval.
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	91 return true;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	92 }
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	93 return false;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	94 }
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	95
14340 cd6b3f1a94ff 8033792: AltHashing used jint for imprecise bit shifting minqi parents: 12316 diff changeset	96 template <class T, MEMFLAGS F> juint Hashtable<T, F>::_seed = 0;
6201 ace99a6ffc83 7181200: JVM new hashing code breaks SA in product mode coleenp parents: 6197 diff changeset	97
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	98 // Create a new table and using alternate hash code, populate the new table
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	99 // with the existing elements. This can be used to change the hash code
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	100 // and could in the future change the size of the table.
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	101
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	102 template <class T, MEMFLAGS F> void Hashtable<T, F>::move_to(Hashtable<T, F>* new_table) {
6201 ace99a6ffc83 7181200: JVM new hashing code breaks SA in product mode coleenp parents: 6197 diff changeset	103
ace99a6ffc83 7181200: JVM new hashing code breaks SA in product mode coleenp parents: 6197 diff changeset	104 // Initialize the global seed for hashing.
ace99a6ffc83 7181200: JVM new hashing code breaks SA in product mode coleenp parents: 6197 diff changeset	105 _seed = AltHashing::compute_seed();
ace99a6ffc83 7181200: JVM new hashing code breaks SA in product mode coleenp parents: 6197 diff changeset	106 assert(seed() != 0, "shouldn't be zero");
ace99a6ffc83 7181200: JVM new hashing code breaks SA in product mode coleenp parents: 6197 diff changeset	107
ace99a6ffc83 7181200: JVM new hashing code breaks SA in product mode coleenp parents: 6197 diff changeset	108 int saved_entry_count = this->number_of_entries();
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	109
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	110 // Iterate through the table and create a new entry for the new table
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	111 for (int i = 0; i < new_table->table_size(); ++i) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	112 for (HashtableEntry<T, F>* p = bucket(i); p != NULL; ) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	113 HashtableEntry<T, F>* next = p->next();
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	114 T string = p->literal();
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	115 // Use alternate hashing algorithm on the symbol in the first table
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6260 diff changeset	116 unsigned int hashValue = string->new_hash(seed());
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	117 // Get a new index relative to the new table (can also change size)
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	118 int index = new_table->hash_to_index(hashValue);
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	119 p->set_hash(hashValue);
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	120 // Keep the shared bit in the Hashtable entry to indicate that this entry
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	121 // can't be deleted. The shared bit is the LSB in the _next field so
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	122 // walking the hashtable past these entries requires
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	123 // BasicHashtableEntry::make_ptr() call.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	124 bool keep_shared = p->is_shared();
6260 5e2dc722e70d 7186278: Build error after CR#6995781 / 7151532 with GCC 4.7.0 andrew parents: 6201 diff changeset	125 this->unlink_entry(p);
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	126 new_table->add_entry(index, p);
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	127 if (keep_shared) {
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	128 p->set_shared();
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	129 }
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	130 p = next;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	131 }
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	132 }
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	133 // give the new table the free list as well
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	134 new_table->copy_freelist(this);
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	135 assert(new_table->number_of_entries() == saved_entry_count, "lost entry on dictionary copy?");
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	136
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	137 // Destroy memory used by the buckets in the hashtable. The memory
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	138 // for the elements has been used in a new table and is not
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	139 // destroyed. The memory reuse will benefit resizing the SystemDictionary
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	140 // to avoid a memory allocation spike at safepoint.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	141 BasicHashtable<F>::free_buckets();
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	142 }
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 4006 diff changeset	143
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	144 template <MEMFLAGS F> void BasicHashtable<F>::free_buckets() {
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	145 if (NULL != _buckets) {
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	146 // Don't delete the buckets in the shared space. They aren't
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	147 // allocated by os::malloc
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	148 if (!UseSharedSpaces \|\|
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	149 !FileMapInfo::current_info()->is_in_shared_space(_buckets)) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	150 FREE_C_HEAP_ARRAY(HashtableBucket, _buckets, F);
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	151 }
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	152 _buckets = NULL;
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	153 }
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	154 }
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	155
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	156
0 a61af66fc99e Initial load duke parents: diff changeset	157 // Reverse the order of elements in the hash buckets.
a61af66fc99e Initial load duke parents: diff changeset	158
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	159 template <MEMFLAGS F> void BasicHashtable<F>::reverse() {
0 a61af66fc99e Initial load duke parents: diff changeset	160
a61af66fc99e Initial load duke parents: diff changeset	161 for (int i = 0; i < _table_size; ++i) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	162 BasicHashtableEntry<F>* new_list = NULL;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	163 BasicHashtableEntry<F>* p = bucket(i);
0 a61af66fc99e Initial load duke parents: diff changeset	164 while (p != NULL) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	165 BasicHashtableEntry<F>* next = p->next();
0 a61af66fc99e Initial load duke parents: diff changeset	166 p->set_next(new_list);
a61af66fc99e Initial load duke parents: diff changeset	167 new_list = p;
a61af66fc99e Initial load duke parents: diff changeset	168 p = next;
a61af66fc99e Initial load duke parents: diff changeset	169 }
a61af66fc99e Initial load duke parents: diff changeset	170 *bucket_addr(i) = new_list;
a61af66fc99e Initial load duke parents: diff changeset	171 }
a61af66fc99e Initial load duke parents: diff changeset	172 }
a61af66fc99e Initial load duke parents: diff changeset	173
a61af66fc99e Initial load duke parents: diff changeset	174
a61af66fc99e Initial load duke parents: diff changeset	175 // Copy the table to the shared space.
a61af66fc99e Initial load duke parents: diff changeset	176
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	177 template <MEMFLAGS F> void BasicHashtable<F>::copy_table(char** top, char* end) {
0 a61af66fc99e Initial load duke parents: diff changeset	178
a61af66fc99e Initial load duke parents: diff changeset	179 // Dump the hash table entries.
a61af66fc99e Initial load duke parents: diff changeset	180
a61af66fc99e Initial load duke parents: diff changeset	181 intptr_t plen = (intptr_t)(*top);
a61af66fc99e Initial load duke parents: diff changeset	182 top += sizeof(plen);
a61af66fc99e Initial load duke parents: diff changeset	183
a61af66fc99e Initial load duke parents: diff changeset	184 int i;
a61af66fc99e Initial load duke parents: diff changeset	185 for (i = 0; i < _table_size; ++i) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	186 for (BasicHashtableEntry<F>** p = _buckets[i].entry_addr();
0 a61af66fc99e Initial load duke parents: diff changeset	187 *p != NULL;
a61af66fc99e Initial load duke parents: diff changeset	188 p = (*p)->next_addr()) {
a61af66fc99e Initial load duke parents: diff changeset	189 if (*top + entry_size() > end) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	190 report_out_of_shared_space(SharedMiscData);
0 a61af66fc99e Initial load duke parents: diff changeset	191 }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	192 p = (BasicHashtableEntry<F>)memcpy(top, p, entry_size());
0 a61af66fc99e Initial load duke parents: diff changeset	193 *top += entry_size();
a61af66fc99e Initial load duke parents: diff changeset	194 }
a61af66fc99e Initial load duke parents: diff changeset	195 }
a61af66fc99e Initial load duke parents: diff changeset	196 plen = (char)(top) - (char)plen - sizeof(*plen);
a61af66fc99e Initial load duke parents: diff changeset	197
a61af66fc99e Initial load duke parents: diff changeset	198 // Set the shared bit.
a61af66fc99e Initial load duke parents: diff changeset	199
a61af66fc99e Initial load duke parents: diff changeset	200 for (i = 0; i < _table_size; ++i) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	201 for (BasicHashtableEntry<F>* p = bucket(i); p != NULL; p = p->next()) {
0 a61af66fc99e Initial load duke parents: diff changeset	202 p->set_shared();
a61af66fc99e Initial load duke parents: diff changeset	203 }
a61af66fc99e Initial load duke parents: diff changeset	204 }
a61af66fc99e Initial load duke parents: diff changeset	205 }
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207
a61af66fc99e Initial load duke parents: diff changeset	208
a61af66fc99e Initial load duke parents: diff changeset	209 // Reverse the order of elements in the hash buckets.
a61af66fc99e Initial load duke parents: diff changeset	210
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	211 template <class T, MEMFLAGS F> void Hashtable<T, F>::reverse(void* boundary) {
0 a61af66fc99e Initial load duke parents: diff changeset	212
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	213 for (int i = 0; i < this->table_size(); ++i) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	214 HashtableEntry<T, F>* high_list = NULL;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	215 HashtableEntry<T, F>* low_list = NULL;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	216 HashtableEntry<T, F>* last_low_entry = NULL;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	217 HashtableEntry<T, F>* p = bucket(i);
0 a61af66fc99e Initial load duke parents: diff changeset	218 while (p != NULL) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	219 HashtableEntry<T, F>* next = p->next();
0 a61af66fc99e Initial load duke parents: diff changeset	220 if ((void*)p->literal() >= boundary) {
a61af66fc99e Initial load duke parents: diff changeset	221 p->set_next(high_list);
a61af66fc99e Initial load duke parents: diff changeset	222 high_list = p;
a61af66fc99e Initial load duke parents: diff changeset	223 } else {
a61af66fc99e Initial load duke parents: diff changeset	224 p->set_next(low_list);
a61af66fc99e Initial load duke parents: diff changeset	225 low_list = p;
a61af66fc99e Initial load duke parents: diff changeset	226 if (last_low_entry == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	227 last_low_entry = p;
a61af66fc99e Initial load duke parents: diff changeset	228 }
a61af66fc99e Initial load duke parents: diff changeset	229 }
a61af66fc99e Initial load duke parents: diff changeset	230 p = next;
a61af66fc99e Initial load duke parents: diff changeset	231 }
a61af66fc99e Initial load duke parents: diff changeset	232 if (low_list != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	233 *bucket_addr(i) = low_list;
a61af66fc99e Initial load duke parents: diff changeset	234 last_low_entry->set_next(high_list);
a61af66fc99e Initial load duke parents: diff changeset	235 } else {
a61af66fc99e Initial load duke parents: diff changeset	236 *bucket_addr(i) = high_list;
a61af66fc99e Initial load duke parents: diff changeset	237 }
a61af66fc99e Initial load duke parents: diff changeset	238 }
a61af66fc99e Initial load duke parents: diff changeset	239 }
a61af66fc99e Initial load duke parents: diff changeset	240
10312 a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	241 template <class T, MEMFLAGS F> int Hashtable<T, F>::literal_size(Symbol *symbol) {
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	242 return symbol->size() * HeapWordSize;
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	243 }
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	244
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	245 template <class T, MEMFLAGS F> int Hashtable<T, F>::literal_size(oop oop) {
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	246 // NOTE: this would over-count if (pre-JDK8) java_lang_Class::has_offset_field() is true,
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	247 // and the String.value array is shared by several Strings. However, starting from JDK8,
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	248 // the String.value array is not shared anymore.
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	249 assert(oop != NULL && oop->klass() == SystemDictionary::String_klass(), "only strings are supported");
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	250 return (oop->size() + java_lang_String::value(oop)->size()) * HeapWordSize;
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	251 }
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	252
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	253 // Dump footprint and bucket length statistics
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	254 //
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	255 // Note: if you create a new subclass of Hashtable<MyNewType, F>, you will need to
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	256 // add a new function Hashtable<T, F>::literal_size(MyNewType lit)
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	257
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	258 template <class T, MEMFLAGS F> void Hashtable<T, F>::dump_table(outputStream* st, const char *table_name) {
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	259 NumberSeq summary;
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	260 int literal_bytes = 0;
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	261 for (int i = 0; i < this->table_size(); ++i) {
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	262 int count = 0;
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	263 for (HashtableEntry<T, F>* e = bucket(i);
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	264 e != NULL; e = e->next()) {
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	265 count++;
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	266 literal_bytes += literal_size(e->literal());
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	267 }
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	268 summary.add((double)count);
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	269 }
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	270 double num_buckets = summary.num();
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	271 double num_entries = summary.sum();
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	272
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	273 int bucket_bytes = (int)num_buckets * sizeof(bucket(0));
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	274 int entry_bytes = (int)num_entries * sizeof(HashtableEntry<T, F>);
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	275 int total_bytes = literal_bytes + bucket_bytes + entry_bytes;
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	276
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	277 double bucket_avg = (num_buckets <= 0) ? 0 : (bucket_bytes / num_buckets);
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	278 double entry_avg = (num_entries <= 0) ? 0 : (entry_bytes / num_entries);
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	279 double literal_avg = (num_entries <= 0) ? 0 : (literal_bytes / num_entries);
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	280
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	281 st->print_cr("%s statistics:", table_name);
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	282 st->print_cr("Number of buckets : %9d = %9d bytes, avg %7.3f", (int)num_buckets, bucket_bytes, bucket_avg);
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	283 st->print_cr("Number of entries : %9d = %9d bytes, avg %7.3f", (int)num_entries, entry_bytes, entry_avg);
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	284 st->print_cr("Number of literals : %9d = %9d bytes, avg %7.3f", (int)num_entries, literal_bytes, literal_avg);
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	285 st->print_cr("Total footprint : %9s = %9d bytes", "", total_bytes);
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	286 st->print_cr("Average bucket size : %9.3f", summary.avg());
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	287 st->print_cr("Variance of bucket size : %9.3f", summary.variance());
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	288 st->print_cr("Std. dev. of bucket size: %9.3f", summary.sd());
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	289 st->print_cr("Maximum bucket size : %9d", (int)summary.maximum());
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	290 }
a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info iklam parents: 6725 diff changeset	291
0 a61af66fc99e Initial load duke parents: diff changeset	292
a61af66fc99e Initial load duke parents: diff changeset	293 // Dump the hash table buckets.
a61af66fc99e Initial load duke parents: diff changeset	294
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	295 template <MEMFLAGS F> void BasicHashtable<F>::copy_buckets(char** top, char* end) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	296 intptr_t len = _table_size * sizeof(HashtableBucket<F>);
0 a61af66fc99e Initial load duke parents: diff changeset	297 (intptr_t)(*top) = len;
a61af66fc99e Initial load duke parents: diff changeset	298 *top += sizeof(intptr_t);
a61af66fc99e Initial load duke parents: diff changeset	299
a61af66fc99e Initial load duke parents: diff changeset	300 (intptr_t)(*top) = _number_of_entries;
a61af66fc99e Initial load duke parents: diff changeset	301 *top += sizeof(intptr_t);
a61af66fc99e Initial load duke parents: diff changeset	302
a61af66fc99e Initial load duke parents: diff changeset	303 if (*top + len > end) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	304 report_out_of_shared_space(SharedMiscData);
0 a61af66fc99e Initial load duke parents: diff changeset	305 }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	306 _buckets = (HashtableBucket<F>)memcpy(top, _buckets, len);
0 a61af66fc99e Initial load duke parents: diff changeset	307 *top += len;
a61af66fc99e Initial load duke parents: diff changeset	308 }
a61af66fc99e Initial load duke parents: diff changeset	309
a61af66fc99e Initial load duke parents: diff changeset	310
a61af66fc99e Initial load duke parents: diff changeset	311 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	312
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	313 template <class T, MEMFLAGS F> void Hashtable<T, F>::print() {
0 a61af66fc99e Initial load duke parents: diff changeset	314 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	315
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	316 for (int i = 0; i < BasicHashtable<F>::table_size(); i++) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	317 HashtableEntry<T, F>* entry = bucket(i);
0 a61af66fc99e Initial load duke parents: diff changeset	318 while(entry != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	319 tty->print("%d : ", i);
a61af66fc99e Initial load duke parents: diff changeset	320 entry->literal()->print();
a61af66fc99e Initial load duke parents: diff changeset	321 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	322 entry = entry->next();
a61af66fc99e Initial load duke parents: diff changeset	323 }
a61af66fc99e Initial load duke parents: diff changeset	324 }
a61af66fc99e Initial load duke parents: diff changeset	325 }
a61af66fc99e Initial load duke parents: diff changeset	326
a61af66fc99e Initial load duke parents: diff changeset	327
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	328 template <MEMFLAGS F> void BasicHashtable<F>::verify() {
0 a61af66fc99e Initial load duke parents: diff changeset	329 int count = 0;
a61af66fc99e Initial load duke parents: diff changeset	330 for (int i = 0; i < table_size(); i++) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	331 for (BasicHashtableEntry<F>* p = bucket(i); p != NULL; p = p->next()) {
0 a61af66fc99e Initial load duke parents: diff changeset	332 ++count;
a61af66fc99e Initial load duke parents: diff changeset	333 }
a61af66fc99e Initial load duke parents: diff changeset	334 }
a61af66fc99e Initial load duke parents: diff changeset	335 assert(count == number_of_entries(), "number of hashtable entries incorrect");
a61af66fc99e Initial load duke parents: diff changeset	336 }
a61af66fc99e Initial load duke parents: diff changeset	337
a61af66fc99e Initial load duke parents: diff changeset	338
a61af66fc99e Initial load duke parents: diff changeset	339 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	340
a61af66fc99e Initial load duke parents: diff changeset	341
a61af66fc99e Initial load duke parents: diff changeset	342 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	343
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	344 template <MEMFLAGS F> void BasicHashtable<F>::verify_lookup_length(double load) {
0 a61af66fc99e Initial load duke parents: diff changeset	345 if ((double)_lookup_length / (double)_lookup_count > load * 2.0) {
a61af66fc99e Initial load duke parents: diff changeset	346 warning("Performance bug: SystemDictionary lookup_count=%d "
a61af66fc99e Initial load duke parents: diff changeset	347 "lookup_length=%d average=%lf load=%f",
a61af66fc99e Initial load duke parents: diff changeset	348 _lookup_count, _lookup_length,
a61af66fc99e Initial load duke parents: diff changeset	349 (double) _lookup_length / _lookup_count, load);
a61af66fc99e Initial load duke parents: diff changeset	350 }
a61af66fc99e Initial load duke parents: diff changeset	351 }
a61af66fc99e Initial load duke parents: diff changeset	352
a61af66fc99e Initial load duke parents: diff changeset	353 #endif
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	354 // Explicitly instantiate these types
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6260 diff changeset	355 template class Hashtable<ConstantPool*, mtClass>;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	356 template class Hashtable<Symbol*, mtSymbol>;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6260 diff changeset	357 template class Hashtable<Klass*, mtClass>;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	358 template class Hashtable<oop, mtClass>;
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10312 diff changeset	359 #if defined(SOLARIS) \|\| defined(CHECK_UNHANDLED_OOPS)
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	360 template class Hashtable<oop, mtSymbol>;
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10312 diff changeset	361 #endif // SOLARIS \|\| CHECK_UNHANDLED_OOPS
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	362 template class Hashtable<oopDesc*, mtSymbol>;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	363 template class Hashtable<Symbol*, mtClass>;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	364 template class HashtableEntry<Symbol*, mtSymbol>;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	365 template class HashtableEntry<Symbol*, mtClass>;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	366 template class HashtableEntry<oop, mtSymbol>;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	367 template class BasicHashtableEntry<mtSymbol>;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	368 template class BasicHashtableEntry<mtCode>;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	369 template class BasicHashtable<mtClass>;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	370 template class BasicHashtable<mtSymbol>;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	371 template class BasicHashtable<mtCode>;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	372 template class BasicHashtable<mtInternal>;

Mercurial > hg > truffle

annotate src/share/vm/utilities/hashtable.cpp @ 14649:f6301b007a16