From cdc8407a7caff165c816876e3d1bdcb1e1a9f8f3 Mon Sep 17 00:00:00 2001 From: Richard Fuchs Date: Thu, 4 Apr 2024 12:54:06 -0400 Subject: [PATCH] MT#55283 use relaxed memory order for stats No need for memory barriers here Change-Id: I9ac6768bb1929be3aa982b0de73c95baa965bef7 --- daemon/cli.c | 36 +++++----- daemon/graphite.c | 36 +++++----- daemon/statistics.c | 156 +++++++++++++++++++++---------------------- include/statistics.h | 12 ++-- lib/auxlib.h | 28 ++++---- 5 files changed, 134 insertions(+), 134 deletions(-) diff --git a/daemon/cli.c b/daemon/cli.c index c91be18f0..22555c455 100644 --- a/daemon/cli.c +++ b/daemon/cli.c @@ -438,26 +438,26 @@ static void cli_incoming_params_revert(str *instr, struct cli_writer *cw) { static void cli_incoming_list_counters(str *instr, struct cli_writer *cw) { cw->cw_printf(cw, "\nCurrent per-second counters:\n\n"); cw->cw_printf(cw, " Packets per second (userspace) :%" PRIu64 "\n", - atomic64_get(&rtpe_stats_rate.packets_user)); + atomic64_get_na(&rtpe_stats_rate.packets_user)); cw->cw_printf(cw, " Bytes per second (userspace) :%" PRIu64 "\n", - atomic64_get(&rtpe_stats_rate.bytes_user)); + atomic64_get_na(&rtpe_stats_rate.bytes_user)); cw->cw_printf(cw, " Errors per second (userspace) :%" PRIu64 "\n", - atomic64_get(&rtpe_stats_rate.errors_user)); + atomic64_get_na(&rtpe_stats_rate.errors_user)); cw->cw_printf(cw, " Packets per second (kernel) :%" PRIu64 "\n", - atomic64_get(&rtpe_stats_rate.packets_kernel)); + atomic64_get_na(&rtpe_stats_rate.packets_kernel)); cw->cw_printf(cw, " Bytes per second (kernel) :%" PRIu64 "\n", - atomic64_get(&rtpe_stats_rate.bytes_kernel)); + atomic64_get_na(&rtpe_stats_rate.bytes_kernel)); cw->cw_printf(cw, " Errors per second (kernel) :%" PRIu64 "\n", - atomic64_get(&rtpe_stats_rate.errors_kernel)); + atomic64_get_na(&rtpe_stats_rate.errors_kernel)); cw->cw_printf(cw, " Packets per second (total) :%" PRIu64 "\n", - atomic64_get(&rtpe_stats_rate.packets_user) + - atomic64_get(&rtpe_stats_rate.packets_kernel)); + atomic64_get_na(&rtpe_stats_rate.packets_user) + + atomic64_get_na(&rtpe_stats_rate.packets_kernel)); cw->cw_printf(cw, " Bytes per second (total) :%" PRIu64 "\n", - atomic64_get(&rtpe_stats_rate.bytes_user) + - atomic64_get(&rtpe_stats_rate.bytes_kernel)); + atomic64_get_na(&rtpe_stats_rate.bytes_user) + + atomic64_get_na(&rtpe_stats_rate.bytes_kernel)); cw->cw_printf(cw, " Errors per second (total) :%" PRIu64 "\n", - atomic64_get(&rtpe_stats_rate.errors_user) + - atomic64_get(&rtpe_stats_rate.errors_kernel)); + atomic64_get_na(&rtpe_stats_rate.errors_user) + + atomic64_get_na(&rtpe_stats_rate.errors_kernel)); } static void cli_incoming_list_totals(str *instr, struct cli_writer *cw) { @@ -480,17 +480,17 @@ static void cli_incoming_list_totals(str *instr, struct cli_writer *cw) { static void cli_incoming_list_numsessions(str *instr, struct cli_writer *cw) { rwlock_lock_r(&rtpe_callhash_lock); - cw->cw_printf(cw, "Current sessions own: "UINT64F"\n", t_hash_table_size(rtpe_callhash) - atomic64_get(&rtpe_stats_gauge.foreign_sessions)); - cw->cw_printf(cw, "Current sessions foreign: "UINT64F"\n", atomic64_get(&rtpe_stats_gauge.foreign_sessions)); + cw->cw_printf(cw, "Current sessions own: "UINT64F"\n", t_hash_table_size(rtpe_callhash) - atomic64_get_na(&rtpe_stats_gauge.foreign_sessions)); + cw->cw_printf(cw, "Current sessions foreign: "UINT64F"\n", atomic64_get_na(&rtpe_stats_gauge.foreign_sessions)); cw->cw_printf(cw, "Current sessions total: %i\n", t_hash_table_size(rtpe_callhash)); rwlock_unlock_r(&rtpe_callhash_lock); - cw->cw_printf(cw, "Current transcoded media: "UINT64F"\n", atomic64_get(&rtpe_stats_gauge.transcoded_media)); + cw->cw_printf(cw, "Current transcoded media: "UINT64F"\n", atomic64_get_na(&rtpe_stats_gauge.transcoded_media)); cw->cw_printf(cw, "Current sessions ipv4 only media: " UINT64F "\n", - atomic64_get(&rtpe_stats_gauge.ipv4_sessions)); + atomic64_get_na(&rtpe_stats_gauge.ipv4_sessions)); cw->cw_printf(cw, "Current sessions ipv6 only media: " UINT64F "\n", - atomic64_get(&rtpe_stats_gauge.ipv6_sessions)); + atomic64_get_na(&rtpe_stats_gauge.ipv6_sessions)); cw->cw_printf(cw, "Current sessions ip mixed media: " UINT64F "\n", - atomic64_get(&rtpe_stats_gauge.mixed_sessions)); + atomic64_get_na(&rtpe_stats_gauge.mixed_sessions)); } static void cli_incoming_list_maxsessions(str *instr, struct cli_writer *cw) { diff --git a/daemon/graphite.c b/daemon/graphite.c index b5d318f61..2440ca4f7 100644 --- a/daemon/graphite.c +++ b/daemon/graphite.c @@ -113,23 +113,23 @@ GString *print_graphite_data(void) { for (int i = 0; i < NGC_COUNT; i++) { GPF("%s_time_min %.6f", ng_command_strings_esc[i], - (double) atomic64_get(&rtpe_sampled_graphite_min_max_sampled.min.ng_command_times[i]) / 1000000.0); + (double) atomic64_get_na(&rtpe_sampled_graphite_min_max_sampled.min.ng_command_times[i]) / 1000000.0); GPF("%s_time_max %.6f", ng_command_strings_esc[i], - (double) atomic64_get(&rtpe_sampled_graphite_min_max_sampled.max.ng_command_times[i]) / 1000000.0); + (double) atomic64_get_na(&rtpe_sampled_graphite_min_max_sampled.max.ng_command_times[i]) / 1000000.0); GPF("%s_time_avg %.6f", ng_command_strings_esc[i], - (double) atomic64_get(&rtpe_sampled_graphite_avg.avg.ng_command_times[i]) / 1000000.0); + (double) atomic64_get_na(&rtpe_sampled_graphite_avg.avg.ng_command_times[i]) / 1000000.0); - GPF("%ss_ps_min " UINT64F, ng_command_strings_esc[i], atomic64_get(&rtpe_rate_graphite_min_max_avg_sampled.min.ng_commands[i])); - GPF("%ss_ps_max " UINT64F, ng_command_strings_esc[i], atomic64_get(&rtpe_rate_graphite_min_max_avg_sampled.max.ng_commands[i])); - GPF("%ss_ps_avg " UINT64F, ng_command_strings_esc[i], atomic64_get(&rtpe_rate_graphite_min_max_avg_sampled.avg.ng_commands[i])); + GPF("%ss_ps_min " UINT64F, ng_command_strings_esc[i], atomic64_get_na(&rtpe_rate_graphite_min_max_avg_sampled.min.ng_commands[i])); + GPF("%ss_ps_max " UINT64F, ng_command_strings_esc[i], atomic64_get_na(&rtpe_rate_graphite_min_max_avg_sampled.max.ng_commands[i])); + GPF("%ss_ps_avg " UINT64F, ng_command_strings_esc[i], atomic64_get_na(&rtpe_rate_graphite_min_max_avg_sampled.avg.ng_commands[i])); ilog(LOG_DEBUG, "Min/Max/Avg %s processing delay: %.6f/%.6f/%.6f sec", ng_command_strings[i], - (double) atomic64_get(&rtpe_sampled_graphite_min_max_sampled.min.ng_command_times[i]) / 1000000.0, - (double) atomic64_get(&rtpe_sampled_graphite_min_max_sampled.max.ng_command_times[i]) / 1000000.0, - (double) atomic64_get(&rtpe_sampled_graphite_avg.avg.ng_command_times[i]) / 1000000.0); + (double) atomic64_get_na(&rtpe_sampled_graphite_min_max_sampled.min.ng_command_times[i]) / 1000000.0, + (double) atomic64_get_na(&rtpe_sampled_graphite_min_max_sampled.max.ng_command_times[i]) / 1000000.0, + (double) atomic64_get_na(&rtpe_sampled_graphite_avg.avg.ng_command_times[i]) / 1000000.0); - GPF("%s_count %" PRIu64, ng_command_strings_esc[i], atomic64_get(&rtpe_stats.ng_commands[i])); + GPF("%s_count %" PRIu64, ng_command_strings_esc[i], atomic64_get_na(&rtpe_stats.ng_commands[i])); } GPF("call_dur %.6f", (double) atomic64_get_na(&rtpe_stats_graphite_diff.total_calls_duration_intv) / 1000000.0); @@ -141,16 +141,16 @@ GString *print_graphite_data(void) { 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_diff.forced_term_sess)); - GPF("managed_sess "UINT64F, atomic64_get(&rtpe_stats.managed_sess)); + GPF("managed_sess "UINT64F, atomic64_get_na(&rtpe_stats.managed_sess)); GPF("managed_sess_min "UINT64F, atomic64_get_na(&rtpe_gauge_graphite_min_max_sampled.min.total_sessions)); GPF("managed_sess_max "UINT64F, atomic64_get_na(&rtpe_gauge_graphite_min_max_sampled.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)); - GPF("current_sessions_mixed "UINT64F, atomic64_get(&rtpe_stats_gauge.mixed_sessions)); + GPF("current_sessions_total "UINT64F, atomic64_get_na(&rtpe_stats_gauge.total_sessions)); + GPF("current_sessions_own "UINT64F, atomic64_get_na(&rtpe_stats_gauge.total_sessions) - atomic64_get_na(&rtpe_stats_gauge.foreign_sessions)); + GPF("current_sessions_foreign "UINT64F, atomic64_get_na(&rtpe_stats_gauge.foreign_sessions)); + GPF("current_transcoded_media "UINT64F, atomic64_get_na(&rtpe_stats_gauge.transcoded_media)); + GPF("current_sessions_ipv4 "UINT64F, atomic64_get_na(&rtpe_stats_gauge.ipv4_sessions)); + GPF("current_sessions_ipv6 "UINT64F, atomic64_get_na(&rtpe_stats_gauge.ipv6_sessions)); + GPF("current_sessions_mixed "UINT64F, atomic64_get_na(&rtpe_stats_gauge.mixed_sessions)); GPF("nopacket_relayed_sess "UINT64F, atomic64_get_na(&rtpe_stats_graphite_diff.nopacket_relayed_sess)); GPF("oneway_stream_sess "UINT64F, atomic64_get_na(&rtpe_stats_graphite_diff.oneway_stream_sess)); GPF("regular_term_sess "UINT64F, atomic64_get_na(&rtpe_stats_graphite_diff.regular_term_sess)); diff --git a/daemon/statistics.c b/daemon/statistics.c index 698176caf..61adbe156 100644 --- a/daemon/statistics.c +++ b/daemon/statistics.c @@ -326,56 +326,56 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i cur_sessions = t_hash_table_size(rtpe_callhash); rwlock_unlock_r(&rtpe_callhash_lock); - METRIC("sessionsown", "Owned sessions", UINT64F, UINT64F, cur_sessions - atomic64_get(&rtpe_stats_gauge.foreign_sessions)); + METRIC("sessionsown", "Owned sessions", UINT64F, UINT64F, cur_sessions - atomic64_get_na(&rtpe_stats_gauge.foreign_sessions)); PROM("sessions", "gauge"); PROMLAB("type=\"own\""); - METRIC("sessionsforeign", "Foreign sessions", UINT64F, UINT64F, atomic64_get(&rtpe_stats_gauge.foreign_sessions)); + METRIC("sessionsforeign", "Foreign sessions", UINT64F, UINT64F, atomic64_get_na(&rtpe_stats_gauge.foreign_sessions)); PROM("sessions", "gauge"); PROMLAB("type=\"foreign\""); METRIC("sessionstotal", "Total sessions", UINT64F, UINT64F, cur_sessions); - METRIC("transcodedmedia", "Transcoded media", UINT64F, UINT64F, atomic64_get(&rtpe_stats_gauge.transcoded_media)); + METRIC("transcodedmedia", "Transcoded media", UINT64F, UINT64F, atomic64_get_na(&rtpe_stats_gauge.transcoded_media)); PROM("transcoded_media", "gauge"); METRIC("packetrate_user", "Packets per second (userspace)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats_rate.packets_user)); + atomic64_get_na(&rtpe_stats_rate.packets_user)); METRIC("byterate_user", "Bytes per second (userspace)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats_rate.bytes_user)); + atomic64_get_na(&rtpe_stats_rate.bytes_user)); METRIC("errorrate_user", "Errors per second (userspace)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats_rate.errors_user)); + atomic64_get_na(&rtpe_stats_rate.errors_user)); METRIC("packetrate_kernel", "Packets per second (kernel)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats_rate.packets_kernel)); + atomic64_get_na(&rtpe_stats_rate.packets_kernel)); METRIC("byterate_kernel", "Bytes per second (kernel)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats_rate.bytes_kernel)); + atomic64_get_na(&rtpe_stats_rate.bytes_kernel)); METRIC("errorrate_kernel", "Errors per second (kernel)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats_rate.errors_kernel)); + atomic64_get_na(&rtpe_stats_rate.errors_kernel)); METRIC("packetrate", "Packets per second (total)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats_rate.packets_user) + - atomic64_get(&rtpe_stats_rate.packets_kernel)); + atomic64_get_na(&rtpe_stats_rate.packets_user) + + atomic64_get_na(&rtpe_stats_rate.packets_kernel)); METRIC("byterate", "Bytes per second (total)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats_rate.bytes_user) + - atomic64_get(&rtpe_stats_rate.bytes_kernel)); + atomic64_get_na(&rtpe_stats_rate.bytes_user) + + atomic64_get_na(&rtpe_stats_rate.bytes_kernel)); METRIC("errorrate", "Errors per second (total)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats_rate.errors_user) + - atomic64_get(&rtpe_stats_rate.errors_kernel)); + atomic64_get_na(&rtpe_stats_rate.errors_user) + + atomic64_get_na(&rtpe_stats_rate.errors_kernel)); METRIC("media_userspace", "Userspace-only media streams", UINT64F, UINT64F, - atomic64_get(&rtpe_stats_gauge.userspace_streams)); + atomic64_get_na(&rtpe_stats_gauge.userspace_streams)); PROM("mediastreams", "gauge"); PROMLAB("type=\"userspace\""); METRIC("media_kernel", "Kernel-only media streams", UINT64F, UINT64F, - atomic64_get(&rtpe_stats_gauge.kernel_only_streams)); + atomic64_get_na(&rtpe_stats_gauge.kernel_only_streams)); PROM("mediastreams", "gauge"); PROMLAB("type=\"kernel\""); METRIC("media_mixed", "Mixed kernel/userspace media streams", UINT64F, UINT64F, - atomic64_get(&rtpe_stats_gauge.kernel_user_streams)); + atomic64_get_na(&rtpe_stats_gauge.kernel_user_streams)); PROM("mediastreams", "gauge"); PROMLAB("type=\"mixed\""); - num_sessions = atomic64_get(&rtpe_stats.managed_sess); - uint64_t total_duration = atomic64_get(&rtpe_stats.call_duration); + num_sessions = atomic64_get_na(&rtpe_stats.managed_sess); + uint64_t total_duration = atomic64_get_na(&rtpe_stats.call_duration); uint64_t avg_us = num_sessions ? total_duration / num_sessions : 0; HEADER("}", ""); @@ -387,67 +387,67 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i METRIC("managedsessions", "Total managed sessions", UINT64F, UINT64F, num_sessions); PROM("sessions_total", "counter"); - METRIC("rejectedsessions", "Total rejected sessions", UINT64F, UINT64F, atomic64_get(&rtpe_stats.rejected_sess)); + METRIC("rejectedsessions", "Total rejected sessions", UINT64F, UINT64F, atomic64_get_na(&rtpe_stats.rejected_sess)); PROM("closed_sessions_total", "counter"); PROMLAB("reason=\"rejected\""); - METRIC("timeoutsessions", "Total timed-out sessions via TIMEOUT", UINT64F, UINT64F, atomic64_get(&rtpe_stats.timeout_sess)); + METRIC("timeoutsessions", "Total timed-out sessions via TIMEOUT", UINT64F, UINT64F, atomic64_get_na(&rtpe_stats.timeout_sess)); PROM("closed_sessions_total", "counter"); PROMLAB("reason=\"timeout\""); - METRIC("silenttimeoutsessions", "Total timed-out sessions via SILENT_TIMEOUT", UINT64F, UINT64F,atomic64_get(&rtpe_stats.silent_timeout_sess)); + METRIC("silenttimeoutsessions", "Total timed-out sessions via SILENT_TIMEOUT", UINT64F, UINT64F,atomic64_get_na(&rtpe_stats.silent_timeout_sess)); PROM("closed_sessions_total", "counter"); PROMLAB("reason=\"silent_timeout\""); - METRIC("finaltimeoutsessions", "Total timed-out sessions via FINAL_TIMEOUT", UINT64F, UINT64F,atomic64_get(&rtpe_stats.final_timeout_sess)); + METRIC("finaltimeoutsessions", "Total timed-out sessions via FINAL_TIMEOUT", UINT64F, UINT64F,atomic64_get_na(&rtpe_stats.final_timeout_sess)); PROM("closed_sessions_total", "counter"); PROMLAB("reason=\"final_timeout\""); - METRIC("offertimeoutsessions", "Total timed-out sessions via OFFER_TIMEOUT", UINT64F, UINT64F,atomic64_get(&rtpe_stats.offer_timeout_sess)); + METRIC("offertimeoutsessions", "Total timed-out sessions via OFFER_TIMEOUT", UINT64F, UINT64F,atomic64_get_na(&rtpe_stats.offer_timeout_sess)); PROM("closed_sessions_total", "counter"); PROMLAB("reason=\"offer_timeout\""); - METRIC("regularterminatedsessions", "Total regular terminated sessions", UINT64F, UINT64F, atomic64_get(&rtpe_stats.regular_term_sess)); + METRIC("regularterminatedsessions", "Total regular terminated sessions", UINT64F, UINT64F, atomic64_get_na(&rtpe_stats.regular_term_sess)); PROM("closed_sessions_total", "counter"); PROMLAB("reason=\"terminated\""); - METRIC("forcedterminatedsessions", "Total forced terminated sessions", UINT64F, UINT64F, atomic64_get(&rtpe_stats.forced_term_sess)); + METRIC("forcedterminatedsessions", "Total forced terminated sessions", UINT64F, UINT64F, atomic64_get_na(&rtpe_stats.forced_term_sess)); PROM("closed_sessions_total", "counter"); PROMLAB("reason=\"force_terminated\""); METRIC("relayedpackets_user", "Total relayed packets (userspace)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.packets_user)); + atomic64_get_na(&rtpe_stats.packets_user)); PROM("packets_total", "counter"); PROMLAB("type=\"userspace\""); METRIC("relayedpacketerrors_user", "Total relayed packet errors (userspace)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.errors_user)); + atomic64_get_na(&rtpe_stats.errors_user)); PROM("packet_errors_total", "counter"); PROMLAB("type=\"userspace\""); METRIC("relayedbytes_user", "Total relayed bytes (userspace)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.bytes_user)); + atomic64_get_na(&rtpe_stats.bytes_user)); PROM("bytes_total", "counter"); PROMLAB("type=\"userspace\""); METRIC("relayedpackets_kernel", "Total relayed packets (kernel)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.packets_kernel)); + atomic64_get_na(&rtpe_stats.packets_kernel)); PROM("packets_total", "counter"); PROMLAB("type=\"kernel\""); METRIC("relayedpacketerrors_kernel", "Total relayed packet errors (kernel)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.errors_kernel)); + atomic64_get_na(&rtpe_stats.errors_kernel)); PROM("packet_errors_total", "counter"); PROMLAB("type=\"kernel\""); METRIC("relayedbytes_kernel", "Total relayed bytes (kernel)", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.bytes_kernel)); + atomic64_get_na(&rtpe_stats.bytes_kernel)); PROM("bytes_total", "counter"); PROMLAB("type=\"kernel\""); METRIC("relayedpackets", "Total relayed packets", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.packets_kernel) + - atomic64_get(&rtpe_stats.packets_user)); + atomic64_get_na(&rtpe_stats.packets_kernel) + + atomic64_get_na(&rtpe_stats.packets_user)); METRIC("relayedpacketerrors", "Total relayed packet errors", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.errors_kernel) + - atomic64_get(&rtpe_stats.errors_user)); + atomic64_get_na(&rtpe_stats.errors_kernel) + + atomic64_get_na(&rtpe_stats.errors_user)); METRIC("relayedbytes", "Total relayed bytes", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.bytes_kernel) + - atomic64_get(&rtpe_stats.bytes_user)); + atomic64_get_na(&rtpe_stats.bytes_kernel) + + atomic64_get_na(&rtpe_stats.bytes_user)); - METRIC("zerowaystreams", "Total number of streams with no relayed packets", UINT64F, UINT64F, atomic64_get(&rtpe_stats.nopacket_relayed_sess)); + METRIC("zerowaystreams", "Total number of streams with no relayed packets", UINT64F, UINT64F, atomic64_get_na(&rtpe_stats.nopacket_relayed_sess)); PROM("zero_packet_streams_total", "counter"); - METRIC("onewaystreams", "Total number of 1-way streams", UINT64F, UINT64F,atomic64_get(&rtpe_stats.oneway_stream_sess)); + METRIC("onewaystreams", "Total number of 1-way streams", UINT64F, UINT64F,atomic64_get_na(&rtpe_stats.oneway_stream_sess)); PROM("one_way_sessions_total", "counter"); METRICva("avgcallduration", "Average call duration", "%.6f", "%.6f seconds", (double) avg_us / 1000000.0); PROM("call_duration_avg", "gauge"); @@ -455,7 +455,7 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i METRICva("totalcallsduration", "Total calls duration", "%.6f", "%.6f seconds", (double) total_duration / 1000000.0); PROM("call_duration_total", "counter"); - total_duration = atomic64_get(&rtpe_stats.call_duration2); + total_duration = atomic64_get_na(&rtpe_stats.call_duration2); METRICva("totalcallsduration2", "Total calls duration squared", "%.6f", "%.6f seconds squared", (double) total_duration / 1000000.0); PROM("call_duration2_total", "counter"); @@ -467,8 +467,8 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i if (graphite_is_enabled()) { calls_dur_iv = (double) atomic64_get_na(&rtpe_stats_graphite_diff.total_calls_duration_intv) / 1000000.0; - min_sess_iv = atomic64_get(&rtpe_gauge_graphite_min_max_sampled.min.total_sessions); - max_sess_iv = atomic64_get(&rtpe_gauge_graphite_min_max_sampled.max.total_sessions); + min_sess_iv = atomic64_get_na(&rtpe_gauge_graphite_min_max_sampled.min.total_sessions); + max_sess_iv = atomic64_get_na(&rtpe_gauge_graphite_min_max_sampled.max.total_sessions); HEADER("intervalstatistics", "Graphite interval statistics (last reported values to graphite):"); HEADER("{", NULL); @@ -480,9 +480,9 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i METRIC("maxmanagedsessions", "Max managed sessions", UINT64F, UINT64F, max_sess_iv); for (int i = 0; i < NGC_COUNT; i++) { - double min = (double) atomic64_get(&rtpe_sampled_graphite_min_max_sampled.min.ng_command_times[i]) / 1000000.0; - double max = (double) atomic64_get(&rtpe_sampled_graphite_min_max_sampled.max.ng_command_times[i]) / 1000000.0; - double avg = (double) atomic64_get(&rtpe_sampled_graphite_avg.avg.ng_command_times[i]) / 1000000.0; + double min = (double) atomic64_get_na(&rtpe_sampled_graphite_min_max_sampled.min.ng_command_times[i]) / 1000000.0; + double max = (double) atomic64_get_na(&rtpe_sampled_graphite_min_max_sampled.max.ng_command_times[i]) / 1000000.0; + double avg = (double) atomic64_get_na(&rtpe_sampled_graphite_avg.avg.ng_command_times[i]) / 1000000.0; g_autoptr(char) min_label = g_strdup_printf("min%sdelay", ng_command_strings[i]); g_autoptr(char) max_label = g_strdup_printf("max%sdelay", ng_command_strings[i]); g_autoptr(char) avg_label = g_strdup_printf("avg%sdelay", ng_command_strings[i]); @@ -494,9 +494,9 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i } for (int i = 0; i < NGC_COUNT; i++) { - uint64_t min = atomic64_get(&rtpe_rate_graphite_min_max_avg_sampled.min.ng_commands[i]); - uint64_t max = atomic64_get(&rtpe_rate_graphite_min_max_avg_sampled.max.ng_commands[i]); - uint64_t avg = atomic64_get(&rtpe_rate_graphite_min_max_avg_sampled.avg.ng_commands[i]); + uint64_t min = atomic64_get_na(&rtpe_rate_graphite_min_max_avg_sampled.min.ng_commands[i]); + uint64_t max = atomic64_get_na(&rtpe_rate_graphite_min_max_avg_sampled.max.ng_commands[i]); + uint64_t avg = atomic64_get_na(&rtpe_rate_graphite_min_max_avg_sampled.avg.ng_commands[i]); g_autoptr(char) min_label = g_strdup_printf("min%srequestrate", ng_command_strings[i]); g_autoptr(char) max_label = g_strdup_printf("max%srequestrate", ng_command_strings[i]); g_autoptr(char) avg_label = g_strdup_printf("avg%srequestrate", ng_command_strings[i]); @@ -516,21 +516,21 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i #define STAT_GET_PRINT_GEN(source, avgs, stat_name, name, divisor, prefix, label...) \ METRIC(#stat_name "_total", "Sum of all " name " values sampled", "%.6f", "%.6f", \ - (double) atomic64_get(&(source)->sums.stat_name) / (divisor)); \ + (double) atomic64_get_na(&(source)->sums.stat_name) / (divisor)); \ PROM(prefix #stat_name "_total", "counter"); \ PROMLAB(label); \ METRIC(#stat_name "2_total", "Sum of all " name " square values sampled", "%.6f", "%.6f", \ - (double) atomic64_get(&(source)->sums_squared.stat_name) / (divisor * divisor)); \ + (double) atomic64_get_na(&(source)->sums_squared.stat_name) / (divisor * divisor)); \ PROM(prefix #stat_name "2_total", "counter"); \ PROMLAB(label); \ METRIC(#stat_name "_samples_total", "Total number of " name " samples", UINT64F, UINT64F, \ - atomic64_get(&(source)->counts.stat_name)); \ + atomic64_get_na(&(source)->counts.stat_name)); \ PROM(prefix #stat_name "_samples_total", "counter"); \ PROMLAB(label); \ METRIC(#stat_name "_average", "Average " name, "%.6f", "%.6f", \ - (double) atomic64_get(&(avgs)->avg.stat_name) / (divisor)); \ + (double) atomic64_get_na(&(avgs)->avg.stat_name) / (divisor)); \ METRIC(#stat_name "_stddev", name " standard deviation", "%.6f", "%.6f", \ - (double) atomic64_get(&(avgs)->stddev.stat_name) / (divisor * divisor)); + (double) atomic64_get_na(&(avgs)->stddev.stat_name) / (divisor * divisor)); #define STAT_GET_PRINT(stat_name, name, divisor) \ STAT_GET_PRINT_GEN(&rtpe_stats_sampled, &sampled_avgs, stat_name, name, divisor, "", NULL) @@ -549,19 +549,19 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i STAT_GET_PRINT(packetloss, "packet loss", 1.0); STAT_GET_PRINT(jitter_measured, "jitter (measured)", 1.0); METRIC("packets_lost", "Packets lost", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.packets_lost)); + atomic64_get_na(&rtpe_stats.packets_lost)); PROM("packets_lost", "counter"); METRIC("rtp_duplicates", "Duplicate RTP packets", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.rtp_duplicates)); + atomic64_get_na(&rtpe_stats.rtp_duplicates)); PROM("rtp_duplicates", "counter"); METRIC("rtp_skips", "RTP sequence skips", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.rtp_skips)); + atomic64_get_na(&rtpe_stats.rtp_skips)); PROM("rtp_skips", "counter"); METRIC("rtp_seq_resets", "RTP sequence resets", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.rtp_seq_resets)); + atomic64_get_na(&rtpe_stats.rtp_seq_resets)); PROM("rtp_seq_resets", "counter"); METRIC("rtp_reordered", "Out-of-order RTP packets", UINT64F, UINT64F, - atomic64_get(&rtpe_stats.rtp_reordered)); + atomic64_get_na(&rtpe_stats.rtp_reordered)); PROM("rtp_reordered", "counter"); HEADER(NULL, ""); HEADER("}", ""); @@ -703,7 +703,7 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i struct interface_counter_stats diff; interface_counter_calc_diff(&lif->stats->s, &intv_stats->s, &diff); -#define F(f) METRICs(#f, UINT64F, atomic64_get(&diff.f)); +#define F(f) METRICs(#f, UINT64F, atomic64_get_na(&diff.f)); #include "interface_counter_stats_fields.inc" #undef F @@ -716,7 +716,7 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i struct interface_counter_stats rate; interface_counter_calc_rate_from_diff(time_diff_us, &diff, &rate); -#define F(f) METRICs(#f, UINT64F, atomic64_get(&rate.f)); +#define F(f) METRICs(#f, UINT64F, atomic64_get_na(&rate.f)); #include "interface_counter_stats_fields.inc" #undef F @@ -765,29 +765,29 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i interface_sampled_avg(&avg, &diff); METRIC("mos", "Average interval MOS", "%.6f", "%.6f", \ - (double) atomic64_get(&avg.avg.mos) / 10.0); \ + (double) atomic64_get_na(&avg.avg.mos) / 10.0); \ METRIC("mos_stddev", "Standard deviation interval MOS", "%.6f", "%.6f", \ - (double) atomic64_get(&avg.stddev.mos) / 100.0); \ + (double) atomic64_get_na(&avg.stddev.mos) / 100.0); \ METRIC("jitter", "Average interval jitter (reported)", "%.6f", "%.6f", \ - (double) atomic64_get(&avg.avg.jitter)); \ + (double) atomic64_get_na(&avg.avg.jitter)); \ METRIC("jitter_stddev", "Standard deviation interval jitter (reported)", "%.6f", "%.6f", \ - (double) atomic64_get(&avg.stddev.jitter)); \ + (double) atomic64_get_na(&avg.stddev.jitter)); \ METRIC("rtt_e2e", "Average interval end-to-end round-trip time", "%.6f", "%.6f", \ - (double) atomic64_get(&avg.avg.rtt_e2e)); \ + (double) atomic64_get_na(&avg.avg.rtt_e2e)); \ METRIC("rtt_e2e_stddev", "Standard deviation interval end-to-end round-trip time", "%.6f", "%.6f", \ - (double) atomic64_get(&avg.stddev.rtt_e2e)); \ + (double) atomic64_get_na(&avg.stddev.rtt_e2e)); \ METRIC("rtt_dsct", "Average interval discrete round-trip time", "%.6f", "%.6f", \ - (double) atomic64_get(&avg.avg.rtt_dsct)); \ + (double) atomic64_get_na(&avg.avg.rtt_dsct)); \ METRIC("rtt_dsct_stddev", "Standard deviation interval discrete round-trip time", "%.6f", "%.6f", \ - (double) atomic64_get(&avg.stddev.rtt_dsct)); \ + (double) atomic64_get_na(&avg.stddev.rtt_dsct)); \ METRIC("packetloss", "Average interval packet loss", "%.6f", "%.6f", \ - (double) atomic64_get(&avg.avg.packetloss)); \ + (double) atomic64_get_na(&avg.avg.packetloss)); \ METRIC("packetloss_stddev", "Standard deviation interval packet loss", "%.6f", "%.6f", \ - (double) atomic64_get(&avg.stddev.packetloss)); \ + (double) atomic64_get_na(&avg.stddev.packetloss)); \ METRIC("jitter_measured", "Average interval jitter (measured)", "%.6f", "%.6f", \ - (double) atomic64_get(&avg.avg.jitter_measured)); \ + (double) atomic64_get_na(&avg.avg.jitter_measured)); \ METRIC("jitter_measured_stddev", "Standard deviation interval jitter (measured)", "%.6f", "%.6f", \ - (double) atomic64_get(&avg.stddev.jitter_measured)); \ + (double) atomic64_get_na(&avg.stddev.jitter_measured)); \ HEADER("}", NULL); } @@ -821,7 +821,7 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i struct interface_counter_stats_dir diff_in; interface_counter_calc_diff_dir(&lif->stats->in, &intv_stats->in, &diff_in); -#define F(f) METRICs(#f, UINT64F, atomic64_get(&diff_in.f)); +#define F(f) METRICs(#f, UINT64F, atomic64_get_na(&diff_in.f)); #include "interface_counter_stats_fields_dir.inc" #undef F @@ -833,7 +833,7 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i struct interface_counter_stats_dir diff_out; interface_counter_calc_diff_dir(&lif->stats->out, &intv_stats->out, &diff_out); -#define F(f) METRICs(#f, UINT64F, atomic64_get(&diff_out.f)); +#define F(f) METRICs(#f, UINT64F, atomic64_get_na(&diff_out.f)); #include "interface_counter_stats_fields_dir.inc" #undef F @@ -847,7 +847,7 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i interface_counter_calc_rate_from_diff_dir(time_diff_us, &diff_in, &rate); -#define F(f) METRICs(#f, UINT64F, atomic64_get(&rate.f)); +#define F(f) METRICs(#f, UINT64F, atomic64_get_na(&rate.f)); #include "interface_counter_stats_fields_dir.inc" #undef F @@ -859,7 +859,7 @@ stats_metric_q *statistics_gather_metrics(struct interface_sampled_rate_stats *i interface_counter_calc_rate_from_diff_dir(time_diff_us, &diff_out, &rate); -#define F(f) METRICs(#f, UINT64F, atomic64_get(&rate.f)); +#define F(f) METRICs(#f, UINT64F, atomic64_get_na(&rate.f)); #include "interface_counter_stats_fields_dir.inc" #undef F diff --git a/include/statistics.h b/include/statistics.h index 8c8051707..315345ab4 100644 --- a/include/statistics.h +++ b/include/statistics.h @@ -125,14 +125,14 @@ extern struct global_gauge_min_max rtpe_gauge_min_max; // master lifetime min/ } while (0) #define RTPE_GAUGE_SET(field, num) \ do { \ - atomic64_set(&rtpe_stats_gauge.field, num); \ + atomic64_set_na(&rtpe_stats_gauge.field, num); \ RTPE_GAUGE_SET_MIN_MAX(field, rtpe_gauge_min_max, num); \ if (graphite_is_enabled()) \ RTPE_GAUGE_SET_MIN_MAX(field, rtpe_gauge_graphite_min_max, num); \ } while (0) #define RTPE_GAUGE_ADD(field, num) \ do { \ - uint64_t __old = atomic64_add(&rtpe_stats_gauge.field, num); \ + uint64_t __old = atomic64_add_na(&rtpe_stats_gauge.field, num); \ RTPE_GAUGE_SET_MIN_MAX(field, rtpe_gauge_min_max, __old + num); \ if (graphite_is_enabled()) \ RTPE_GAUGE_SET_MIN_MAX(field, rtpe_gauge_graphite_min_max, __old + num); \ @@ -158,9 +158,9 @@ extern struct global_sampled_min_max rtpe_sampled_min_max; // master lifetime m RTPE_STATS_SAMPLE(field, num); \ if (sfd) { \ struct local_intf *__intf = sfd->local_intf; \ - atomic64_add(&__intf->stats->sampled.sums.field, num); \ - atomic64_add(&__intf->stats->sampled.sums_squared.field, num * num); \ - atomic64_inc(&__intf->stats->sampled.counts.field); \ + atomic64_add_na(&__intf->stats->sampled.sums.field, num); \ + atomic64_add_na(&__intf->stats->sampled.sums_squared.field, num * num); \ + atomic64_inc_na(&__intf->stats->sampled.counts.field); \ } \ } while (0) @@ -168,7 +168,7 @@ extern struct global_stats_counter rtpe_stats; // total, cumulative, master extern struct global_stats_counter rtpe_stats_rate; // per-second, calculated once per timer run extern struct global_stats_counter rtpe_stats_intv; // per-second, calculated once per timer run -#define RTPE_STATS_ADD(field, num) atomic64_add(&rtpe_stats.field, num) +#define RTPE_STATS_ADD(field, num) atomic64_add_na(&rtpe_stats.field, num) #define RTPE_STATS_INC(field) RTPE_STATS_ADD(field, 1) diff --git a/lib/auxlib.h b/lib/auxlib.h index 4dc366112..04a09adb3 100644 --- a/lib/auxlib.h +++ b/lib/auxlib.h @@ -543,7 +543,7 @@ INLINE void atomic64_local_copy_zero(atomic64 *dst, atomic64 *src) { INLINE void atomic64_min(atomic64 *min, uint64_t val) { do { - uint64_t old = atomic64_get(min); + uint64_t old = atomic64_get_na(min); if (old && old <= val) break; if (atomic64_set_if(min, val, old)) @@ -552,7 +552,7 @@ INLINE void atomic64_min(atomic64 *min, uint64_t val) { } INLINE void atomic64_max(atomic64 *max, uint64_t val) { do { - uint64_t old = atomic64_get(max); + uint64_t old = atomic64_get_na(max); if (old && old >= val) break; if (atomic64_set_if(max, val, old)) @@ -561,33 +561,33 @@ INLINE void atomic64_max(atomic64 *max, uint64_t val) { } INLINE void atomic64_calc_rate_from_diff(long long run_diff_us, uint64_t diff, atomic64 *rate_var) { - atomic64_set(rate_var, run_diff_us ? diff * 1000000LL / run_diff_us : 0); + atomic64_set_na(rate_var, run_diff_us ? diff * 1000000LL / run_diff_us : 0); } INLINE void atomic64_calc_rate(const atomic64 *ax_var, long long run_diff_us, atomic64 *intv_var, atomic64 *rate_var) { - uint64_t ax = atomic64_get(ax_var); - uint64_t old_intv = atomic64_get(intv_var); - atomic64_set(intv_var, ax); + uint64_t ax = atomic64_get_na(ax_var); + uint64_t old_intv = atomic64_get_na(intv_var); + atomic64_set_na(intv_var, ax); atomic64_calc_rate_from_diff(run_diff_us, ax - old_intv, rate_var); } INLINE void atomic64_calc_diff(const atomic64 *ax_var, atomic64 *intv_var, atomic64 *diff_var) { - uint64_t ax = atomic64_get(ax_var); - uint64_t old_intv = atomic64_get(intv_var); - atomic64_set(intv_var, ax); - atomic64_set(diff_var, ax - old_intv); + uint64_t ax = atomic64_get_na(ax_var); + uint64_t old_intv = atomic64_get_na(intv_var); + atomic64_set_na(intv_var, ax); + atomic64_set_na(diff_var, ax - old_intv); } INLINE void atomic64_mina(atomic64 *min, atomic64 *inp) { - atomic64_min(min, atomic64_get(inp)); + atomic64_min(min, atomic64_get_na(inp)); } INLINE void atomic64_maxa(atomic64 *max, atomic64 *inp) { - atomic64_max(max, atomic64_get(inp)); + atomic64_max(max, atomic64_get_na(inp)); } INLINE double atomic64_div(const atomic64 *n, const atomic64 *d) { - int64_t dd = atomic64_get(d); + int64_t dd = atomic64_get_na(d); if (!dd) return 0.; - return (double) atomic64_get(n) / (double) dd; + return (double) atomic64_get_na(n) / (double) dd; } #define atomic_get_na(x) __atomic_load_n(x, __ATOMIC_RELAXED)