< prev index next >

src/hotspot/share/utilities/concurrentHashTable.inline.hpp

Print this page
rev 52316 : 8185525: Add JFR event for DictionarySizes
Summary: Added TableStatistics event
Reviewed-by: egahlin, coleenp

*** 478,487 **** --- 478,488 ---- } // Publish the deletion. GlobalCounter::write_synchronize(); delete_f(rem_n->value()); Node::destroy_node(rem_n); + JFR_ONLY(_stats_rate.remove();) return true; } template <typename VALUE, typename CONFIG, MEMFLAGS F> template <typename EVALUATE_FUNC, typename DELETE_FUNC>
*** 526,535 **** --- 527,537 ---- write_synchonize_on_visible_epoch(thread); } for (size_t node_it = 0; node_it < nd; node_it++) { del_f(ndel[node_it]->value()); Node::destroy_node(ndel[node_it]); + JFR_ONLY(_stats_rate.remove();) DEBUG_ONLY(ndel[node_it] = (Node*)POISON_PTR;) } GlobalCounter::critical_section_begin(thread); } GlobalCounter::critical_section_end(thread);
*** 562,571 **** --- 564,574 ---- } if (dels > 0) { GlobalCounter::write_synchronize(); for (size_t node_it = 0; node_it < dels; node_it++) { Node::destroy_node(ndel[node_it]); + JFR_ONLY(_stats_rate.remove();) DEBUG_ONLY(ndel[node_it] = (Node*)POISON_PTR;) } } }
*** 896,905 **** --- 899,909 ---- new_node = Node::create_node(value_f(), first_at_start); } else { new_node->set_next(first_at_start); } if (bucket->cas_first(new_node, first_at_start)) { + JFR_ONLY(_stats_rate.add();) callback(true, new_node->value()); new_node = NULL; ret = true; break; /* leave critical section */ }
*** 1002,1011 **** --- 1006,1016 ---- : _new_table(NULL), _log2_start_size(log2size), _log2_size_limit(log2size_limit), _grow_hint(grow_hint), _size_limit_reached(false), _resize_lock_owner(NULL), _invisible_epoch(0) { + _stats_rate = TableRateStatistics(); _resize_lock = new Mutex(Mutex::leaf, "ConcurrentHashTable", false, Monitor::_safepoint_check_never); _table = new InternalTable(log2size); assert(log2size_limit >= log2size, "bad ergo");
*** 1085,1094 **** --- 1090,1100 ---- assert(!bucket->have_redirect() && !bucket->is_locked(), "bad"); Node* new_node = Node::create_node(value, bucket->first()); if (!bucket->cas_first(new_node, bucket->first())) { assert(false, "bad"); } + JFR_ONLY(_stats_rate.add();) return true; } template <typename VALUE, typename CONFIG, MEMFLAGS F> template <typename SCAN_FUNC>
*** 1139,1159 **** unlock_resize_lock(thread); } template <typename VALUE, typename CONFIG, MEMFLAGS F> template <typename VALUE_SIZE_FUNC> ! inline void ConcurrentHashTable<VALUE, CONFIG, F>:: ! statistics_to(Thread* thread, VALUE_SIZE_FUNC& vs_f, ! outputStream* st, const char* table_name) { NumberSeq summary; size_t literal_bytes = 0; - if (!try_resize_lock(thread)) { - st->print_cr("statistics unavailable at this moment"); - return; - } - InternalTable* table = get_table(); for (size_t bucket_it = 0; bucket_it < table->_size; bucket_it++) { ScopedCS cs(thread, this); size_t count = 0; Bucket* bucket = table->get_bucket(bucket_it); --- 1145,1159 ---- unlock_resize_lock(thread); } template <typename VALUE, typename CONFIG, MEMFLAGS F> template <typename VALUE_SIZE_FUNC> ! inline TableStatistics ConcurrentHashTable<VALUE, CONFIG, F>:: ! statistics_calculate(Thread* thread, VALUE_SIZE_FUNC& vs_f) { NumberSeq summary; size_t literal_bytes = 0; InternalTable* table = get_table(); for (size_t bucket_it = 0; bucket_it < table->_size; bucket_it++) { ScopedCS cs(thread, this); size_t count = 0; Bucket* bucket = table->get_bucket(bucket_it);
*** 1167,1207 **** current_node = current_node->next(); } summary.add((double)count); } ! double num_buckets = summary.num(); ! double num_entries = summary.sum(); ! size_t bucket_bytes = num_buckets * sizeof(Bucket); ! size_t entry_bytes = num_entries * sizeof(Node); ! size_t total_bytes = literal_bytes + bucket_bytes + entry_bytes; ! ! size_t bucket_size = (num_buckets <= 0) ? 0 : (bucket_bytes / num_buckets); ! size_t entry_size = (num_entries <= 0) ? 0 : (entry_bytes / num_entries); ! ! st->print_cr("%s statistics:", table_name); ! st->print_cr("Number of buckets : %9" PRIuPTR " = %9" PRIuPTR ! " bytes, each " SIZE_FORMAT, ! (size_t)num_buckets, bucket_bytes, bucket_size); ! st->print_cr("Number of entries : %9" PRIuPTR " = %9" PRIuPTR ! " bytes, each " SIZE_FORMAT, ! (size_t)num_entries, entry_bytes, entry_size); ! if (literal_bytes != 0) { ! double literal_avg = (num_entries <= 0) ? 0 : (literal_bytes / num_entries); ! st->print_cr("Number of literals : %9" PRIuPTR " = %9" PRIuPTR ! " bytes, avg %7.3f", ! (size_t)num_entries, literal_bytes, literal_avg); ! } ! st->print_cr("Total footprsize_t : %9s = %9" PRIuPTR " bytes", "" ! , total_bytes); ! st->print_cr("Average bucket size : %9.3f", summary.avg()); ! st->print_cr("Variance of bucket size : %9.3f", summary.variance()); ! st->print_cr("Std. dev. of bucket size: %9.3f", summary.sd()); ! st->print_cr("Maximum bucket size : %9" PRIuPTR, ! (size_t)summary.maximum()); unlock_resize_lock(thread); } template <typename VALUE, typename CONFIG, MEMFLAGS F> inline bool ConcurrentHashTable<VALUE, CONFIG, F>:: try_move_nodes_to(Thread* thread, ConcurrentHashTable<VALUE, CONFIG, F>* to_cht) --- 1167,1209 ---- current_node = current_node->next(); } summary.add((double)count); } ! return TableStatistics(_stats_rate, summary, literal_bytes, sizeof(Bucket), sizeof(Node)); ! } ! ! template <typename VALUE, typename CONFIG, MEMFLAGS F> ! template <typename VALUE_SIZE_FUNC> ! inline TableStatistics ConcurrentHashTable<VALUE, CONFIG, F>:: ! statistics_get(Thread* thread, VALUE_SIZE_FUNC& vs_f, TableStatistics old) ! { ! if (!try_resize_lock(thread)) { ! return old; ! } ! TableStatistics ts = statistics_calculate(thread, vs_f); unlock_resize_lock(thread); + + return ts; + } + + template <typename VALUE, typename CONFIG, MEMFLAGS F> + template <typename VALUE_SIZE_FUNC> + inline void ConcurrentHashTable<VALUE, CONFIG, F>:: + statistics_to(Thread* thread, VALUE_SIZE_FUNC& vs_f, + outputStream* st, const char* table_name) + { + if (!try_resize_lock(thread)) { + st->print_cr("statistics unavailable at this moment"); + return; + } + + TableStatistics ts = statistics_calculate(thread, vs_f); + unlock_resize_lock(thread); + + ts.print(st, table_name); } template <typename VALUE, typename CONFIG, MEMFLAGS F> inline bool ConcurrentHashTable<VALUE, CONFIG, F>:: try_move_nodes_to(Thread* thread, ConcurrentHashTable<VALUE, CONFIG, F>* to_cht)
< prev index next >