Chiebot-Mirror
/
abseil-cpp
mirror of https://hub.fastgit.xyz/abseil/abseil-cpp.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Export of internal Abseil changes.

Browse Source 
--
dcff7cc4eb3837d39d1e083cbf1d4f082054cbf6 by Laramie Leavitt <lar@google.com>:

Add default and fallback modes for SaltedSeedSeq::generate().

SeedSeq::generate will often be called with contiguous ranges of uint32_t.
Detect this case and use the currently direct code paths to handle it.
Otherwise use a fallback mechanism which does an additional copy.
PiperOrigin-RevId: 258853656

--
59ec88845ac2ee6567c493021b54385940d66762 by Gennadiy Rozental <rogeeff@google.com>:

Internal change

PiperOrigin-RevId: 258822137

--
eb2d1ab21f6f94c24c51c1cd3719846be259e8e7 by Abseil Team <absl-team@google.com>:

Add iOS version 11 to the mix of Apple OS versions that have various C++17 header files
but do not support them.

PiperOrigin-RevId: 258820405

--
452cea3e13b29797b2c385d7c6da7613d36bdc45 by Gennadiy Rozental <rogeeff@google.com>:

Internal change

PiperOrigin-RevId: 258802436
GitOrigin-RevId: dcff7cc4eb3837d39d1e083cbf1d4f082054cbf6
Change-Id: I2261cb58e142eb15017ef646a56710dd64f06496
pull/298/head
Abseil Team 6 years ago committed by Derek Mauro
parent 278b26058c
commit f3840bc5e3
5 changed files with 67 additions and 122 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 22
      absl/base/config.h
  2. 5
      absl/flags/flag.h
  3. 80
      absl/flags/internal/registry.cc
  4. 3
      absl/flags/internal/registry.h
  5. 63
      absl/random/internal/salted_seed_seq.h

22
absl/base/config.h
Unescape View File

@ -370,16 +370,20 @@
#error "absl endian detection needs to be set up for your compiler"
#endif
// MacOS 10.13 doesn't let you use <any>, <optional>, or <variant> even though
// the headers exist and are publicly noted to work. See
// MacOS 10.13 and iOS 10.11 don't let you use <any>, <optional>, or <variant>
// even though the headers exist and are publicly noted to work. See
// https://github.com/abseil/abseil-cpp/issues/207 and
// https://developer.apple.com/documentation/xcode_release_notes/xcode_10_release_notes
// libc++ spells out the availability requirements in the file
// llvm-project/libcxx/include/__config.
#if defined(__APPLE__) && defined(_LIBCPP_VERSION) && \
defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && \
__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101400
#define ABSL_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE 1
((defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && \
__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101400) || \
(defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && \
__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 101200))
#define ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 1
#else
#define ABSL_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE 0
#define ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 0
#endif
// ABSL_HAVE_STD_ANY
@ -391,7 +395,7 @@
#ifdef __has_include
#if __has_include(<any>) && __cplusplus >= 201703L && \
!ABSL_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE
!ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
#define ABSL_HAVE_STD_ANY 1
#endif
#endif
@ -405,7 +409,7 @@
#ifdef __has_include
#if __has_include(<optional>) && __cplusplus >= 201703L && \
!ABSL_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE
!ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
#define ABSL_HAVE_STD_OPTIONAL 1
#endif
#endif
@ -419,7 +423,7 @@
#ifdef __has_include
#if __has_include(<variant>) && __cplusplus >= 201703L && \
!ABSL_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE
!ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
#define ABSL_HAVE_STD_VARIANT 1
#endif
#endif

5
absl/flags/flag.h
Unescape View File

@ -220,9 +220,8 @@ void SetFlag(absl::Flag<T>* flag, const V& v) {
namespace absl {} \
ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value) \
ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, help) \
absl::Flag<Type> FLAGS_##name( \
ABSL_FLAG_IMPL_FLAGNAME(#name), \
&AbslFlagsWrapHelp##name, \
ABSL_CONST_INIT absl::Flag<Type> FLAGS_##name( \
ABSL_FLAG_IMPL_FLAGNAME(#name), &AbslFlagsWrapHelp##name, \
ABSL_FLAG_IMPL_FILENAME(), \
&absl::flags_internal::FlagMarshallingOps<Type>, \
&AbslFlagsInitFlag##name); \

80
absl/flags/internal/registry.cc
Unescape View File

@ -54,53 +54,6 @@ void DestroyFlag(CommandLineFlag* flag) NO_THREAD_SAFETY_ANALYSIS {
// the function will acquire it itself if needed.
// --------------------------------------------------------------------
// A map from flag pointer to CommandLineFlag*. Used when registering
// validators.
class FlagPtrMap {
public:
void Register(CommandLineFlag* flag) {
auto& vec = buckets_[BucketForFlag(flag->cur)];
if (vec.size() == vec.capacity()) {
// Bypass default 2x growth factor with 1.25 so we have fuller vectors.
// This saves 4% memory compared to default growth.
vec.reserve(vec.size() * 1.25 + 0.5);
}
vec.push_back(flag);
}
CommandLineFlag* FindByPtr(const void* flag_ptr) {
const auto& flag_vector = buckets_[BucketForFlag(flag_ptr)];
for (CommandLineFlag* entry : flag_vector) {
if (entry->cur == flag_ptr) {
return entry;
}
}
return nullptr;
}
private:
// Instead of std::map, we use a custom hash table where each bucket stores
// flags in a vector. This reduces memory usage 40% of the memory that would
// have been used by std::map.
//
// kNumBuckets was picked as a large enough prime. As of writing this code, a
// typical large binary has ~8k (old-style) flags, and this would gives
// buckets with roughly 50 elements each.
//
// Note that reads to this hash table are rare: exactly as many as we have
// flags with validators. As of writing, a typical binary only registers 52
// validated flags.
static constexpr size_t kNumBuckets = 163;
std::vector<CommandLineFlag*> buckets_[kNumBuckets];
static int BucketForFlag(const void* ptr) {
// Modulo a prime is good enough here. On a real program, bucket size stddev
// after registering 8k flags is ~5 (mean size at 51).
return reinterpret_cast<uintptr_t>(ptr) % kNumBuckets;
}
};
constexpr size_t FlagPtrMap::kNumBuckets;
class FlagRegistry {
public:
FlagRegistry() = default;
@ -111,9 +64,7 @@ class FlagRegistry {
}
// Store a flag in this registry. Takes ownership of *flag.
// If ptr is non-null, the flag can later be found by calling
// FindFlagViaPtrLocked(ptr).
void RegisterFlag(CommandLineFlag* flag, const void* ptr);
void RegisterFlag(CommandLineFlag* flag);
void Lock() EXCLUSIVE_LOCK_FUNCTION(lock_) { lock_.Lock(); }
void Unlock() UNLOCK_FUNCTION(lock_) { lock_.Unlock(); }
@ -126,9 +77,6 @@ class FlagRegistry {
// found or not retired. Does not emit a warning.
CommandLineFlag* FindRetiredFlagLocked(absl::string_view name);
// Returns the flag object whose current-value is stored at flag_ptr.
CommandLineFlag* FindFlagViaPtrLocked(const void* flag_ptr);
static FlagRegistry* GlobalRegistry(); // returns a singleton registry
private:
@ -142,8 +90,6 @@ class FlagRegistry {
using FlagConstIterator = FlagMap::const_iterator;
FlagMap flags_;
FlagPtrMap flag_ptr_map_;
absl::Mutex lock_;
// Disallow
@ -169,7 +115,7 @@ class FlagRegistryLock {
} // namespace
void FlagRegistry::RegisterFlag(CommandLineFlag* flag, const void* ptr) {
void FlagRegistry::RegisterFlag(CommandLineFlag* flag) {
FlagRegistryLock registry_lock(this);
std::pair<FlagIterator, bool> ins =
flags_.insert(FlagMap::value_type(flag->Name(), flag));
@ -217,11 +163,6 @@ void FlagRegistry::RegisterFlag(CommandLineFlag* flag, const void* ptr) {
// All cases above are fatal, except for the retired flags.
std::exit(1);
}
if (ptr != nullptr) {
// This must be the first time we're seeing this flag.
flag_ptr_map_.Register(flag);
}
}
CommandLineFlag* FlagRegistry::FindFlagLocked(absl::string_view name) {
@ -247,10 +188,6 @@ CommandLineFlag* FlagRegistry::FindRetiredFlagLocked(absl::string_view name) {
return i->second;
}
CommandLineFlag* FlagRegistry::FindFlagViaPtrLocked(const void* flag_ptr) {
return flag_ptr_map_.FindByPtr(flag_ptr);
}
// --------------------------------------------------------------------
// FlagSaver
// FlagSaverImpl
@ -430,13 +367,6 @@ CommandLineFlag* FindCommandLineFlag(absl::string_view name) {
return registry->FindFlagLocked(name);
}
CommandLineFlag* FindCommandLineV1Flag(const void* flag_ptr) {
FlagRegistry* const registry = FlagRegistry::GlobalRegistry();
FlagRegistryLock frl(registry);
return registry->FindFlagViaPtrLocked(flag_ptr);
}
CommandLineFlag* FindRetiredFlag(absl::string_view name) {
FlagRegistry* const registry = FlagRegistry::GlobalRegistry();
FlagRegistryLock frl(registry);
@ -477,8 +407,8 @@ void GetAllFlags(std::vector<CommandLineFlagInfo>* OUTPUT) {
// --------------------------------------------------------------------
bool RegisterCommandLineFlag(CommandLineFlag* flag, const void* ptr) {
FlagRegistry::GlobalRegistry()->RegisterFlag(flag, ptr);
bool RegisterCommandLineFlag(CommandLineFlag* flag) {
FlagRegistry::GlobalRegistry()->RegisterFlag(flag);
return true;
}
@ -492,7 +422,7 @@ bool Retire(FlagOpFn ops, FlagMarshallingOpFn marshalling_ops,
/*filename_arg=*/"RETIRED", ops, marshalling_ops,
/*initial_value_gen=*/nullptr,
/*retired_arg=*/true, nullptr, nullptr);
FlagRegistry::GlobalRegistry()->RegisterFlag(flag, nullptr);
FlagRegistry::GlobalRegistry()->RegisterFlag(flag);
return true;
}

3
absl/flags/internal/registry.h
Unescape View File

@ -57,7 +57,6 @@ void FillCommandLineFlagInfo(CommandLineFlag* flag,
//-----------------------------------------------------------------------------
CommandLineFlag* FindCommandLineFlag(absl::string_view name);
CommandLineFlag* FindCommandLineV1Flag(const void* flag_ptr);
CommandLineFlag* FindRetiredFlag(absl::string_view name);
// Executes specified visitor for each non-retired flag in the registry.
@ -74,7 +73,7 @@ void GetAllFlags(std::vector<CommandLineFlagInfo>* OUTPUT);
//-----------------------------------------------------------------------------
bool RegisterCommandLineFlag(CommandLineFlag*, const void* ptr = nullptr);
bool RegisterCommandLineFlag(CommandLineFlag*);
//-----------------------------------------------------------------------------
// Retired registrations:

63
absl/random/internal/salted_seed_seq.h
Unescape View File

@ -64,10 +64,15 @@ class SaltedSeedSeq {
template <typename RandomAccessIterator>
void generate(RandomAccessIterator begin, RandomAccessIterator end) {
// The common case is that generate is called with ContiguousIterators
// to uint arrays. Such contiguous memory regions may be optimized,
// which we detect here.
using tag = absl::conditional_t<
(std::is_pointer<RandomAccessIterator>::value &&
std::is_same<absl::decay_t<decltype(*begin)>, uint32_t>::value),
ContiguousAndUint32Tag, DefaultTag>;
if (begin != end) {
generate_impl(
std::integral_constant<bool, sizeof(*begin) == sizeof(uint32_t)>{},
begin, end);
generate_impl(begin, end, tag{});
}
}
@ -79,19 +84,12 @@ class SaltedSeedSeq {
size_t size() const { return seq_->size(); }
private:
// The common case for generate is that it is called with iterators over a
// 32-bit value buffer. These can be reinterpreted to a uint32_t and we can
// operate on them as such.
template <typename RandomAccessIterator>
void generate_impl(std::integral_constant<bool, true> /*is_32bit*/,
RandomAccessIterator begin, RandomAccessIterator end) {
seq_->generate(begin, end);
const uint32_t salt = absl::random_internal::GetSaltMaterial().value_or(0);
auto buffer = absl::MakeSpan(begin, end);
MixIntoSeedMaterial(
absl::MakeConstSpan(&salt, 1),
absl::MakeSpan(reinterpret_cast<uint32_t*>(buffer.data()),
buffer.size()));
struct ContiguousAndUint32Tag {};
struct DefaultTag {};
// Generate which requires the iterators are contiguous pointers to uint32_t.
void generate_impl(uint32_t* begin, uint32_t* end, ContiguousAndUint32Tag) {
generate_contiguous(absl::MakeSpan(begin, end));
}
// The uncommon case for generate is that it is called with iterators over
@ -99,17 +97,32 @@ class SaltedSeedSeq {
// case we allocate a temporary 32-bit buffer and then copy-assign back
// to the initial inputs.
template <typename RandomAccessIterator>
void generate_impl(std::integral_constant<bool, false> /*is_32bit*/,
RandomAccessIterator begin, RandomAccessIterator end) {
// Allocate a temporary buffer, seed, and then copy.
absl::InlinedVector<uint32_t, 8> data(std::distance(begin, end), 0);
generate_impl(std::integral_constant<bool, true>{}, data.begin(),
data.end());
std::copy(data.begin(), data.end(), begin);
void generate_impl(RandomAccessIterator begin, RandomAccessIterator end,
DefaultTag) {
return generate_and_copy(std::distance(begin, end), begin);
}
// Fills the initial seed buffer the underlying SSeq::generate() call,
// mixing in the salt material.
void generate_contiguous(absl::Span<uint32_t> buffer) {
seq_->generate(buffer.begin(), buffer.end());
const uint32_t salt = absl::random_internal::GetSaltMaterial().value_or(0);
MixIntoSeedMaterial(absl::MakeConstSpan(&salt, 1), buffer);
}
// Allocates a seed buffer of `n` elements, generates the seed, then
// copies the result into the `out` iterator.
template <typename Iterator>
void generate_and_copy(size_t n, Iterator out) {
// Allocate a temporary buffer, generate, and then copy.
absl::InlinedVector<uint32_t, 8> data(n, 0);
generate_contiguous(absl::MakeSpan(data.data(), data.size()));
std::copy(data.begin(), data.end(), out);
}
// Because [rand.req.seedseq] is not copy-constructible, copy-assignable nor
// movable so we wrap it with unique pointer to be able to move SaltedSeedSeq.
// Because [rand.req.seedseq] is not required to be copy-constructible,
// copy-assignable nor movable, we wrap it with unique pointer to be able
// to move SaltedSeedSeq.
std::unique_ptr<SSeq> seq_;
};

Write Preview
Loading…
Cancel
Save