From 2ae5cc79bab2fb3dae28d99063da008eb1f66606 Mon Sep 17 00:00:00 2001 From: Richard Fuchs Date: Tue, 7 Sep 2021 18:52:48 -0400 Subject: [PATCH] TT#101150 obsolete more fields from struct totalstats total_managed_sess, total_average_call_dur, total_average_lock, managed_sess_max, managed_sess_min, managed_sess_lock Change-Id: Ibe3f619ec6d2f21270fc81901dde55b5242b0daa --- daemon/call.c | 5 ++- daemon/graphite.c | 43 +++++++------------- daemon/statistics.c | 70 ++++---------------------------- include/counter_stats_fields.inc | 2 + include/statistics.h | 8 ---- t/test-stats.c | 6 +-- 6 files changed, 33 insertions(+), 101 deletions(-) diff --git a/daemon/call.c b/daemon/call.c index 9f39a147f..3760086ba 100644 --- a/daemon/call.c +++ b/daemon/call.c @@ -3056,8 +3056,10 @@ void call_destroy(struct call *c) { rwlock_lock_w(&rtpe_callhash_lock); ret = (g_hash_table_lookup(rtpe_callhash, &c->callid) == c); - if (ret) + if (ret) { g_hash_table_remove(rtpe_callhash, &c->callid); + RTPE_GAUGE_DEC(total_sessions); + } rwlock_unlock_w(&rtpe_callhash_lock); // if call not found in callhash => previously deleted @@ -3403,6 +3405,7 @@ restart: goto restart; } g_hash_table_insert(rtpe_callhash, &c->callid, obj_get(c)); + RTPE_GAUGE_INC(total_sessions); c->foreign_call = foreign ? 1 : 0; diff --git a/daemon/graphite.c b/daemon/graphite.c index 34493a106..3023b9fb0 100644 --- a/daemon/graphite.c +++ b/daemon/graphite.c @@ -83,13 +83,6 @@ GString *print_graphite_data(struct totalstats *sent_data) { /* atomically copy values to stack and reset to zero */ - mutex_lock(&rtpe_totalstats_interval.total_average_lock); - ts->total_average_call_dur = rtpe_totalstats_interval.total_average_call_dur; - ts->total_managed_sess = rtpe_totalstats_interval.total_managed_sess; - ZERO(rtpe_totalstats_interval.total_average_call_dur); - ZERO(rtpe_totalstats_interval.total_managed_sess); - mutex_unlock(&rtpe_totalstats_interval.total_average_lock); - mutex_lock(&rtpe_totalstats_interval.total_calls_duration_lock); ts->total_calls_duration_interval = rtpe_totalstats_interval.total_calls_duration_interval; rtpe_totalstats_interval.total_calls_duration_interval.tv_sec = 0; @@ -97,18 +90,6 @@ GString *print_graphite_data(struct totalstats *sent_data) { //ZERO(rtpe_totalstats_interval.total_calls_duration_interval); mutex_unlock(&rtpe_totalstats_interval.total_calls_duration_lock); - rwlock_lock_r(&rtpe_callhash_lock); - mutex_lock(&rtpe_totalstats_interval.managed_sess_lock); - ts->managed_sess_max = rtpe_totalstats_interval.managed_sess_max; - ts->managed_sess_min = rtpe_totalstats_interval.managed_sess_min; - uint64_t total_sessions = g_hash_table_size(rtpe_callhash); - uint64_t foreign_sessions = atomic64_get(&rtpe_stats_gauge.foreign_sessions); - uint64_t own_sessions = total_sessions - foreign_sessions; - rtpe_totalstats_interval.managed_sess_max = own_sessions;; - rtpe_totalstats_interval.managed_sess_min = own_sessions; - mutex_unlock(&rtpe_totalstats_interval.managed_sess_lock); - rwlock_unlock_r(&rtpe_callhash_lock); - GString *graph_str = g_string_new(""); #define GPF(fmt, ...) \ @@ -126,14 +107,20 @@ GString *print_graphite_data(struct totalstats *sent_data) { } GPF("call_dur %llu.%06llu",(unsigned long long)ts->total_calls_duration_interval.tv_sec,(unsigned long long)ts->total_calls_duration_interval.tv_usec); - GPF("average_call_dur %llu.%06llu",(unsigned long long)ts->total_average_call_dur.tv_sec,(unsigned long long)ts->total_average_call_dur.tv_usec); + struct timeval avg_duration; + uint64_t managed_sess = atomic64_get_na(&rtpe_stats_graphite_interval.managed_sess); + if (managed_sess) + timeval_from_us(&avg_duration, atomic64_get_na(&rtpe_stats_graphite_interval.call_duration) / managed_sess); + else + avg_duration = (struct timeval) {0,0}; + GPF("average_call_dur %llu.%06llu",(unsigned long long)avg_duration.tv_sec,(unsigned long long)avg_duration.tv_usec); GPF("forced_term_sess "UINT64F, atomic64_get_na(&rtpe_stats_graphite_interval.forced_term_sess)); - GPF("managed_sess "UINT64F, ts->total_managed_sess); - GPF("managed_sess_min "UINT64F, ts->managed_sess_min); - GPF("managed_sess_max "UINT64F, ts->managed_sess_max); - GPF("current_sessions_total "UINT64F, total_sessions); - GPF("current_sessions_own "UINT64F, own_sessions); - GPF("current_sessions_foreign "UINT64F, foreign_sessions); + GPF("managed_sess "UINT64F, atomic64_get(&rtpe_stats.ax.managed_sess)); + GPF("managed_sess_min "UINT64F, atomic64_get_na(&rtpe_stats_gauge_graphite_min_max_interval.min.total_sessions)); + GPF("managed_sess_max "UINT64F, atomic64_get_na(&rtpe_stats_gauge_graphite_min_max_interval.max.total_sessions)); + GPF("current_sessions_total "UINT64F, atomic64_get(&rtpe_stats_gauge.total_sessions)); + GPF("current_sessions_own "UINT64F, atomic64_get(&rtpe_stats_gauge.total_sessions) - atomic64_get(&rtpe_stats_gauge.foreign_sessions)); + GPF("current_sessions_foreign "UINT64F, atomic64_get(&rtpe_stats_gauge.foreign_sessions)); GPF("current_transcoded_media "UINT64F, atomic64_get(&rtpe_stats_gauge.transcoded_media)); GPF("current_sessions_ipv4 "UINT64F, atomic64_get(&rtpe_stats_gauge.ipv4_sessions)); GPF("current_sessions_ipv6 "UINT64F, atomic64_get(&rtpe_stats_gauge.ipv6_sessions)); @@ -195,8 +182,8 @@ GString *print_graphite_data(struct totalstats *sent_data) { ilog(LOG_DEBUG, "min_sessions:%llu max_sessions:%llu, call_dur_per_interval:%llu.%06llu at time %llu\n", - (unsigned long long) ts->managed_sess_min, - (unsigned long long) ts->managed_sess_max, + (unsigned long long) atomic64_get_na(&rtpe_stats_gauge_graphite_min_max_interval.min.total_sessions), + (unsigned long long) atomic64_get_na(&rtpe_stats_gauge_graphite_min_max_interval.max.total_sessions), (unsigned long long ) ts->total_calls_duration_interval.tv_sec, (unsigned long long ) ts->total_calls_duration_interval.tv_usec, (unsigned long long ) rtpe_now.tv_sec); diff --git a/daemon/statistics.c b/daemon/statistics.c index 115a575b3..e9a35a60b 100644 --- a/daemon/statistics.c +++ b/daemon/statistics.c @@ -15,31 +15,6 @@ mutex_t rtpe_codec_stats_lock; GHashTable *rtpe_codec_stats; -static void timeval_totalstats_average_add(struct totalstats *s, const struct timeval *add) { - struct timeval dp, oa; - - mutex_lock(&s->total_average_lock); - - // new average = ((old average * old num sessions) + datapoint) / new num sessions - // ... but this will overflow when num sessions becomes very large - - // timeval_multiply(&t, &s->total_average_call_dur, s->total_managed_sess); - // timeval_add(&t, &t, add); - // s->total_managed_sess++; - // timeval_divide(&s->total_average_call_dur, &t, s->total_managed_sess); - - // alternative: - // new average = old average + (datapoint / new num sessions) - (old average / new num sessions) - - s->total_managed_sess++; - timeval_divide(&dp, add, s->total_managed_sess); - timeval_divide(&oa, &s->total_average_call_dur, s->total_managed_sess); - timeval_add(&s->total_average_call_dur, &s->total_average_call_dur, &dp); - timeval_subtract(&s->total_average_call_dur, &s->total_average_call_dur, &oa); - - mutex_unlock(&s->total_average_lock); -} - static void timeval_totalstats_call_duration_add(struct totalstats *s, struct timeval *call_start, struct timeval *call_stop, struct timeval *interval_start, int interval_dur_s) { @@ -164,26 +139,10 @@ void statistics_update_foreignown_dec(struct call* c) { if (IS_FOREIGN_CALL(c)) { RTPE_GAUGE_DEC(foreign_sessions); } - - if(IS_OWN_CALL(c)) { - mutex_lock(&rtpe_totalstats_interval.managed_sess_lock); - rtpe_totalstats_interval.managed_sess_min = MIN(rtpe_totalstats_interval.managed_sess_min, - g_hash_table_size(rtpe_callhash) - atomic64_get(&rtpe_stats_gauge.foreign_sessions)); - mutex_unlock(&rtpe_totalstats_interval.managed_sess_lock); - } - } void statistics_update_foreignown_inc(struct call* c) { - if (IS_OWN_CALL(c)) { - mutex_lock(&rtpe_totalstats_interval.managed_sess_lock); - rtpe_totalstats_interval.managed_sess_max = MAX( - rtpe_totalstats_interval.managed_sess_max, - g_hash_table_size(rtpe_callhash) - - atomic64_get(&rtpe_stats_gauge.foreign_sessions)); - mutex_unlock(&rtpe_totalstats_interval.managed_sess_lock); - } - else if (IS_FOREIGN_CALL(c)) { /* foreign call*/ + if (IS_FOREIGN_CALL(c)) { /* foreign call*/ RTPE_GAUGE_INC(foreign_sessions); RTPE_STATS_INC(foreign_sess); } @@ -259,8 +218,9 @@ void statistics_update_oneway(struct call* c) { else if (ml->term_reason==FORCED) RTPE_STATS_INC(forced_term_sess); - timeval_totalstats_average_add(&rtpe_totalstats, &tim_result_duration); - timeval_totalstats_average_add(&rtpe_totalstats_interval, &tim_result_duration); + RTPE_STATS_ADD(call_duration, timeval_us(&tim_result_duration)); + RTPE_STATS_INC(managed_sess); + timeval_totalstats_call_duration_add( &rtpe_totalstats_interval, &ml->started, &ml->terminated, &rtpe_latest_graphite_interval_start, @@ -422,11 +382,6 @@ GQueue *statistics_gather_metrics(void) { struct timeval avg, calls_dur_iv; uint64_t cur_sessions, num_sessions, min_sess_iv, max_sess_iv; - mutex_lock(&rtpe_totalstats.total_average_lock); - avg = rtpe_totalstats.total_average_call_dur; - num_sessions = rtpe_totalstats.total_managed_sess; - mutex_unlock(&rtpe_totalstats.total_average_lock); - HEADER("{", ""); HEADER("currentstatistics", "Statistics over currently running sessions:"); HEADER("{", ""); @@ -450,10 +405,9 @@ GQueue *statistics_gather_metrics(void) { METRIC("byterate", "Bytes per second", UINT64F, UINT64F, atomic64_get(&rtpe_stats.intv.bytes)); METRIC("errorrate", "Errors per second", UINT64F, UINT64F, atomic64_get(&rtpe_stats.intv.errors)); - mutex_lock(&rtpe_totalstats.total_average_lock); - avg = rtpe_totalstats.total_average_call_dur; - num_sessions = rtpe_totalstats.total_managed_sess; - mutex_unlock(&rtpe_totalstats.total_average_lock); + num_sessions = atomic64_get(&rtpe_stats.ax.managed_sess); + long long avg_us = num_sessions ? atomic64_get(&rtpe_stats.ax.call_duration) / num_sessions : 0; + timeval_from_us(&avg, avg_us); HEADER("}", ""); HEADER("totalstatistics", "Total statistics (does not include current running sessions):"); @@ -501,8 +455,8 @@ GQueue *statistics_gather_metrics(void) { mutex_lock(&rtpe_totalstats_lastinterval_lock); calls_dur_iv = rtpe_totalstats_lastinterval.total_calls_duration_interval; - min_sess_iv = rtpe_totalstats_lastinterval.managed_sess_min; - max_sess_iv = rtpe_totalstats_lastinterval.managed_sess_max; + min_sess_iv = atomic64_get(&rtpe_stats_gauge_graphite_min_max_interval.min.total_sessions); + max_sess_iv = atomic64_get(&rtpe_stats_gauge_graphite_min_max_interval.max.total_sessions); mutex_unlock(&rtpe_totalstats_lastinterval_lock); HEADER(NULL, ""); @@ -726,9 +680,6 @@ void statistics_free_metrics(GQueue **q) { } void statistics_free() { - mutex_destroy(&rtpe_totalstats.total_average_lock); - mutex_destroy(&rtpe_totalstats_interval.total_average_lock); - mutex_destroy(&rtpe_totalstats_interval.managed_sess_lock); mutex_destroy(&rtpe_totalstats_interval.total_calls_duration_lock); mutex_destroy(&rtpe_totalstats_lastinterval_lock); @@ -745,9 +696,6 @@ static void codec_stats_free(void *p) { } void statistics_init() { - mutex_init(&rtpe_totalstats.total_average_lock); - mutex_init(&rtpe_totalstats_interval.total_average_lock); - mutex_init(&rtpe_totalstats_interval.managed_sess_lock); mutex_init(&rtpe_totalstats_interval.total_calls_duration_lock); time(&rtpe_totalstats.started); diff --git a/include/counter_stats_fields.inc b/include/counter_stats_fields.inc index 2538e6a37..5c61529c4 100644 --- a/include/counter_stats_fields.inc +++ b/include/counter_stats_fields.inc @@ -3,6 +3,7 @@ F(bytes) F(errors) FA(ng_commands, NGC_COUNT) F(timeout_sess) +F(managed_sess) F(foreign_sess) F(rejected_sess) F(silent_timeout_sess) @@ -12,3 +13,4 @@ F(regular_term_sess) F(forced_term_sess) F(nopacket_relayed_sess) F(oneway_stream_sess) +F(call_duration) diff --git a/include/statistics.h b/include/statistics.h index 95b4af91e..55cdfd7af 100644 --- a/include/statistics.h +++ b/include/statistics.h @@ -65,14 +65,6 @@ struct global_stats_min_max { struct totalstats { time_t started; - mutex_t total_average_lock; /* for these two below */ - uint64_t total_managed_sess; - struct timeval total_average_call_dur; - - mutex_t managed_sess_lock; /* for these below */ - uint64_t managed_sess_max; /* per graphite interval statistic */ - uint64_t managed_sess_min; /* per graphite interval statistic */ - mutex_t total_calls_duration_lock; /* for these two below */ struct timeval total_calls_duration_interval; }; diff --git a/t/test-stats.c b/t/test-stats.c index bf9e91eb9..a9aac3124 100644 --- a/t/test-stats.c +++ b/t/test-stats.c @@ -3211,7 +3211,7 @@ int main(void) { "average_call_dur 0.000000 157\n" "forced_term_sess 0 157\n" "managed_sess 0 157\n" - "managed_sess_min 0 157\n" + "managed_sess_min 1 157\n" "managed_sess_max 2 157\n" "current_sessions_total 2 157\n" "current_sessions_own 2 157\n" @@ -3427,8 +3427,8 @@ int main(void) { "\n" "Min managed sessions\n" "minmanagedsessions\n" - "0\n" - "0\n" + "1\n" + "1\n" "Max managed sessions\n" "maxmanagedsessions\n" "2\n"