MT#55283 use relaxed memory order for stats

No need for memory barriers here

Change-Id: I9ac6768bb1929be3aa982b0de73c95baa965bef7

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

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));

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
 

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)
 
 

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)