From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- .../test/bwe_test_logging.h | 360 +++++++++++++++++++++ 1 file changed, 360 insertions(+) create mode 100644 third_party/libwebrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h (limited to 'third_party/libwebrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h') diff --git a/third_party/libwebrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h b/third_party/libwebrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h new file mode 100644 index 0000000000..49e1e716b2 --- /dev/null +++ b/third_party/libwebrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h @@ -0,0 +1,360 @@ +/* + * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_TEST_LOGGING_H_ +#define MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_TEST_LOGGING_H_ + +// To enable BWE logging, run this command from trunk/ : +// build/gyp_chromium --depth=. webrtc/modules/modules.gyp +// -Denable_bwe_test_logging=1 +#ifndef BWE_TEST_LOGGING_COMPILE_TIME_ENABLE +#define BWE_TEST_LOGGING_COMPILE_TIME_ENABLE 0 +#endif // BWE_TEST_LOGGING_COMPILE_TIME_ENABLE + +// BWE logging allows you to insert dynamically named log/plot points in the +// call tree. E.g. the function: +// void f1() { +// BWE_TEST_LOGGING_TIME(clock_->TimeInMilliseconds()); +// BWE_TEST_LOGGING_CONTEXT("stream"); +// for (uint32_t i=0; i<4; ++i) { +// BWE_TEST_LOGGING_ENABLE(i & 1); +// BWE_TEST_LOGGING_CONTEXT(i); +// BWE_TEST_LOGGING_LOG1("weight", "%f tonnes", weights_[i]); +// for (float j=0.0f; j<1.0; j+=0.4f) { +// BWE_TEST_LOGGING_PLOT(0, "bps", -1, j); +// } +// } +// } +// +// Might produce the output: +// stream_00000001_weight 13.000000 tonnes +// PLOT stream_00000001_bps 1.000000 0.000000 +// PLOT stream_00000001_bps 1.000000 0.400000 +// PLOT stream_00000001_bps 1.000000 0.800000 +// stream_00000003_weight 39.000000 tonnes +// PLOT stream_00000003_bps 1.000000 0.000000 +// PLOT stream_00000003_bps 1.000000 0.400000 +// PLOT stream_00000003_bps 1.000000 0.800000 +// +// Log *contexts* are names concatenated with '_' between them, with the name +// of the logged/plotted string/value last. Plot *time* is inherited down the +// tree. A branch is enabled by default but can be *disabled* to reduce output. +// The difference between the RTC_LOG and PLOT macros is that PLOT prefixes the +// line so it can be easily filtered, plus it outputs the current time. + +#if !(BWE_TEST_LOGGING_COMPILE_TIME_ENABLE) + +// Set a thread-global base logging context. This name will be prepended to all +// hierarchical contexts. +// `name` is a char*, std::string or uint32_t to name the context. +#define BWE_TEST_LOGGING_GLOBAL_CONTEXT(name) + +// Thread-globally allow/disallow logging. +// `enable` is expected to be a bool. +#define BWE_TEST_LOGGING_GLOBAL_ENABLE(enabled) + +// Insert a (hierarchical) logging context. +// `name` is a char*, std::string or uint32_t to name the context. +#define BWE_TEST_LOGGING_CONTEXT(name) + +// Allow/disallow logging down the call tree from this point. Logging must be +// enabled all the way to the root of the call tree to take place. +// `enable` is expected to be a bool. +#define BWE_TEST_LOGGING_ENABLE(enabled) + +// Set current time (only affects PLOT output). Down the call tree, the latest +// time set always takes precedence. +// `time` is an int64_t time in ms, or -1 to inherit time from previous context. +#define BWE_TEST_LOGGING_TIME(time) + +// Print to stdout, e.g.: +// Context1_Context2_Name printf-formated-string +// `name` is a char*, std::string or uint32_t to name the log line. +// `format` is a printf format string. +// |_1...| are arguments for printf. +#define BWE_TEST_LOGGING_LOG1(name, format, _1) +#define BWE_TEST_LOGGING_LOG2(name, format, _1, _2) +#define BWE_TEST_LOGGING_LOG3(name, format, _1, _2, _3) +#define BWE_TEST_LOGGING_LOG4(name, format, _1, _2, _3, _4) +#define BWE_TEST_LOGGING_LOG5(name, format, _1, _2, _3, _4, _5) + +// Print to stdout in tab-separated format suitable for plotting, e.g.: +// PLOT figure Context1_Context2_Name time value +// `figure` is a figure id. Different figures are plotted in different windows. +// `name` is a char*, std::string or uint32_t to name the plotted value. +// `time` is an int64_t time in ms, or -1 to inherit time from previous context. +// `value` is a double precision float to be plotted. +// `ssrc` identifies the source of a stream +// `alg_name` is an optional argument, a string +#define BWE_TEST_LOGGING_PLOT(figure, name, time, value) +#define BWE_TEST_LOGGING_PLOT_WITH_NAME(figure, name, time, value, alg_name) +#define BWE_TEST_LOGGING_PLOT_WITH_SSRC(figure, name, time, value, ssrc) +#define BWE_TEST_LOGGING_PLOT_WITH_NAME_AND_SSRC(figure, name, time, value, \ + ssrc, alg_name) + +// Print to stdout in tab-separated format suitable for plotting, e.g.: +// BAR figure Context1_Context2_Name x_left width value +// `figure` is a figure id. Different figures are plotted in different windows. +// `name` is a char*, std::string or uint32_t to name the plotted value. +// `value` is a double precision float to be plotted. +// `ylow` and `yhigh` are double precision float for the error line. +// `title` is a string and refers to the error label. +// `ymax` is a double precision float for the limit horizontal line. +// `limit_title` is a string and refers to the limit label. +#define BWE_TEST_LOGGING_BAR(figure, name, value, flow_id) +#define BWE_TEST_LOGGING_ERRORBAR(figure, name, value, ylow, yhigh, \ + error_title, flow_id) +#define BWE_TEST_LOGGING_LIMITERRORBAR( \ + figure, name, value, ylow, yhigh, error_title, ymax, limit_title, flow_id) + +#define BWE_TEST_LOGGING_BASELINEBAR(figure, name, value, flow_id) + +// `num_flows` is an integer refering to the number of RMCAT flows in the +// scenario. +// Define `x_label` and `y_label` for plots. +#define BWE_TEST_LOGGING_LABEL(figure, x_label, y_label, num_flows) + +#else // BWE_TEST_LOGGING_COMPILE_TIME_ENABLE + +#include +#include +#include +#include + +#include "rtc_base/synchronization/mutex.h" + +#define BWE_TEST_LOGGING_GLOBAL_CONTEXT(name) \ + do { \ + webrtc::testing::bwe::Logging::GetInstance()->SetGlobalContext(name); \ + } while (0) + +#define BWE_TEST_LOGGING_GLOBAL_ENABLE(enabled) \ + do { \ + webrtc::testing::bwe::Logging::GetInstance()->SetGlobalEnable(enabled); \ + } while (0) + +#define __BWE_TEST_LOGGING_CONTEXT_NAME(ctx, line) ctx##line +#define __BWE_TEST_LOGGING_CONTEXT_DECLARE(ctx, line, name, time, enabled) \ + webrtc::testing::bwe::Logging::Context __BWE_TEST_LOGGING_CONTEXT_NAME( \ + ctx, line)(name, time, enabled) + +#define BWE_TEST_LOGGING_CONTEXT(name) \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __LINE__, name, -1, true) +#define BWE_TEST_LOGGING_ENABLE(enabled) \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __LINE__, "", -1, \ + static_cast(enabled)) +#define BWE_TEST_LOGGING_TIME(time) \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __LINE__, "", \ + static_cast(time), true) + +#define BWE_TEST_LOGGING_LOG1(name, format, _1) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->Log(format, _1); \ + } while (0) +#define BWE_TEST_LOGGING_LOG2(name, format, _1, _2) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->Log(format, _1, _2); \ + } while (0) +#define BWE_TEST_LOGGING_LOG3(name, format, _1, _2, _3) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->Log(format, _1, _2, _3); \ + } while (0) +#define BWE_TEST_LOGGING_LOG4(name, format, _1, _2, _3, _4) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->Log(format, _1, _2, _3, _4); \ + } while (0) +#define BWE_TEST_LOGGING_LOG5(name, format, _1, _2, _3, _4, _5) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->Log(format, _1, _2, _3, _4, \ + _5); \ + } while (0) + +#define BWE_TEST_LOGGING_PLOT(figure, name, time, value) \ + do { \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __PLOT__, name, \ + static_cast(time), true); \ + webrtc::testing::bwe::Logging::GetInstance()->Plot(figure, name, value); \ + } while (0) + +#define BWE_TEST_LOGGING_PLOT_WITH_NAME(figure, name, time, value, alg_name) \ + do { \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __PLOT__, name, \ + static_cast(time), true); \ + webrtc::testing::bwe::Logging::GetInstance()->Plot(figure, name, value, \ + alg_name); \ + } while (0) + +#define BWE_TEST_LOGGING_PLOT_WITH_SSRC(figure, name, time, value, ssrc) \ + do { \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __PLOT__, name, \ + static_cast(time), true); \ + webrtc::testing::bwe::Logging::GetInstance()->Plot(figure, name, value, \ + ssrc); \ + } while (0) + +#define BWE_TEST_LOGGING_PLOT_WITH_NAME_AND_SSRC(figure, name, time, value, \ + ssrc, alg_name) \ + do { \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __PLOT__, name, \ + static_cast(time), true); \ + webrtc::testing::bwe::Logging::GetInstance()->Plot(figure, name, value, \ + ssrc, alg_name); \ + } while (0) + +#define BWE_TEST_LOGGING_BAR(figure, name, value, flow_id) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->PlotBar(figure, name, value, \ + flow_id); \ + } while (0) + +#define BWE_TEST_LOGGING_BASELINEBAR(figure, name, value, flow_id) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->PlotBaselineBar( \ + figure, name, value, flow_id); \ + } while (0) + +#define BWE_TEST_LOGGING_ERRORBAR(figure, name, value, ylow, yhigh, title, \ + flow_id) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->PlotErrorBar( \ + figure, name, value, ylow, yhigh, title, flow_id); \ + } while (0) + +#define BWE_TEST_LOGGING_LIMITERRORBAR( \ + figure, name, value, ylow, yhigh, error_title, ymax, limit_title, flow_id) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->PlotLimitErrorBar( \ + figure, name, value, ylow, yhigh, error_title, ymax, limit_title, \ + flow_id); \ + } while (0) + +#define BWE_TEST_LOGGING_LABEL(figure, title, y_label, num_flows) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(title); \ + webrtc::testing::bwe::Logging::GetInstance()->PlotLabel( \ + figure, title, y_label, num_flows); \ + } while (0) + +namespace webrtc { +namespace testing { +namespace bwe { + +class Logging { + public: + class Context { + public: + Context(uint32_t name, int64_t timestamp_ms, bool enabled); + Context(const std::string& name, int64_t timestamp_ms, bool enabled); + Context(const char* name, int64_t timestamp_ms, bool enabled); + + Context() = delete; + Context(const Context&) = delete; + Context& operator=(const Context&) = delete; + ~Context(); + }; + + static Logging* GetInstance(); + + void SetGlobalContext(uint32_t name); + void SetGlobalContext(const std::string& name); + void SetGlobalContext(const char* name); + void SetGlobalEnable(bool enabled); + +#if defined(__GNUC__) + // Note: Implicit `this` argument counts as the first argument. + __attribute__((__format__(__printf__, 2, 3))) +#endif + void + Log(const char format[], ...); + void Plot(int figure, const std::string& name, double value); + void Plot(int figure, + const std::string& name, + double value, + const std::string& alg_name); + void Plot(int figure, const std::string& name, double value, uint32_t ssrc); + void Plot(int figure, + const std::string& name, + double value, + uint32_t ssrc, + const std::string& alg_name); + void PlotBar(int figure, const std::string& name, double value, int flow_id); + void PlotBaselineBar(int figure, + const std::string& name, + double value, + int flow_id); + void PlotErrorBar(int figure, + const std::string& name, + double value, + double ylow, + double yhigh, + const std::string& error_title, + int flow_id); + + void PlotLimitErrorBar(int figure, + const std::string& name, + double value, + double ylow, + double yhigh, + const std::string& error_title, + double ymax, + const std::string& limit_title, + int flow_id); + void PlotLabel(int figure, + const std::string& title, + const std::string& y_label, + int num_flows); + + private: + struct State { + State(); + State(const std::string& new_tag, int64_t timestamp_ms, bool enabled); + void MergePrevious(const State& previous); + + std::string tag; + int64_t timestamp_ms; + bool enabled; + }; + struct ThreadState { + ThreadState(); + ~ThreadState(); + State global_state; + std::stack stack; + }; + typedef std::map ThreadMap; + + Logging(); + ~Logging(); + + Logging(const Logging&) = delete; + Logging& operator=(const Logging&) = delete; + + void PushState(const std::string& append_to_tag, + int64_t timestamp_ms, + bool enabled); + void PopState(); + + Mutex mutex_; + ThreadMap thread_map_; +}; +} // namespace bwe +} // namespace testing +} // namespace webrtc + +#endif // BWE_TEST_LOGGING_COMPILE_TIME_ENABLE +#endif // MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_TEST_LOGGING_H_ -- cgit v1.2.3