diff options
Diffstat (limited to 'absl/flags')
| -rw-r--r-- | absl/flags/BUILD.bazel | 2 | ||||
| -rw-r--r-- | absl/flags/flag.h | 12 | ||||
| -rw-r--r-- | absl/flags/flag_test.cc | 6 | ||||
| -rw-r--r-- | absl/flags/internal/flag.cc | 47 | ||||
| -rw-r--r-- | absl/flags/internal/flag.h | 372 |
5 files changed, 232 insertions, 207 deletions
diff --git a/absl/flags/BUILD.bazel b/absl/flags/BUILD.bazel index cbdbae52ed83..03833d440f55 100644 --- a/absl/flags/BUILD.bazel +++ b/absl/flags/BUILD.bazel @@ -36,7 +36,7 @@ cc_library( ], copts = ABSL_DEFAULT_COPTS, linkopts = ABSL_DEFAULT_LINKOPTS, - visibility = ["//visibility:private"], + visibility = ["//absl/base:__subpackages__"], deps = [ ":config", ":handle", diff --git a/absl/flags/flag.h b/absl/flags/flag.h index fcfdd58cbf4a..782dee2ee8df 100644 --- a/absl/flags/flag.h +++ b/absl/flags/flag.h @@ -120,11 +120,11 @@ class Flag { return impl_; } - impl_ = new flags_internal::Flag<T>( - name_, filename_, marshalling_op_, - {flags_internal::FlagHelpSrc(help_gen_), - flags_internal::FlagHelpSrcKind::kGenFunc}, - default_value_gen_); + impl_ = + new flags_internal::Flag<T>(name_, filename_, marshalling_op_, + {flags_internal::FlagHelpMsg(help_gen_), + flags_internal::FlagHelpKind::kGenFunc}, + default_value_gen_); inited_.store(true, std::memory_order_release); } @@ -152,7 +152,7 @@ class Flag { T Get() const { return GetImpl()->Get(); } bool AtomicGet(T* v) const { return GetImpl()->AtomicGet(v); } void Set(const T& v) { GetImpl()->Set(v); } - void SetCallback(const flags_internal::FlagCallback mutation_callback) { + void SetCallback(const flags_internal::FlagCallbackFunc mutation_callback) { GetImpl()->SetCallback(mutation_callback); } void InvokeCallback() { GetImpl()->InvokeCallback(); } diff --git a/absl/flags/flag_test.cc b/absl/flags/flag_test.cc index 7b50fd66a110..6722329c1f12 100644 --- a/absl/flags/flag_test.cc +++ b/absl/flags/flag_test.cc @@ -51,8 +51,8 @@ void TestCallback() {} template <typename T> bool TestConstructionFor() { - constexpr flags::HelpInitArg help_arg{flags::FlagHelpSrc("literal help"), - flags::FlagHelpSrcKind::kLiteral}; + constexpr flags::FlagHelpArg help_arg{flags::FlagHelpMsg("literal help"), + flags::FlagHelpKind::kLiteral}; constexpr flags::Flag<T> f1("f1", "file", &flags::FlagMarshallingOps<T>, help_arg, &TestMakeDflt<T>); EXPECT_EQ(f1.Name(), "f1"); @@ -61,7 +61,7 @@ bool TestConstructionFor() { ABSL_CONST_INIT static flags::Flag<T> f2( "f2", "file", &flags::FlagMarshallingOps<T>, - {flags::FlagHelpSrc(&TestHelpMsg), flags::FlagHelpSrcKind::kGenFunc}, + {flags::FlagHelpMsg(&TestHelpMsg), flags::FlagHelpKind::kGenFunc}, &TestMakeDflt<T>); flags::FlagRegistrar<T, false>(&f2).OnUpdate(TestCallback); diff --git a/absl/flags/internal/flag.cc b/absl/flags/internal/flag.cc index 2ef8e3f6fe35..3df8d82cfede 100644 --- a/absl/flags/internal/flag.cc +++ b/absl/flags/internal/flag.cc @@ -91,11 +91,11 @@ void FlagImpl::Init() { absl::MutexLock lock(reinterpret_cast<absl::Mutex*>(&data_guard_)); - if (cur_ != nullptr) { + if (value_.dynamic != nullptr) { inited_.store(true, std::memory_order_release); } else { // Need to initialize cur field. - cur_ = MakeInitValue().release(); + value_.dynamic = MakeInitValue().release(); StoreAtomic(); inited_.store(true, std::memory_order_release); } @@ -117,7 +117,7 @@ void FlagImpl::Destroy() { absl::MutexLock l(DataGuard()); // Values are heap allocated for Abseil Flags. - if (cur_) Delete(op_, cur_); + if (value_.dynamic) Delete(op_, value_.dynamic); // Release the dynamically allocated default value if any. if (def_kind_ == FlagDefaultSrcKind::kDynamicValue) { @@ -125,7 +125,7 @@ void FlagImpl::Destroy() { } // If this flag has an assigned callback, release callback data. - if (callback_data_) delete callback_data_; + if (callback_) delete callback_; } absl::MutexLock l(&flag_mutex_lifetime_guard); @@ -150,8 +150,8 @@ std::string FlagImpl::Filename() const { } std::string FlagImpl::Help() const { - return help_source_kind_ == FlagHelpSrcKind::kLiteral ? help_.literal - : help_.gen_func(); + return help_source_kind_ == FlagHelpKind::kLiteral ? help_.literal + : help_.gen_func(); } bool FlagImpl::IsModified() const { @@ -174,27 +174,26 @@ std::string FlagImpl::DefaultValue() const { std::string FlagImpl::CurrentValue() const { absl::MutexLock l(DataGuard()); - return Unparse(marshalling_op_, cur_); + return Unparse(marshalling_op_, value_.dynamic); } -void FlagImpl::SetCallback( - const flags_internal::FlagCallback mutation_callback) { +void FlagImpl::SetCallback(const FlagCallbackFunc mutation_callback) { absl::MutexLock l(DataGuard()); - if (callback_data_ == nullptr) { - callback_data_ = new CallbackData; + if (callback_ == nullptr) { + callback_ = new FlagCallback; } - callback_data_->func = mutation_callback; + callback_->func = mutation_callback; InvokeCallback(); } void FlagImpl::InvokeCallback() const { - if (!callback_data_) return; + if (!callback_) return; // Make a copy of the C-style function pointer that we are about to invoke // before we release the lock guarding it. - FlagCallback cb = callback_data_->func; + FlagCallbackFunc cb = callback_->func; // If the flag has a mutation callback this function invokes it. While the // callback is being invoked the primary flag's mutex is unlocked and it is @@ -208,7 +207,7 @@ void FlagImpl::InvokeCallback() const { // completed. Requires that *primary_lock be held in exclusive mode; it may be // released and reacquired by the implementation. MutexRelock relock(DataGuard()); - absl::MutexLock lock(&callback_data_->guard); + absl::MutexLock lock(&callback_->guard); cb(); } @@ -267,7 +266,7 @@ void FlagImpl::Read(void* dst, const flags_internal::FlagOpFn dst_op) const { absl::StrCat("Flag '", Name(), "' is defined as one type and declared as another")); } - CopyConstruct(op_, cur_, dst); + CopyConstruct(op_, value_.dynamic, dst); } void FlagImpl::StoreAtomic() { @@ -275,14 +274,14 @@ void FlagImpl::StoreAtomic() { if (data_size <= sizeof(int64_t)) { int64_t t = 0; - std::memcpy(&t, cur_, data_size); - atomics_.small_atomic.store(t, std::memory_order_release); + std::memcpy(&t, value_.dynamic, data_size); + value_.atomics.small_atomic.store(t, std::memory_order_release); } #if defined(ABSL_FLAGS_INTERNAL_ATOMIC_DOUBLE_WORD) else if (data_size <= sizeof(FlagsInternalTwoWordsType)) { FlagsInternalTwoWordsType t{0, 0}; - std::memcpy(&t, cur_, data_size); - atomics_.big_atomic.store(t, std::memory_order_release); + std::memcpy(&t, value_.dynamic, data_size); + value_.atomics.big_atomic.store(t, std::memory_order_release); } #endif } @@ -313,7 +312,7 @@ void FlagImpl::Write(const void* src, const flags_internal::FlagOpFn src_op) { modified_ = true; counter_++; - Copy(op_, src, cur_); + Copy(op_, src, value_.dynamic); StoreAtomic(); InvokeCallback(); @@ -334,7 +333,7 @@ bool FlagImpl::SetFromString(absl::string_view value, FlagSettingMode set_mode, switch (set_mode) { case SET_FLAGS_VALUE: { // set or modify the flag's value - if (!TryParse(&cur_, value, err)) return false; + if (!TryParse(&value_.dynamic, value, err)) return false; modified_ = true; counter_++; StoreAtomic(); @@ -348,7 +347,7 @@ bool FlagImpl::SetFromString(absl::string_view value, FlagSettingMode set_mode, case SET_FLAG_IF_DEFAULT: { // set the flag's value, but only if it hasn't been set by someone else if (!modified_) { - if (!TryParse(&cur_, value, err)) return false; + if (!TryParse(&value_.dynamic, value, err)) return false; modified_ = true; counter_++; StoreAtomic(); @@ -381,7 +380,7 @@ bool FlagImpl::SetFromString(absl::string_view value, FlagSettingMode set_mode, if (!modified_) { // Need to set both default value *and* current, in this case - Copy(op_, default_src_.dynamic_value, cur_); + Copy(op_, default_src_.dynamic_value, value_.dynamic); StoreAtomic(); InvokeCallback(); } diff --git a/absl/flags/internal/flag.h b/absl/flags/internal/flag.h index 4341f1137d9d..cc07dce1829b 100644 --- a/absl/flags/internal/flag.h +++ b/absl/flags/internal/flag.h @@ -22,6 +22,7 @@ #include <cstring> #include <memory> #include <string> +#include <type_traits> #include "absl/base/config.h" #include "absl/base/thread_annotations.h" @@ -37,65 +38,12 @@ namespace absl { ABSL_NAMESPACE_BEGIN namespace flags_internal { -// The minimum atomic size we believe to generate lock free code, i.e. all -// trivially copyable types not bigger this size generate lock free code. -static constexpr int kMinLockFreeAtomicSize = 8; - -// The same as kMinLockFreeAtomicSize but maximum atomic size. As double words -// might use two registers, we want to dispatch the logic for them. -#if defined(ABSL_FLAGS_INTERNAL_ATOMIC_DOUBLE_WORD) -static constexpr int kMaxLockFreeAtomicSize = 16; -#else -static constexpr int kMaxLockFreeAtomicSize = 8; -#endif - -// We can use atomic in cases when it fits in the register, trivially copyable -// in order to make memcpy operations. -template <typename T> -struct IsAtomicFlagTypeTrait { - static constexpr bool value = - (sizeof(T) <= kMaxLockFreeAtomicSize && - type_traits_internal::is_trivially_copyable<T>::value); -}; - -// Clang does not always produce cmpxchg16b instruction when alignment of a 16 -// bytes type is not 16. -struct alignas(16) FlagsInternalTwoWordsType { - int64_t first; - int64_t second; -}; - -constexpr bool operator==(const FlagsInternalTwoWordsType& that, - const FlagsInternalTwoWordsType& other) { - return that.first == other.first && that.second == other.second; -} -constexpr bool operator!=(const FlagsInternalTwoWordsType& that, - const FlagsInternalTwoWordsType& other) { - return !(that == other); -} - -constexpr int64_t SmallAtomicInit() { return 0xababababababababll; } - -template <typename T, typename S = void> -struct BestAtomicType { - using type = int64_t; - static constexpr int64_t AtomicInit() { return SmallAtomicInit(); } -}; - -template <typename T> -struct BestAtomicType< - T, typename std::enable_if<(kMinLockFreeAtomicSize < sizeof(T) && - sizeof(T) <= kMaxLockFreeAtomicSize), - void>::type> { - using type = FlagsInternalTwoWordsType; - static constexpr FlagsInternalTwoWordsType AtomicInit() { - return {SmallAtomicInit(), SmallAtomicInit()}; - } -}; - template <typename T> class Flag; +/////////////////////////////////////////////////////////////////////////////// +// Persistent state of the flag data. + template <typename T> class FlagState : public flags_internal::FlagStateInterface { public: @@ -123,24 +71,27 @@ class FlagState : public flags_internal::FlagStateInterface { int64_t counter_; }; +/////////////////////////////////////////////////////////////////////////////// +// Flag help auxiliary structs. + // This is help argument for absl::Flag encapsulating the string literal pointer // or pointer to function generating it as well as enum descriminating two // cases. using HelpGenFunc = std::string (*)(); -union FlagHelpSrc { - constexpr explicit FlagHelpSrc(const char* help_msg) : literal(help_msg) {} - constexpr explicit FlagHelpSrc(HelpGenFunc help_gen) : gen_func(help_gen) {} +union FlagHelpMsg { + constexpr explicit FlagHelpMsg(const char* help_msg) : literal(help_msg) {} + constexpr explicit FlagHelpMsg(HelpGenFunc help_gen) : gen_func(help_gen) {} const char* literal; HelpGenFunc gen_func; }; -enum class FlagHelpSrcKind : int8_t { kLiteral, kGenFunc }; +enum class FlagHelpKind : int8_t { kLiteral, kGenFunc }; -struct HelpInitArg { - FlagHelpSrc source; - FlagHelpSrcKind kind; +struct FlagHelpArg { + FlagHelpMsg source; + FlagHelpKind kind; }; extern const char kStrippedFlagHelp[]; @@ -172,17 +123,18 @@ constexpr const char* HelpConstexprWrap(char* p) { return p; } // evaluatable in constexpr context, but the cost is an extra function being // generated in the ABSL_FLAG code. template <typename T, int = (T::Const(), 1)> -constexpr flags_internal::HelpInitArg HelpArg(int) { - return {flags_internal::FlagHelpSrc(T::Const()), - flags_internal::FlagHelpSrcKind::kLiteral}; +constexpr FlagHelpArg HelpArg(int) { + return {FlagHelpMsg(T::Const()), FlagHelpKind::kLiteral}; } template <typename T> -constexpr flags_internal::HelpInitArg HelpArg(char) { - return {flags_internal::FlagHelpSrc(&T::NonConst), - flags_internal::FlagHelpSrcKind::kGenFunc}; +constexpr FlagHelpArg HelpArg(char) { + return {FlagHelpMsg(&T::NonConst), FlagHelpKind::kGenFunc}; } +/////////////////////////////////////////////////////////////////////////////// +// Flag default value auxiliary structs. + // Signature for the function generating the initial flag value (usually // based on default value supplied in flag's definition) using FlagDfltGenFunc = void* (*)(); @@ -197,32 +149,138 @@ union FlagDefaultSrc { enum class FlagDefaultSrcKind : int8_t { kDynamicValue, kGenFunc }; +/////////////////////////////////////////////////////////////////////////////// +// Flag current value auxiliary structs. + +// The minimum atomic size we believe to generate lock free code, i.e. all +// trivially copyable types not bigger this size generate lock free code. +static constexpr int kMinLockFreeAtomicSize = 8; + +// The same as kMinLockFreeAtomicSize but maximum atomic size. As double words +// might use two registers, we want to dispatch the logic for them. +#if defined(ABSL_FLAGS_INTERNAL_ATOMIC_DOUBLE_WORD) +static constexpr int kMaxLockFreeAtomicSize = 16; +#else +static constexpr int kMaxLockFreeAtomicSize = 8; +#endif + +// We can use atomic in cases when it fits in the register, trivially copyable +// in order to make memcpy operations. +template <typename T> +struct IsAtomicFlagTypeTrait { + static constexpr bool value = + (sizeof(T) <= kMaxLockFreeAtomicSize && + type_traits_internal::is_trivially_copyable<T>::value); +}; + +// Clang does not always produce cmpxchg16b instruction when alignment of a 16 +// bytes type is not 16. +struct alignas(16) FlagsInternalTwoWordsType { + int64_t first; + int64_t second; +}; + +constexpr bool operator==(const FlagsInternalTwoWordsType& that, + const FlagsInternalTwoWordsType& other) { + return that.first == other.first && that.second == other.second; +} +constexpr bool operator!=(const FlagsInternalTwoWordsType& that, + const FlagsInternalTwoWordsType& other) { + return !(that == other); +} + +constexpr int64_t SmallAtomicInit() { return 0xababababababababll; } + +template <typename T, typename S = void> +struct BestAtomicType { + using type = int64_t; + static constexpr int64_t AtomicInit() { return SmallAtomicInit(); } +}; + +template <typename T> +struct BestAtomicType< + T, typename std::enable_if<(kMinLockFreeAtomicSize < sizeof(T) && + sizeof(T) <= kMaxLockFreeAtomicSize), + void>::type> { + using type = FlagsInternalTwoWordsType; + static constexpr FlagsInternalTwoWordsType AtomicInit() { + return {SmallAtomicInit(), SmallAtomicInit()}; + } +}; + +struct FlagValue { + // Heap allocated value. + void* dynamic = nullptr; + // For some types, a copy of the current value is kept in an atomically + // accessible field. + union Atomics { + // Using small atomic for small types. + std::atomic<int64_t> small_atomic; + template <typename T, + typename K = typename std::enable_if< + (sizeof(T) <= kMinLockFreeAtomicSize), void>::type> + int64_t load() const { + return small_atomic.load(std::memory_order_acquire); + } + +#if defined(ABSL_FLAGS_INTERNAL_ATOMIC_DOUBLE_WORD) + // Using big atomics for big types. + std::atomic<FlagsInternalTwoWordsType> big_atomic; + template <typename T, typename K = typename std::enable_if< + (kMinLockFreeAtomicSize < sizeof(T) && + sizeof(T) <= kMaxLockFreeAtomicSize), + void>::type> + FlagsInternalTwoWordsType load() const { + return big_atomic.load(std::memory_order_acquire); + } + constexpr Atomics() + : big_atomic{FlagsInternalTwoWordsType{SmallAtomicInit(), + SmallAtomicInit()}} {} +#else + constexpr Atomics() : small_atomic{SmallAtomicInit()} {} +#endif + }; + Atomics atomics{}; +}; + +/////////////////////////////////////////////////////////////////////////////// +// Flag callback auxiliary structs. + // Signature for the mutation callback used by watched Flags // The callback is noexcept. // TODO(rogeeff): add noexcept after C++17 support is added. -using FlagCallback = void (*)(); +using FlagCallbackFunc = void (*)(); + +struct FlagCallback { + FlagCallbackFunc func; + absl::Mutex guard; // Guard for concurrent callback invocations. +}; + +/////////////////////////////////////////////////////////////////////////////// +// Flag implementation, which does not depend on flag value type. +// The class encapsulates the Flag's data and access to it. struct DynValueDeleter { - void operator()(void* ptr) const { Delete(op, ptr); } + explicit DynValueDeleter(FlagOpFn op_arg = nullptr) : op(op_arg) {} + void operator()(void* ptr) const { + if (op != nullptr) Delete(op, ptr); + } const FlagOpFn op; }; -// The class encapsulates the Flag's data and safe access to it. class FlagImpl { public: - constexpr FlagImpl(const char* name, const char* filename, - const flags_internal::FlagOpFn op, - const flags_internal::FlagMarshallingOpFn marshalling_op, - const HelpInitArg help, - const flags_internal::FlagDfltGenFunc default_value_gen) + constexpr FlagImpl(const char* name, const char* filename, FlagOpFn op, + FlagMarshallingOpFn marshalling_op, FlagHelpArg help, + FlagDfltGenFunc default_value_gen) : name_(name), filename_(filename), op_(op), marshalling_op_(marshalling_op), help_(help.source), help_source_kind_(help.kind), - def_kind_(flags_internal::FlagDefaultSrcKind::kGenFunc), + def_kind_(FlagDefaultSrcKind::kGenFunc), default_src_(default_value_gen), data_guard_{} {} @@ -237,7 +295,7 @@ class FlagImpl { bool IsSpecifiedOnCommandLine() const ABSL_LOCKS_EXCLUDED(*DataGuard()); std::string DefaultValue() const ABSL_LOCKS_EXCLUDED(*DataGuard()); std::string CurrentValue() const ABSL_LOCKS_EXCLUDED(*DataGuard()); - void Read(void* dst, const flags_internal::FlagOpFn dst_op) const + void Read(void* dst, const FlagOpFn dst_op) const ABSL_LOCKS_EXCLUDED(*DataGuard()); // Attempts to parse supplied `value` std::string. If parsing is successful, then // it replaces `dst` with the new value. @@ -247,32 +305,30 @@ class FlagImpl { #ifndef NDEBUG template <typename T> void Get(T* dst) const { - Read(dst, &flags_internal::FlagOps<T>); + Read(dst, &FlagOps<T>); } #else template <typename T, typename std::enable_if< - !flags_internal::IsAtomicFlagTypeTrait<T>::value, - int>::type = 0> + !IsAtomicFlagTypeTrait<T>::value, int>::type = 0> void Get(T* dst) const { - Read(dst, &flags_internal::FlagOps<T>); + Read(dst, &FlagOps<T>); } // Overload for `GetFlag()` for types that support lock-free reads. - template <typename T, - typename std::enable_if< - flags_internal::IsAtomicFlagTypeTrait<T>::value, int>::type = 0> + template <typename T, typename std::enable_if<IsAtomicFlagTypeTrait<T>::value, + int>::type = 0> void Get(T* dst) const { - using U = flags_internal::BestAtomicType<T>; - const typename U::type r = atomics_.template load<T>(); + using U = BestAtomicType<T>; + const typename U::type r = value_.atomics.template load<T>(); if (r != U::AtomicInit()) { std::memcpy(static_cast<void*>(dst), &r, sizeof(T)); } else { - Read(dst, &flags_internal::FlagOps<T>); + Read(dst, &FlagOps<T>); } } #endif // Mutating access methods - void Write(const void* src, const flags_internal::FlagOpFn src_op) + void Write(const void* src, const FlagOpFn src_op) ABSL_LOCKS_EXCLUDED(*DataGuard()); bool SetFromString(absl::string_view value, FlagSettingMode set_mode, ValueSource source, std::string* err) @@ -282,18 +338,18 @@ class FlagImpl { void StoreAtomic() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard()); // Interfaces to operate on callbacks. - void SetCallback(const flags_internal::FlagCallback mutation_callback) + void SetCallback(const FlagCallbackFunc mutation_callback) ABSL_LOCKS_EXCLUDED(*DataGuard()); void InvokeCallback() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard()); // Interfaces to save/restore mutable flag data template <typename T> - std::unique_ptr<flags_internal::FlagStateInterface> SaveState( - Flag<T>* flag) const ABSL_LOCKS_EXCLUDED(*DataGuard()) { + std::unique_ptr<FlagStateInterface> SaveState(Flag<T>* flag) const + ABSL_LOCKS_EXCLUDED(*DataGuard()) { T&& cur_value = flag->Get(); absl::MutexLock l(DataGuard()); - return absl::make_unique<flags_internal::FlagState<T>>( + return absl::make_unique<FlagState<T>>( flag, std::move(cur_value), modified_, on_command_line_, counter_); } bool RestoreState(const void* value, bool modified, bool on_command_line, @@ -306,35 +362,47 @@ class FlagImpl { ABSL_LOCKS_EXCLUDED(*DataGuard()); private: - // Lazy initialization of the Flag's data. - void Init(); - // Ensures that the lazily initialized data is initialized, - // and returns pointer to the mutex guarding flags data. + // Ensures that `data_guard_` is initialized and returns it. absl::Mutex* DataGuard() const ABSL_LOCK_RETURNED((absl::Mutex*)&data_guard_); // Returns heap allocated value of type T initialized with default value. std::unique_ptr<void, DynValueDeleter> MakeInitValue() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard()); + // Lazy initialization of the Flag's data. + void Init(); - // Immutable Flag's data. - // Constant configuration for a particular flag. - const char* const name_; // Flags name passed to ABSL_FLAG as second arg. - const char* const filename_; // The file name where ABSL_FLAG resides. - const FlagOpFn op_; // Type-specific handler. - const FlagMarshallingOpFn marshalling_op_; // Marshalling ops handler. - const FlagHelpSrc help_; // Help message literal or function to generate it. + // Immutable flag's state. + + // Flags name passed to ABSL_FLAG as second arg. + const char* const name_; + // The file name where ABSL_FLAG resides. + const char* const filename_; + // Type-specific handler. + const FlagOpFn op_; + // Marshalling ops handler. + const FlagMarshallingOpFn marshalling_op_; + // Help message literal or function to generate it. + const FlagHelpMsg help_; // Indicates if help message was supplied as literal or generator func. - const FlagHelpSrcKind help_source_kind_; + const FlagHelpKind help_source_kind_; // Indicates that the Flag state is initialized. std::atomic<bool> inited_{false}; - // Mutable Flag state (guarded by data_guard_). - // Additional bool to protect against multiple concurrent constructions - // of `data_guard_`. + + // Mutable flag's state (guarded by `data_guard_`). + + // Protects against multiple concurrent constructions of `data_guard_`. bool is_data_guard_inited_ = false; - // Has flag value been modified? + // Has this flag's value been modified? bool modified_ ABSL_GUARDED_BY(*DataGuard()) = false; - // Specified on command line. + // Has this flag been specified on command line. bool on_command_line_ ABSL_GUARDED_BY(*DataGuard()) = false; + + // Mutation counter + int64_t counter_ ABSL_GUARDED_BY(*DataGuard()) = 0; + + // Optional flag's callback and absl::Mutex to guard the invocations. + FlagCallback* callback_ ABSL_GUARDED_BY(*DataGuard()) = nullptr; + // If def_kind_ == kDynamicValue, default_src_ holds a dynamically allocated // value. FlagDefaultSrcKind def_kind_ ABSL_GUARDED_BY(*DataGuard()); @@ -343,46 +411,10 @@ class FlagImpl { // value via SetCommandLineOptionWithMode. def_kind_ is used to distinguish // these two cases. FlagDefaultSrc default_src_ ABSL_GUARDED_BY(*DataGuard()); - // Lazily initialized pointer to current value - void* cur_ ABSL_GUARDED_BY(*DataGuard()) = nullptr; - // Mutation counter - int64_t counter_ ABSL_GUARDED_BY(*DataGuard()) = 0; - // For some types, a copy of the current value is kept in an atomically - // accessible field. - union Atomics { - // Using small atomic for small types. - std::atomic<int64_t> small_atomic; - template <typename T, - typename K = typename std::enable_if< - (sizeof(T) <= kMinLockFreeAtomicSize), void>::type> - int64_t load() const { - return small_atomic.load(std::memory_order_acquire); - } -#if defined(ABSL_FLAGS_INTERNAL_ATOMIC_DOUBLE_WORD) - // Using big atomics for big types. - std::atomic<FlagsInternalTwoWordsType> big_atomic; - template <typename T, typename K = typename std::enable_if< - (kMinLockFreeAtomicSize < sizeof(T) && - sizeof(T) <= kMaxLockFreeAtomicSize), - void>::type> - FlagsInternalTwoWordsType load() const { - return big_atomic.load(std::memory_order_acquire); - } - constexpr Atomics() - : big_atomic{FlagsInternalTwoWordsType{SmallAtomicInit(), - SmallAtomicInit()}} {} -#else - constexpr Atomics() : small_atomic{SmallAtomicInit()} {} -#endif - }; - Atomics atomics_{}; + // Current Flag Value + FlagValue value_; - struct CallbackData { - FlagCallback func; - absl::Mutex guard; // Guard for concurrent callback invocations. - }; - CallbackData* callback_data_ ABSL_GUARDED_BY(*DataGuard()) = nullptr; // This is reserved space for an absl::Mutex to guard flag data. It will be // initialized in FlagImpl::Init via placement new. // We can't use "absl::Mutex data_guard_", since this class is not literal. @@ -393,15 +425,18 @@ class FlagImpl { alignas(absl::Mutex) mutable char data_guard_[sizeof(absl::Mutex)]; }; -// This is "unspecified" implementation of absl::Flag<T> type. +/////////////////////////////////////////////////////////////////////////////// +// The "unspecified" implementation of Flag object parameterized by the +// flag's value type. + template <typename T> class Flag final : public flags_internal::CommandLineFlag { public: constexpr Flag(const char* name, const char* filename, - const flags_internal::FlagMarshallingOpFn marshalling_op, - const flags_internal::HelpInitArg help, - const flags_internal::FlagDfltGenFunc default_value_gen) - : impl_(name, filename, &flags_internal::FlagOps<T>, marshalling_op, help, + const FlagMarshallingOpFn marshalling_op, + const FlagHelpArg help, + const FlagDfltGenFunc default_value_gen) + : impl_(name, filename, &FlagOps<T>, marshalling_op, help, default_value_gen) {} T Get() const { @@ -417,9 +452,9 @@ class Flag final : public flags_internal::CommandLineFlag { return std::move(u.value); } - void Set(const T& v) { impl_.Write(&v, &flags_internal::FlagOps<T>); } + void Set(const T& v) { impl_.Write(&v, &FlagOps<T>); } - void SetCallback(const flags_internal::FlagCallback mutation_callback) { + void SetCallback(const FlagCallbackFunc mutation_callback) { impl_.SetCallback(mutation_callback); } @@ -434,7 +469,6 @@ class Flag final : public flags_internal::CommandLineFlag { } std::string DefaultValue() const override { return impl_.DefaultValue(); } std::string CurrentValue() const override { return impl_.CurrentValue(); } - bool ValidateInputValue(absl::string_view value) const override { return impl_.ValidateInputValue(value); } @@ -442,24 +476,20 @@ class Flag final : public flags_internal::CommandLineFlag { // Interfaces to save and restore flags to/from persistent state. // Returns current flag state or nullptr if flag does not support // saving and restoring a state. - std::unique_ptr<flags_internal::FlagStateInterface> SaveState() override { + std::unique_ptr<FlagStateInterface> SaveState() override { return impl_.SaveState(this); } // Restores the flag state to the supplied state object. If there is // nothing to restore returns false. Otherwise returns true. - bool RestoreState(const flags_internal::FlagState<T>& flag_state) { + bool RestoreState(const FlagState<T>& flag_state) { return impl_.RestoreState(&flag_state.cur_value_, flag_state.modified_, flag_state.on_command_line_, flag_state.counter_); } - - bool SetFromString(absl::string_view value, - flags_internal::FlagSettingMode set_mode, - flags_internal::ValueSource source, - std::string* error) override { + bool SetFromString(absl::string_view value, FlagSettingMode set_mode, + ValueSource source, std::string* error) override { return impl_.SetFromString(value, set_mode, source, error); } - void CheckDefaultValueParsingRoundtrip() const override { impl_.CheckDefaultValueParsingRoundtrip(); } @@ -469,14 +499,10 @@ class Flag final : public flags_internal::CommandLineFlag { void Destroy() override { impl_.Destroy(); } - void Read(void* dst) const override { - impl_.Read(dst, &flags_internal::FlagOps<T>); - } - flags_internal::FlagOpFn TypeId() const override { - return &flags_internal::FlagOps<T>; - } + void Read(void* dst) const override { impl_.Read(dst, &FlagOps<T>); } + FlagOpFn TypeId() const override { return &FlagOps<T>; } - // Flag's data + // Flag's implementation with value type abstracted out. FlagImpl impl_; }; @@ -499,7 +525,7 @@ class FlagRegistrar { if (do_register) flags_internal::RegisterCommandLineFlag(flag_); } - FlagRegistrar& OnUpdate(flags_internal::FlagCallback cb) && { + FlagRegistrar& OnUpdate(FlagCallbackFunc cb) && { flag_->SetCallback(cb); return *this; } |