188 Atomic::add(-context->_num_removed, &_number_of_entries);
189 }
190 // Copy the table to the shared space.
191 template <MEMFLAGS F> size_t BasicHashtable<F>::count_bytes_for_table() {
192 size_t bytes = 0;
193 bytes += sizeof(intptr_t); // len
194
195 for (int i = 0; i < _table_size; ++i) {
196 for (BasicHashtableEntry<F>** p = _buckets[i].entry_addr();
197 *p != NULL;
198 p = (*p)->next_addr()) {
199 bytes += entry_size();
200 }
201 }
202
203 return bytes;
204 }
205
206 // Dump the hash table entries (into CDS archive)
207 template <MEMFLAGS F> void BasicHashtable<F>::copy_table(char* top, char* end) {
208 assert(is_ptr_aligned(top, sizeof(intptr_t)), "bad alignment");
209 intptr_t *plen = (intptr_t*)(top);
210 top += sizeof(*plen);
211
212 int i;
213 for (i = 0; i < _table_size; ++i) {
214 for (BasicHashtableEntry<F>** p = _buckets[i].entry_addr();
215 *p != NULL;
216 p = (*p)->next_addr()) {
217 *p = (BasicHashtableEntry<F>*)memcpy(top, *p, entry_size());
218 top += entry_size();
219 }
220 }
221 *plen = (char*)(top) - (char*)plen - sizeof(*plen);
222 assert(top == end, "count_bytes_for_table is wrong");
223 // Set the shared bit.
224
225 for (i = 0; i < _table_size; ++i) {
226 for (BasicHashtableEntry<F>* p = bucket(i); p != NULL; p = p->next()) {
227 p->set_shared();
228 }
229 }
230 }
231
232 template <class T, MEMFLAGS F> int RehashableHashtable<T, F>::literal_size(Symbol *symbol) {
233 return symbol->size() * HeapWordSize;
234 }
235
236 template <class T, MEMFLAGS F> int RehashableHashtable<T, F>::literal_size(oop oop) {
237 // NOTE: this would over-count if (pre-JDK8) java_lang_Class::has_offset_field() is true,
277 st->print_cr("Average bucket size : %9.3f", summary.avg());
278 st->print_cr("Variance of bucket size : %9.3f", summary.variance());
279 st->print_cr("Std. dev. of bucket size: %9.3f", summary.sd());
280 st->print_cr("Maximum bucket size : %9d", (int)summary.maximum());
281 }
282
283
284 // Dump the hash table buckets.
285
286 template <MEMFLAGS F> size_t BasicHashtable<F>::count_bytes_for_buckets() {
287 size_t bytes = 0;
288 bytes += sizeof(intptr_t); // len
289 bytes += sizeof(intptr_t); // _number_of_entries
290 bytes += _table_size * sizeof(HashtableBucket<F>); // the buckets
291
292 return bytes;
293 }
294
295 // Dump the buckets (into CDS archive)
296 template <MEMFLAGS F> void BasicHashtable<F>::copy_buckets(char* top, char* end) {
297 assert(is_ptr_aligned(top, sizeof(intptr_t)), "bad alignment");
298 intptr_t len = _table_size * sizeof(HashtableBucket<F>);
299 *(intptr_t*)(top) = len;
300 top += sizeof(intptr_t);
301
302 *(intptr_t*)(top) = _number_of_entries;
303 top += sizeof(intptr_t);
304
305 _buckets = (HashtableBucket<F>*)memcpy(top, (void*)_buckets, len);
306 top += len;
307
308 assert(top == end, "count_bytes_for_buckets is wrong");
309 }
310
311
312 #ifndef PRODUCT
313
314 template <class T, MEMFLAGS F> void Hashtable<T, F>::print() {
315 ResourceMark rm;
316
317 for (int i = 0; i < BasicHashtable<F>::table_size(); i++) {
|
188 Atomic::add(-context->_num_removed, &_number_of_entries);
189 }
190 // Copy the table to the shared space.
191 template <MEMFLAGS F> size_t BasicHashtable<F>::count_bytes_for_table() {
192 size_t bytes = 0;
193 bytes += sizeof(intptr_t); // len
194
195 for (int i = 0; i < _table_size; ++i) {
196 for (BasicHashtableEntry<F>** p = _buckets[i].entry_addr();
197 *p != NULL;
198 p = (*p)->next_addr()) {
199 bytes += entry_size();
200 }
201 }
202
203 return bytes;
204 }
205
206 // Dump the hash table entries (into CDS archive)
207 template <MEMFLAGS F> void BasicHashtable<F>::copy_table(char* top, char* end) {
208 assert(is_aligned(top, sizeof(intptr_t)), "bad alignment");
209 intptr_t *plen = (intptr_t*)(top);
210 top += sizeof(*plen);
211
212 int i;
213 for (i = 0; i < _table_size; ++i) {
214 for (BasicHashtableEntry<F>** p = _buckets[i].entry_addr();
215 *p != NULL;
216 p = (*p)->next_addr()) {
217 *p = (BasicHashtableEntry<F>*)memcpy(top, (void*)*p, entry_size());
218 top += entry_size();
219 }
220 }
221 *plen = (char*)(top) - (char*)plen - sizeof(*plen);
222 assert(top == end, "count_bytes_for_table is wrong");
223 // Set the shared bit.
224
225 for (i = 0; i < _table_size; ++i) {
226 for (BasicHashtableEntry<F>* p = bucket(i); p != NULL; p = p->next()) {
227 p->set_shared();
228 }
229 }
230 }
231
232 template <class T, MEMFLAGS F> int RehashableHashtable<T, F>::literal_size(Symbol *symbol) {
233 return symbol->size() * HeapWordSize;
234 }
235
236 template <class T, MEMFLAGS F> int RehashableHashtable<T, F>::literal_size(oop oop) {
237 // NOTE: this would over-count if (pre-JDK8) java_lang_Class::has_offset_field() is true,
277 st->print_cr("Average bucket size : %9.3f", summary.avg());
278 st->print_cr("Variance of bucket size : %9.3f", summary.variance());
279 st->print_cr("Std. dev. of bucket size: %9.3f", summary.sd());
280 st->print_cr("Maximum bucket size : %9d", (int)summary.maximum());
281 }
282
283
284 // Dump the hash table buckets.
285
286 template <MEMFLAGS F> size_t BasicHashtable<F>::count_bytes_for_buckets() {
287 size_t bytes = 0;
288 bytes += sizeof(intptr_t); // len
289 bytes += sizeof(intptr_t); // _number_of_entries
290 bytes += _table_size * sizeof(HashtableBucket<F>); // the buckets
291
292 return bytes;
293 }
294
295 // Dump the buckets (into CDS archive)
296 template <MEMFLAGS F> void BasicHashtable<F>::copy_buckets(char* top, char* end) {
297 assert(is_aligned(top, sizeof(intptr_t)), "bad alignment");
298 intptr_t len = _table_size * sizeof(HashtableBucket<F>);
299 *(intptr_t*)(top) = len;
300 top += sizeof(intptr_t);
301
302 *(intptr_t*)(top) = _number_of_entries;
303 top += sizeof(intptr_t);
304
305 _buckets = (HashtableBucket<F>*)memcpy(top, (void*)_buckets, len);
306 top += len;
307
308 assert(top == end, "count_bytes_for_buckets is wrong");
309 }
310
311
312 #ifndef PRODUCT
313
314 template <class T, MEMFLAGS F> void Hashtable<T, F>::print() {
315 ResourceMark rm;
316
317 for (int i = 0; i < BasicHashtable<F>::table_size(); i++) {
|