about summary refs log tree commit diff
path: root/absl/flags
diff options
context:
space:
mode:
Diffstat (limited to 'absl/flags')
-rw-r--r--absl/flags/BUILD.bazel2
-rw-r--r--absl/flags/flag.h12
-rw-r--r--absl/flags/flag_test.cc6
-rw-r--r--absl/flags/internal/flag.cc47
-rw-r--r--absl/flags/internal/flag.h372
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;
   }