< prev index next >

src/share/vm/utilities/hashtable.cpp

Print this page


 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++) {


< prev index next >