Skip to content

A
abseil-cpp
Commit 7b6c17e3 by Derek Mauro Committed by Copybara-Service
Options

Add VLOG and friends 

These are methods for configurable verbose logging

PiperOrigin-RevId: 588059727
Change-Id: Ib3703edd2493050a5da8b30e88b21adc643b1f7f
parent a39d71a8
Showing with 937 additions and 1 deletions
CMake/AbseilDll.cmake
......@@ -191,6 +191,9 @@ set(ABSL_INTERNAL_DLL_FILES
"log/log_sink_registry.h"
"log/log_streamer.h"
"log/structured.h"
"log/vlog_config.cc"
"log/vlog_config.h"
"log/vlog_is_on.h"
"memory/memory.h"
"meta/type_traits.h"
"numeric/bits.h"
......
absl/log/BUILD.bazel
......@@ -50,6 +50,7 @@ cc_library(
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
deps = [
":vlog_is_on",
"//absl/log/internal:log_impl",
],
)
......@@ -91,6 +92,7 @@ cc_library(
visibility = ["//visibility:public"],
deps = [
":globals",
":vlog_config",
"//absl/base:config",
"//absl/base:core_headers",
"//absl/base:log_severity",
......@@ -143,6 +145,7 @@ cc_library(
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
deps = [
":vlog_is_on",
"//absl/log/internal:log_impl",
],
)
......@@ -235,6 +238,86 @@ cc_library(
],
)
cc_library(
name = "vlog_config",
srcs = ["vlog_config.cc"],
hdrs = ["vlog_config.h"],
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
visibility = ["//visibility:private"],
deps = [
"//absl/base",
"//absl/base:config",
"//absl/base:core_headers",
"//absl/log/internal:fnmatch",
"//absl/memory",
"//absl/strings",
"//absl/synchronization",
"//absl/types:optional",
],
)
cc_library(
name = "vlog_is_on",
hdrs = ["vlog_is_on.h"],
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
visibility = [
"//absl/log:__subpackages__",
],
deps = [
":vlog_config",
"//absl/base:config",
"//absl/base:core_headers",
"//absl/strings",
],
)
# TODO(b/200695798): run this in TAP projects with -DABSL_MAX_VLOG_VERBOSITY={-100,100}
cc_test(
name = "vlog_is_on_test",
size = "small",
srcs = [
"vlog_is_on_test.cc",
],
copts = ABSL_TEST_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
deps = [
":flags",
":log",
":scoped_mock_log",
":vlog_is_on",
"//absl/base:log_severity",
"//absl/flags:flag",
"//absl/types:optional",
"@com_google_googletest//:gtest",
"@com_google_googletest//:gtest_main",
],
)
cc_test(
name = "vlog_config_benchmark",
size = "medium",
srcs = ["vlog_config_benchmark.cc"],
copts = ABSL_TEST_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
tags = [
"benchmark",
"no_test_loonix",
"notsan",
],
deps = [
":vlog_config",
"//absl/base:config",
"//absl/base:core_headers",
"//absl/container:layout",
"//absl/memory",
"//absl/random:distributions",
"//absl/strings",
"@com_github_google_benchmark//:benchmark_main",
],
)
# Test targets
cc_test(
......
absl/log/CMakeLists.txt
......@@ -157,6 +157,7 @@ absl_cc_library(
absl::log_internal_conditions
absl::log_internal_message
absl::log_internal_strip
absl::vlog_is_on
)
absl_cc_library(
......@@ -418,6 +419,7 @@ absl_cc_library(
${ABSL_DEFAULT_LINKOPTS}
DEPS
absl::log_internal_log_impl
absl::vlog_is_on
PUBLIC
)
......@@ -481,6 +483,7 @@ absl_cc_library(
absl::flags
absl::flags_marshalling
absl::strings
absl::vlog_config_internal
PUBLIC
)
......@@ -536,6 +539,7 @@ absl_cc_library(
${ABSL_DEFAULT_LINKOPTS}
DEPS
absl::log_internal_log_impl
absl::vlog_is_on
PUBLIC
)
......@@ -674,6 +678,65 @@ absl_cc_library(
absl_cc_library(
NAME
vlog_config_internal
SRCS
"vlog_config.cc"
HDRS
"vlog_config.h"
COPTS
${ABSL_DEFAULT_COPTS}
LINKOPTS
${ABSL_DEFAULT_LINKOPTS}
DEPS
absl::base
absl::config
absl::core_headers
absl::log_internal_fnmatch
absl::memory
absl::strings
absl::synchronization
absl::optional
)
absl_cc_library(
NAME
vlog_is_on
COPTS
${ABSL_DEFAULT_COPTS}
LINKOPTS
${ABSL_DEFAULT_LINKOPTS}
HDRS
"vlog_is_on.h"
DEPS
absl::vlog_config_internal
absl::config
absl::core_headers
absl::strings
)
absl_cc_test(
NAME
vlog_is_on_test
SRCS
"vlog_is_on_test.cc"
COPTS
${ABSL_TEST_COPTS}
LINKOPTS
${ABSL_DEFAULT_LINKOPTS}
DEPS
absl::log_flags
absl::log
absl::scoped_mock_log
absl::vlog_is_on
absl::log_severity
absl::flags
absl::optional
GTest::gmock_main
)
absl_cc_library(
NAME
log_internal_fnmatch
SRCS
"internal/fnmatch.cc"
......
absl/log/absl_log.h
......@@ -39,6 +39,9 @@
#define ABSL_PLOG(severity) ABSL_LOG_INTERNAL_PLOG_IMPL(_##severity)
#define ABSL_DLOG(severity) ABSL_LOG_INTERNAL_DLOG_IMPL(_##severity)
#define ABSL_VLOG(verbose_level) ABSL_LOG_INTERNAL_VLOG_IMPL(verbose_level)
#define ABSL_DVLOG(verbose_level) ABSL_LOG_INTERNAL_DVLOG_IMPL(verbose_level)
#define ABSL_LOG_IF(severity, condition) \
ABSL_LOG_INTERNAL_LOG_IF_IMPL(_##severity, condition)
#define ABSL_PLOG_IF(severity, condition) \
......@@ -73,6 +76,15 @@
#define ABSL_DLOG_EVERY_N_SEC(severity, n_seconds) \
ABSL_LOG_INTERNAL_DLOG_EVERY_N_SEC_IMPL(_##severity, n_seconds)
#define ABSL_VLOG_EVERY_N(verbose_level, n) \
ABSL_LOG_INTERNAL_VLOG_EVERY_N_IMPL(verbose_level, n)
#define ABSL_VLOG_FIRST_N(verbose_level, n) \
ABSL_LOG_INTERNAL_VLOG_FIRST_N_IMPL(verbose_level, n)
#define ABSL_VLOG_EVERY_POW_2(verbose_level, n) \
ABSL_LOG_INTERNAL_VLOG_EVERY_POW_2_IMPL(verbose_level, n)
#define ABSL_VLOG_EVERY_N_SEC(verbose_level, n) \
ABSL_LOG_INTERNAL_VLOG_EVERY_N_SEC_IMPL(verbose_level, n)
#define ABSL_LOG_IF_EVERY_N(severity, condition, n) \
ABSL_LOG_INTERNAL_LOG_IF_EVERY_N_IMPL(_##severity, condition, n)
#define ABSL_LOG_IF_FIRST_N(severity, condition, n) \
......
absl/log/flags.cc
......@@ -28,6 +28,7 @@
#include "absl/flags/marshalling.h"
#include "absl/log/globals.h"
#include "absl/log/internal/config.h"
#include "absl/log/vlog_config.h"
#include "absl/strings/numbers.h"
#include "absl/strings/string_view.h"
......@@ -118,3 +119,25 @@ ABSL_FLAG(bool, log_prefix, true,
.OnUpdate([] {
absl::log_internal::RawEnableLogPrefix(absl::GetFlag(FLAGS_log_prefix));
});
ABSL_FLAG(int, v, 0,
"Show all VLOG(m) messages for m <= this. Overridable by --vmodule.")
.OnUpdate([] {
absl::log_internal::UpdateGlobalVLogLevel(absl::GetFlag(FLAGS_v));
});
ABSL_FLAG(
std::string, vmodule, "",
"per-module log verbosity level."
" Argument is a comma-separated list of <module name>=<log level>."
" <module name> is a glob pattern, matched against the filename base"
" (that is, name ignoring .cc/.h./-inl.h)."
" A pattern without slashes matches just the file name portion, otherwise"
" the whole file path below the workspace root"
" (still without .cc/.h./-inl.h) is matched."
" ? and * in the glob pattern match any single or sequence of characters"
" respectively including slashes."
" <log level> overrides any value given by --v.")
.OnUpdate([] {
absl::log_internal::UpdateVModule(absl::GetFlag(FLAGS_vmodule));
});
absl/log/internal/BUILD.bazel
......@@ -153,6 +153,7 @@ cc_library(
":conditions",
":log_message",
":strip",
"//absl/log:vlog_is_on",
],
)
......
absl/log/internal/flags.h
......@@ -50,4 +50,10 @@ ABSL_DECLARE_FLAG(std::string, log_backtrace_at);
// each message logged. Defaults to true.
ABSL_DECLARE_FLAG(bool, log_prefix);
// Global log verbosity level. Default is 0.
ABSL_DECLARE_FLAG(int, v);
// Per-module log verbosity level. By default is empty and is unused.
ABSL_DECLARE_FLAG(std::string, vmodule);
#endif // ABSL_LOG_INTERNAL_FLAGS_H_
absl/log/internal/log_impl.h
......@@ -18,6 +18,7 @@
#include "absl/log/internal/conditions.h"
#include "absl/log/internal/log_message.h"
#include "absl/log/internal/strip.h"
#include "absl/log/vlog_is_on.h"
// ABSL_LOG()
#define ABSL_LOG_INTERNAL_LOG_IMPL(severity) \
......@@ -41,6 +42,35 @@
ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
#endif
// The `switch` ensures that this expansion is the begnning of a statement (as
// opposed to an expression). The use of both `case 0` and `default` is to
// suppress a compiler warning.
#define ABSL_LOG_INTERNAL_VLOG_IMPL(verbose_level) \
switch (const int absl_logging_internal_verbose_level = (verbose_level)) \
case 0: \
default: \
ABSL_LOG_INTERNAL_LOG_IF_IMPL( \
_INFO, VLOG_IS_ON(absl_logging_internal_verbose_level)) \
.WithVerbosity(absl_logging_internal_verbose_level)
#ifndef NDEBUG
#define ABSL_LOG_INTERNAL_DVLOG_IMPL(verbose_level) \
switch (const int absl_logging_internal_verbose_level = (verbose_level)) \
case 0: \
default: \
ABSL_LOG_INTERNAL_LOG_IF_IMPL( \
_INFO, VLOG_IS_ON(absl_logging_internal_verbose_level)) \
.WithVerbosity(absl_logging_internal_verbose_level)
#else
#define ABSL_LOG_INTERNAL_DVLOG_IMPL(verbose_level) \
switch (const int absl_logging_internal_verbose_level = (verbose_level)) \
case 0: \
default: \
ABSL_LOG_INTERNAL_LOG_IF_IMPL( \
_INFO, false && VLOG_IS_ON(absl_logging_internal_verbose_level)) \
.WithVerbosity(absl_logging_internal_verbose_level)
#endif
#define ABSL_LOG_INTERNAL_LOG_IF_IMPL(severity, condition) \
ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, condition) \
ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
......@@ -134,6 +164,42 @@
(EveryNSec, n_seconds) ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
#endif // def NDEBUG
#define ABSL_LOG_INTERNAL_VLOG_EVERY_N_IMPL(verbose_level, n) \
switch (const int absl_logging_internal_verbose_level = (verbose_level)) \
case 0: \
default: \
ABSL_LOG_INTERNAL_CONDITION_INFO( \
STATEFUL, VLOG_IS_ON(absl_logging_internal_verbose_level)) \
(EveryN, n) ABSL_LOGGING_INTERNAL_LOG_INFO.InternalStream().WithVerbosity( \
absl_logging_internal_verbose_level)
#define ABSL_LOG_INTERNAL_VLOG_FIRST_N_IMPL(verbose_level, n) \
switch (const int absl_logging_internal_verbose_level = (verbose_level)) \
case 0: \
default: \
ABSL_LOG_INTERNAL_CONDITION_INFO( \
STATEFUL, VLOG_IS_ON(absl_logging_internal_verbose_level)) \
(FirstN, n) ABSL_LOGGING_INTERNAL_LOG_INFO.InternalStream().WithVerbosity( \
absl_logging_internal_verbose_level)
#define ABSL_LOG_INTERNAL_VLOG_EVERY_POW_2_IMPL(verbose_level) \
switch (const int absl_logging_internal_verbose_level = (verbose_level)) \
case 0: \
default: \
ABSL_LOG_INTERNAL_CONDITION_INFO( \
STATEFUL, VLOG_IS_ON(absl_logging_internal_verbose_level)) \
(EveryPow2) ABSL_LOGGING_INTERNAL_LOG_INFO.InternalStream().WithVerbosity( \
absl_logging_internal_verbose_level)
#define ABSL_LOG_INTERNAL_VLOG_EVERY_N_SEC_IMPL(verbose_level, n_seconds) \
switch (const int absl_logging_internal_verbose_level = (verbose_level)) \
case 0: \
default: \
ABSL_LOG_INTERNAL_CONDITION_INFO( \
STATEFUL, VLOG_IS_ON(absl_logging_internal_verbose_level)) \
(EveryNSec, n_seconds) ABSL_LOGGING_INTERNAL_LOG_INFO.InternalStream() \
.WithVerbosity(absl_logging_internal_verbose_level)
#define ABSL_LOG_INTERNAL_LOG_IF_EVERY_N_IMPL(severity, condition, n) \
ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryN, n) \
ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
......
absl/log/log.h
......@@ -53,6 +53,14 @@
// * .NoPrefix()
// Omits the prefix from this line. The prefix includes metadata about the
// logged data such as source code location and timestamp.
// * .WithVerbosity(int verbose_level)
// Sets the verbosity field of the logged message as if it was logged by
// `VLOG(verbose_level)`. Unlike `VLOG`, this method does not affect
// evaluation of the statement when the specified `verbose_level` has been
// disabled. The only effect is on `LogSink` implementations which make use
// of the `absl::LogSink::verbosity()` value. The value
// `absl::LogEntry::kNoVerbosityLevel` can be specified to mark the message
// not verbose.
// * .WithTimestamp(absl::Time timestamp)
// Uses the specified timestamp instead of one collected at the time of
// execution.
......@@ -190,6 +198,7 @@
#define ABSL_LOG_LOG_H_
#include "absl/log/internal/log_impl.h"
#include "absl/log/vlog_is_on.h" // IWYU pragma: export
// LOG()
//
......@@ -213,11 +222,32 @@
// terminate the program if `NDEBUG` is defined.
#define DLOG(severity) ABSL_LOG_INTERNAL_DLOG_IMPL(_##severity)
// `VLOG` uses numeric levels to provide verbose logging that can configured at
// runtime, including at a per-module level. `VLOG` statements are logged at
// `INFO` severity if they are logged at all; the numeric levels are on a
// different scale than the proper severity levels. Positive levels are
// disabled by default. Negative levels should not be used.
// Example:
//
// VLOG(1) << "I print when you run the program with --v=1 or higher";
// VLOG(2) << "I print when you run the program with --v=2 or higher";
//
// See vlog_is_on.h for further documentation, including the usage of the
// --vmodule flag to log at different levels in different source files.
#define VLOG(severity) ABSL_LOG_INTERNAL_VLOG_IMPL(severity)
// `DVLOG` behaves like `VLOG` in debug mode (i.e. `#ifndef NDEBUG`).
// Otherwise, it compiles away and does nothing.
#define DVLOG(severity) ABSL_LOG_INTERNAL_DVLOG_IMPL(severity)
// `LOG_IF` and friends add a second argument which specifies a condition. If
// the condition is false, nothing is logged.
// Example:
//
// LOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
//
// There is no `VLOG_IF` because the order of evaluation of the arguments is
// ambiguous and the alternate spelling with an `if`-statement is trivial.
#define LOG_IF(severity, condition) \
ABSL_LOG_INTERNAL_LOG_IF_IMPL(_##severity, condition)
#define PLOG_IF(severity, condition) \
......@@ -285,6 +315,15 @@
#define DLOG_EVERY_N_SEC(severity, n_seconds) \
ABSL_LOG_INTERNAL_DLOG_EVERY_N_SEC_IMPL(_##severity, n_seconds)
#define VLOG_EVERY_N(severity, n) \
ABSL_LOG_INTERNAL_VLOG_EVERY_N_IMPL(severity, n)
#define VLOG_FIRST_N(severity, n) \
ABSL_LOG_INTERNAL_VLOG_FIRST_N_IMPL(severity, n)
#define VLOG_EVERY_POW_2(severity) \
ABSL_LOG_INTERNAL_VLOG_EVERY_POW_2_IMPL(severity)
#define VLOG_EVERY_N_SEC(severity, n_seconds) \
ABSL_LOG_INTERNAL_VLOG_EVERY_N_SEC_IMPL(severity, n_seconds)
// `LOG_IF_EVERY_N` and friends behave as the corresponding `LOG_EVERY_N`
// but neither increment a counter nor log a message if condition is false (as
// `LOG_IF`).
......
absl/log/log_entry.h
......@@ -96,7 +96,8 @@ class LogEntry final {
// LogEntry::verbosity()
//
// Returns this entry's verbosity, or `kNoVerbosityLevel` for a non-verbose
// entry. Verbosity control is not available outside of Google yet.
// entry. Taken from the argument to `VLOG` or from
// `LOG(...).WithVerbosity(...)`.
int verbosity() const { return verbose_level_; }
// LogEntry::timestamp()
......
absl/log/vlog_config.h 0 → 100644
// Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// -----------------------------------------------------------------------------
// vlog_config.h
// -----------------------------------------------------------------------------
//
// This header file defines `VLogSite`, a public primitive that represents
// a callsite for the `VLOG` family of macros and related libraries.
// It also declares and defines multiple internal utilities used to implement
// `VLOG`, such as `VLogSiteManager`.
#ifndef ABSL_LOG_VLOG_CONFIG_H_
#define ABSL_LOG_VLOG_CONFIG_H_
// IWYU pragma: private, include "absl/log/log.h"
#include <atomic>
#include <cstdint>
#include <functional>
#include <limits>
#include <type_traits>
#include "absl/base/attributes.h"
#include "absl/base/config.h"
#include "absl/base/optimization.h"
#include "absl/base/thread_annotations.h"
#include "absl/strings/string_view.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
class VLogSite;
namespace log_internal {
class SyntheticBinary;
int RegisterAndInitialize(VLogSite* v);
void UpdateVLogSites();
constexpr int kUseFlag = (std::numeric_limits<int16_t>::min)();
} // namespace log_internal
// Represents a unique callsite for a `VLOG()` or `VLOG_IS_ON()` call.
//
// Libraries that provide `VLOG`-like functionality should use this to
// efficiently handle --vmodule.
//
// VLogSite objects must not be destroyed until the program exits. Doing so will
// probably yield nasty segfaults in VLogSiteManager::UpdateLogSites(). The
// recommendation is to make all such objects function-local statics.
class VLogSite final {
public:
// `f` must not be destroyed until the program exits.
explicit constexpr VLogSite(const char* f)
: file_(f), v_(kUninitialized), next_(nullptr) {}
VLogSite(const VLogSite&) = delete;
VLogSite& operator=(const VLogSite&) = delete;
// Inlining the function yields a ~3x performance improvement at the cost of a
// 1.5x code size increase at the call site.
// Takes locks but does not allocate memory.
ABSL_ATTRIBUTE_ALWAYS_INLINE
bool IsEnabled(int level) {
int stale_v = v_.load(std::memory_order_relaxed);
if (ABSL_PREDICT_TRUE(level > stale_v)) {
return false;
}
// We put everything other than the fast path, i.e. vlogging is initialized
// but not on, behind an out-of-line function to reduce code size.
// "level" is almost always a call-site constant, so we can save a bit
// of code space by special-casing for a few common levels.
#if ABSL_HAVE_BUILTIN(__builtin_constant_p) || defined(__GNUC__)
if (__builtin_constant_p(level)) {
if (level == 0) return SlowIsEnabled0(stale_v);
if (level == 1) return SlowIsEnabled1(stale_v);
if (level == 2) return SlowIsEnabled2(stale_v);
if (level == 3) return SlowIsEnabled3(stale_v);
if (level == 4) return SlowIsEnabled4(stale_v);
if (level == 5) return SlowIsEnabled5(stale_v);
}
#endif
return SlowIsEnabled(stale_v, level);
}
private:
friend int log_internal::RegisterAndInitialize(VLogSite* v);
friend void log_internal::UpdateVLogSites();
friend class log_internal::SyntheticBinary;
static constexpr int kUninitialized = (std::numeric_limits<int>::max)();
// SlowIsEnabled performs slower checks to determine whether a log site is
// enabled. Because it is expected to be called somewhat rarely
// (comparatively), it is not inlined to save on code size.
//
// Prerequisites to calling SlowIsEnabled:
// 1) stale_v is uninitialized OR
// 2) stale_v is initialized and >= level (meaning we must log).
// Takes locks but does not allocate memory.
ABSL_ATTRIBUTE_NOINLINE
bool SlowIsEnabled(int stale_v, int level);
ABSL_ATTRIBUTE_NOINLINE bool SlowIsEnabled0(int stale_v);
ABSL_ATTRIBUTE_NOINLINE bool SlowIsEnabled1(int stale_v);
ABSL_ATTRIBUTE_NOINLINE bool SlowIsEnabled2(int stale_v);
ABSL_ATTRIBUTE_NOINLINE bool SlowIsEnabled3(int stale_v);
ABSL_ATTRIBUTE_NOINLINE bool SlowIsEnabled4(int stale_v);
ABSL_ATTRIBUTE_NOINLINE bool SlowIsEnabled5(int stale_v);
// This object is too size-sensitive to use absl::string_view.
const char* const file_;
std::atomic<int> v_;
std::atomic<VLogSite*> next_;
};
static_assert(std::is_trivially_destructible<VLogSite>::value,
"VLogSite must be trivially destructible");
namespace log_internal {
// Returns the current verbose log level of `file`.
// Does not allocate memory.
int VLogLevel(absl::string_view file);
// Registers a site `v` to get updated as `vmodule` and `v` change. Also
// initializes the site based on their current values, and returns that result.
// Does not allocate memory.
int RegisterAndInitialize(VLogSite* v);
// Allocates memory.
void UpdateVLogSites();
// Completely overwrites the saved value of `vmodule`.
// Allocates memory.
void UpdateVModule(absl::string_view vmodule);
// Updates the global verbosity level to `v` and returns the prior value.
// Allocates memory.
int UpdateGlobalVLogLevel(int v);
// Atomically prepends `module_pattern=log_level` to the start of vmodule.
// Returns the prior value for `module_pattern` if there was an exact match and
// `global_v` otherwise.
// Allocates memory.
int PrependVModule(absl::string_view module_pattern, int log_level);
// Registers `on_update` to be called whenever `v` or `vmodule` change.
// Allocates memory.
void OnVLogVerbosityUpdate(std::function<void()> cb);
// Does not allocate memory.
VLogSite* SetVModuleListHeadForTestOnly(VLogSite* v);
} // namespace log_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_LOG_VLOG_CONFIG_H_
absl/log/vlog_config_benchmark.cc 0 → 100644
// Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <algorithm>
#include <atomic>
#include <cstddef>
#include <cstring>
#include <memory>
#include <new>
#include <random>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
#include "absl/base/config.h"
#include "absl/container/internal/layout.h"
#include "absl/log/vlog_config.h"
#include "absl/memory/memory.h"
#include "absl/random/distributions.h"
#include "absl/strings/str_cat.h"
#include "benchmark/benchmark.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace log_internal {
// Performance of `UpdateLogSites` depends upon the number and organization of
// `VLogSite`s in the program. We can synthesize some on the heap to mimic
// their layout and linkage in static data.
class SyntheticBinary {
public:
explicit SyntheticBinary(const size_t num_tus,
const size_t max_extra_static_data_bytes_per_tu,
const size_t max_sites_per_tu,
const int num_shuffles) {
per_tu_data_.reserve(num_tus);
auto sites = absl::make_unique<VLogSite *[]>(num_tus * max_sites_per_tu);
for (size_t i = 0; i < num_tus; i++) {
const std::string filename =
absl::StrCat("directory-", i / 100, "/subdirectory-", i % 100 / 10,
"/file-", i % 10, ".cc");
container_internal::Layout<char, VLogSite, char> layout(
filename.size() + 1,
absl::LogUniform<size_t>(bitgen_, 1, max_sites_per_tu),
absl::LogUniform<size_t>(bitgen_, 0,
max_extra_static_data_bytes_per_tu));
auto buf = absl::make_unique<char[]>(layout.AllocSize());
layout.PoisonPadding(buf.get());
memcpy(layout.Pointer<0>(buf.get()), filename.c_str(),
filename.size() + 1);
for (VLogSite &site : layout.Slice<1>(buf.get())) {
sites[num_sites_++] =
new (&site) VLogSite(layout.Pointer<0>(buf.get()));
// The last one is a dangling pointer but will be fixed below.
site.next_.store(&site + 1, std::memory_order_seq_cst);
}
num_extra_static_data_bytes_ += layout.Size<2>();
per_tu_data_.push_back(PerTU{layout, std::move(buf)});
}
// Now link the files together back-to-front into a circular list.
for (size_t i = 0; i < num_tus; i++) {
auto &tu = per_tu_data_[i];
auto &next_tu = per_tu_data_[(i + 1) % num_tus];
tu.layout.Slice<1>(tu.buf.get())
.back()
.next_.store(next_tu.layout.Pointer<1>(next_tu.buf.get()),
std::memory_order_seq_cst);
}
// Now do some shufflin'.
auto new_sites = absl::make_unique<VLogSite *[]>(num_sites_);
for (int shuffle_num = 0; shuffle_num < num_shuffles; shuffle_num++) {
// Each shuffle cuts the ring into three pieces and rearranges them.
const size_t cut_a = absl::Uniform(bitgen_, size_t{0}, num_sites_);
const size_t cut_b = absl::Uniform(bitgen_, size_t{0}, num_sites_);
const size_t cut_c = absl::Uniform(bitgen_, size_t{0}, num_sites_);
if (cut_a == cut_b || cut_b == cut_c || cut_a == cut_c) continue;
// The same cuts, sorted:
const size_t cut_1 = std::min({cut_a, cut_b, cut_c});
const size_t cut_3 = std::max({cut_a, cut_b, cut_c});
const size_t cut_2 = cut_a ^ cut_b ^ cut_c ^ cut_1 ^ cut_3;
VLogSite *const tmp = sites[cut_1]->next_.load(std::memory_order_seq_cst);
sites[cut_1]->next_.store(
sites[cut_2]->next_.load(std::memory_order_seq_cst),
std::memory_order_seq_cst);
sites[cut_2]->next_.store(
sites[cut_3]->next_.load(std::memory_order_seq_cst),
std::memory_order_seq_cst);
sites[cut_3]->next_.store(tmp, std::memory_order_seq_cst);
memcpy(&new_sites[0], &sites[0], sizeof(VLogSite *) * (cut_1 + 1));
memcpy(&new_sites[cut_1 + 1], &sites[cut_2 + 1],
sizeof(VLogSite *) * (cut_3 - cut_2));
memcpy(&new_sites[cut_1 + 1 + cut_3 - cut_2], &sites[cut_1 + 1],
sizeof(VLogSite *) * (cut_2 - cut_1));
memcpy(&new_sites[cut_3 + 1], &sites[cut_3 + 1],
sizeof(VLogSite *) * (num_sites_ - cut_3 - 1));
sites.swap(new_sites);
}
const char *last_file = nullptr;
for (size_t i = 0; i < num_sites_; i++) {
if (sites[i]->file_ == last_file) continue;
last_file = sites[i]->file_;
num_new_files_++;
}
absl::log_internal::SetVModuleListHeadForTestOnly(sites[0]);
sites[num_tus - 1]->next_.store(nullptr, std::memory_order_seq_cst);
}
~SyntheticBinary() {
static_assert(std::is_trivially_destructible<VLogSite>::value, "");
absl::log_internal::SetVModuleListHeadForTestOnly(nullptr);
}
size_t num_sites() const { return num_sites_; }
size_t num_new_files() const { return num_new_files_; }
size_t num_extra_static_data_bytes() const {
return num_extra_static_data_bytes_;
}
private:
struct PerTU {
container_internal::Layout<char, VLogSite, char> layout;
std::unique_ptr<char[]> buf;
};
std::mt19937 bitgen_;
std::vector<PerTU> per_tu_data_;
size_t num_sites_ = 0;
size_t num_new_files_ = 0;
size_t num_extra_static_data_bytes_ = 0;
};
namespace {
void BM_UpdateVModuleEmpty(benchmark::State& state) {
SyntheticBinary bin(static_cast<size_t>(state.range(0)), 10 * 1024 * 1024,
256, state.range(1));
for (auto s : state) {
absl::log_internal::UpdateVModule("");
}
state.SetItemsProcessed(static_cast<int>(bin.num_new_files()));
}
BENCHMARK(BM_UpdateVModuleEmpty)
->ArgPair(100, 200)
->ArgPair(1000, 2000)
->ArgPair(10000, 20000);
void BM_UpdateVModuleShort(benchmark::State& state) {
SyntheticBinary bin(static_cast<size_t>(state.range(0)), 10 * 1024 * 1024,
256, state.range(1));
for (auto s : state) {
absl::log_internal::UpdateVModule("directory2/*=4");
}
state.SetItemsProcessed(static_cast<int>(bin.num_new_files()));
}
BENCHMARK(BM_UpdateVModuleShort)
->ArgPair(100, 200)
->ArgPair(1000, 2000)
->ArgPair(10000, 20000);
void BM_UpdateVModuleLong(benchmark::State& state) {
SyntheticBinary bin(static_cast<size_t>(state.range(0)), 10 * 1024 * 1024,
256, state.range(1));
for (auto s : state) {
absl::log_internal::UpdateVModule(
"d?r?c?o?y2/*=4,d?*r?*c?**o?*y1/*=2,d?*rc?**o?*y3/*=2,,"
"d?*r?*c?**o?*1/*=1,d?*r?**o?*y1/*=2,d?*r???***y1/*=7,"
"d?*r?**o?*y1/aaa=6");
}
state.SetItemsProcessed(static_cast<int>(bin.num_new_files()));
}
BENCHMARK(BM_UpdateVModuleLong)
->ArgPair(100, 200)
->ArgPair(1000, 2000)
->ArgPair(10000, 20000);
} // namespace
} // namespace log_internal
ABSL_NAMESPACE_END
} // namespace absl
absl/log/vlog_is_on.h 0 → 100644
// Copyright 2022 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// -----------------------------------------------------------------------------
// File: log/vlog_is_on.h
// -----------------------------------------------------------------------------
//
// This header defines the `VLOG_IS_ON()` macro that controls the
// variable-verbosity conditional logging.
//
// It's used by `VLOG` in log.h, or it can also be used directly like this:
//
// if (VLOG_IS_ON(2)) {
// foo_server.RecomputeStatisticsExpensive();
// LOG(INFO) << foo_server.LastStatisticsAsString();
// }
//
// Each source file has an effective verbosity level that's a non-negative
// integer computed from the `--vmodule` and `--v` flags.
// `VLOG_IS_ON(n)` is true, and `VLOG(n)` logs, if that effective verbosity
// level is greater than or equal to `n`.
//
// `--vmodule` takes a comma-delimited list of key=value pairs. Each key is a
// pattern matched against filenames, and the values give the effective severity
// level applied to matching files. '?' and '*' characters in patterns are
// interpreted as single-character and zero-or-more-character wildcards.
// Patterns including a slash character are matched against full pathnames,
// while those without are matched against basenames only. One suffix (i.e. the
// last . and everything after it) is stripped from each filename prior to
// matching, as is the special suffix "-inl".
//
// Files are matched against globs in `--vmodule` in order, and the first match
// determines the verbosity level.
//
// Files which do not match any pattern in `--vmodule` use the value of `--v` as
// their effective verbosity level. The default is 0.
//
// SetVLOGLevel helper function is provided to do limited dynamic control over
// V-logging by appending to `--vmodule`. Because these go at the beginning of
// the list, they take priority over any globs previously added.
//
// Resetting --vmodule will override all previous modifications to `--vmodule`,
// including via SetVLOGLevel.
#ifndef ABSL_LOG_VLOG_IS_ON_H_
#define ABSL_LOG_VLOG_IS_ON_H_
#include "absl/base/attributes.h"
#include "absl/base/config.h"
#include "absl/log/vlog_config.h" // IWYU pragma: export
#include "absl/strings/string_view.h"
// IWYU pragma: private, include "absl/log/log.h"
// This is expanded at the callsite to allow the compiler to optimize
// always-false cases out of the build.
// An ABSL_MAX_VLOG_VERBOSITY of 2 means that VLOG(3) and above should never
// log.
#ifdef ABSL_MAX_VLOG_VERBOSITY
#define ABSL_LOG_INTERNAL_MAX_LOG_VERBOSITY_CHECK(x) \
((x) <= ABSL_MAX_VLOG_VERBOSITY)&&
#else
#define ABSL_LOG_INTERNAL_MAX_LOG_VERBOSITY_CHECK(x)
#endif
// Each VLOG_IS_ON call site gets its own VLogSite that registers with the
// global linked list of sites to asynchronously update its verbosity level on
// changes to --v or --vmodule. The verbosity can also be set by manually
// calling SetVLOGLevel.
//
// VLOG_IS_ON is not async signal safe, but it is guaranteed not to allocate
// new memory.
#define VLOG_IS_ON(verbose_level) \
(ABSL_LOG_INTERNAL_MAX_LOG_VERBOSITY_CHECK(verbose_level)[]() \
->::absl::VLogSite * \
{ \
ABSL_CONST_INIT static ::absl::VLogSite site(__FILE__); \
return &site; \
}() \
->IsEnabled(verbose_level))
namespace absl {
ABSL_NAMESPACE_BEGIN
// Sets the global `VLOG(_IS_ON)` level to `log_level`. This level is applied
// to any sites whose filename doesn't match any `module_pattern`. Returns the
// prior value.
inline int SetGlobalVLogLevel(int log_level) {
return absl::log_internal::UpdateGlobalVLogLevel(log_level);
}
// Sets `VLOG(_IS_ON)` level for `module_pattern` to `log_level`.
// This lets us dynamically control what is normally set by the --vmodule flag.
// Returns the level that previously applied to module_pattern.
// Calling this with `log_level` of kUseFlag will have all sites for that
// pattern use the value of --v.
inline int SetVLogLevel(absl::string_view module_pattern, int log_level) {
return absl::log_internal::PrependVModule(module_pattern, log_level);
}
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_LOG_VLOG_IS_ON_H_
absl/log/vlog_is_on_test.cc 0 → 100644
// Copyright 2023 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "absl/log/vlog_is_on.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "absl/base/log_severity.h"
#include "absl/flags/flag.h"
#include "absl/log/flags.h"
#include "absl/log/log.h"
#include "absl/log/scoped_mock_log.h"
#include "absl/types/optional.h"
namespace {
using ::testing::_;
absl::optional<int> MaxLogVerbosity() {
#ifdef ABSL_MAX_VLOG_VERBOSITY
return ABSL_MAX_VLOG_VERBOSITY;
#else
return absl::nullopt;
#endif
}
absl::optional<int> MinLogLevel() {
#ifdef ABSL_MIN_LOG_LEVEL
return static_cast<int>(ABSL_MIN_LOG_LEVEL);
#else
return absl::nullopt;
#endif
}
TEST(VLogIsOn, GlobalWorksWithoutMaxVerbosityAndMinLogLevel) {
if (MaxLogVerbosity().has_value() || MinLogLevel().has_value()) {
GTEST_SKIP();
}
absl::SetGlobalVLogLevel(3);
absl::ScopedMockLog log(absl::MockLogDefault::kDisallowUnexpected);
EXPECT_CALL(log, Log(absl::LogSeverity::kInfo, _, "important"));
log.StartCapturingLogs();
VLOG(3) << "important";
VLOG(4) << "spam";
}
TEST(VLogIsOn, FileWorksWithoutMaxVerbosityAndMinLogLevel) {
if (MaxLogVerbosity().has_value() || MinLogLevel().has_value()) {
GTEST_SKIP();
}
absl::SetVLogLevel("vlog_is_on_test", 3);
absl::ScopedMockLog log(absl::MockLogDefault::kDisallowUnexpected);
EXPECT_CALL(log, Log(absl::LogSeverity::kInfo, _, "important"));
log.StartCapturingLogs();
VLOG(3) << "important";
VLOG(4) << "spam";
}
TEST(VLogIsOn, PatternWorksWithoutMaxVerbosityAndMinLogLevel) {
if (MaxLogVerbosity().has_value() || MinLogLevel().has_value()) {
GTEST_SKIP();
}
absl::SetVLogLevel("vlog_is_on*", 3);
absl::ScopedMockLog log(absl::MockLogDefault::kDisallowUnexpected);
EXPECT_CALL(log, Log(absl::LogSeverity::kInfo, _, "important"));
log.StartCapturingLogs();
VLOG(3) << "important";
VLOG(4) << "spam";
}
TEST(VLogIsOn, GlobalDoesNotFilterBelowMaxVerbosity) {
if (!MaxLogVerbosity().has_value() || *MaxLogVerbosity() < 2) {
GTEST_SKIP();
}
// Set an arbitrary high value to avoid filtering VLOGs in tests by default.
absl::SetGlobalVLogLevel(1000);
absl::ScopedMockLog log(absl::MockLogDefault::kDisallowUnexpected);
EXPECT_CALL(log, Log(absl::LogSeverity::kInfo, _, "asdf"));
log.StartCapturingLogs();
VLOG(2) << "asdf";
}
TEST(VLogIsOn, FileDoesNotFilterBelowMaxVerbosity) {
if (!MaxLogVerbosity().has_value() || *MaxLogVerbosity() < 2) {
GTEST_SKIP();
}
// Set an arbitrary high value to avoid filtering VLOGs in tests by default.
absl::SetVLogLevel("vlog_is_on_test", 1000);
absl::ScopedMockLog log(absl::MockLogDefault::kDisallowUnexpected);
EXPECT_CALL(log, Log(absl::LogSeverity::kInfo, _, "asdf"));
log.StartCapturingLogs();
VLOG(2) << "asdf";
}
TEST(VLogIsOn, PatternDoesNotFilterBelowMaxVerbosity) {
if (!MaxLogVerbosity().has_value() || *MaxLogVerbosity() < 2) {
GTEST_SKIP();
}
// Set an arbitrary high value to avoid filtering VLOGs in tests by default.
absl::SetVLogLevel("vlog_is_on*", 1000);
absl::ScopedMockLog log(absl::MockLogDefault::kDisallowUnexpected);
EXPECT_CALL(log, Log(absl::LogSeverity::kInfo, _, "asdf"));
log.StartCapturingLogs();
VLOG(2) << "asdf";
}
TEST(VLogIsOn, GlobalFiltersAboveMaxVerbosity) {
if (!MaxLogVerbosity().has_value() || *MaxLogVerbosity() >= 4) {
GTEST_SKIP();
}
// Set an arbitrary high value to avoid filtering VLOGs in tests by default.
absl::SetGlobalVLogLevel(1000);
absl::ScopedMockLog log(absl::MockLogDefault::kDisallowUnexpected);
log.StartCapturingLogs();
VLOG(4) << "dfgh";
}
TEST(VLogIsOn, FileFiltersAboveMaxVerbosity) {
if (!MaxLogVerbosity().has_value() || *MaxLogVerbosity() >= 4) {
GTEST_SKIP();
}
// Set an arbitrary high value to avoid filtering VLOGs in tests by default.
absl::SetVLogLevel("vlog_is_on_test", 1000);
absl::ScopedMockLog log(absl::MockLogDefault::kDisallowUnexpected);
log.StartCapturingLogs();
VLOG(4) << "dfgh";
}
TEST(VLogIsOn, PatternFiltersAboveMaxVerbosity) {
if (!MaxLogVerbosity().has_value() || *MaxLogVerbosity() >= 4) {
GTEST_SKIP();
}
// Set an arbitrary high value to avoid filtering VLOGs in tests by default.
absl::SetVLogLevel("vlog_is_on*", 1000);
absl::ScopedMockLog log(absl::MockLogDefault::kDisallowUnexpected);
log.StartCapturingLogs();
VLOG(4) << "dfgh";
}
} // namespace
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment