Export of internal Abseil changes

--
3e60f355db5afd7a864591d81a6c383b6c0a0780 by Samuel Benzaquen <sbenza@google.com>:

Internal change

PiperOrigin-RevId: 272531442

--
6d189240b8cebe3a390c730de491156d03049229 by Andy Getzendanner <durandal@google.com>:

Fix AtomicHook init-order fiasco under MSVC 2019.

On this platform, constexpr static init sometimes happens after dynamic init =/.  When it does, we should not zero hook_ (overwriting the value written there by dynamic init); instead we should leave it alone.  This works even when constexpr static init goes first since all uses of AtomicHook should have static storage duration and be zero-initialized.

https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html

PiperOrigin-RevId: 272525226

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

exclude emscripten from running tests involving long doubles

PiperOrigin-RevId: 272497628
GitOrigin-RevId: 3e60f355db5afd7a864591d81a6c383b6c0a0780
Change-Id: I3c8a8f5acaf7652a06ef40cf028ef5d2e142f81b
This commit is contained in:
Abseil Team 2019-10-02 15:20:57 -07:00 committed by CJ Johnson
parent aad33fefaa
commit 25597bdfc1
12 changed files with 166 additions and 12 deletions

View file

@ -207,6 +207,19 @@ cc_library(
], ],
) )
cc_library(
name = "atomic_hook_test_helper",
testonly = 1,
srcs = ["internal/atomic_hook_test_helper.cc"],
hdrs = ["internal/atomic_hook_test_helper.h"],
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
deps = [
":atomic_hook",
":core_headers",
],
)
cc_test( cc_test(
name = "atomic_hook_test", name = "atomic_hook_test",
size = "small", size = "small",
@ -215,6 +228,7 @@ cc_test(
linkopts = ABSL_DEFAULT_LINKOPTS, linkopts = ABSL_DEFAULT_LINKOPTS,
deps = [ deps = [
":atomic_hook", ":atomic_hook",
":atomic_hook_test_helper",
":core_headers", ":core_headers",
"@com_google_googletest//:gtest_main", "@com_google_googletest//:gtest_main",
], ],

View file

@ -254,6 +254,19 @@ absl_cc_test(
gtest_main gtest_main
) )
absl_cc_library(
NAME
atomic_hook_test_helper
SRCS
"internal/atomic_hook_test_helper.cc"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::atomic_hook
absl::core_headers
TESTONLY
)
absl_cc_test( absl_cc_test(
NAME NAME
atomic_hook_test atomic_hook_test
@ -262,8 +275,10 @@ absl_cc_test(
COPTS COPTS
${ABSL_TEST_COPTS} ${ABSL_TEST_COPTS}
DEPS DEPS
absl::atomic_hook_test_helper
absl::atomic_hook absl::atomic_hook
absl::core_headers absl::core_headers
gmock
gtest_main gtest_main
) )

View file

@ -11,7 +11,6 @@
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
//
#ifndef ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_ #ifndef ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
#define ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_ #define ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
@ -23,8 +22,10 @@
#ifdef _MSC_FULL_VER #ifdef _MSC_FULL_VER
#define ABSL_HAVE_WORKING_ATOMIC_POINTER 0 #define ABSL_HAVE_WORKING_ATOMIC_POINTER 0
#define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 0
#else #else
#define ABSL_HAVE_WORKING_ATOMIC_POINTER 1 #define ABSL_HAVE_WORKING_ATOMIC_POINTER 1
#define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 1
#endif #endif
namespace absl { namespace absl {
@ -33,16 +34,17 @@ namespace base_internal {
template <typename T> template <typename T>
class AtomicHook; class AtomicHook;
// AtomicHook is a helper class, templatized on a raw function pointer type, for // `AtomicHook` is a helper class, templatized on a raw function pointer type,
// implementing Abseil customization hooks. It is a callable object that // for implementing Abseil customization hooks. It is a callable object that
// dispatches to the registered hook. // dispatches to the registered hook. Objects of type `AtomicHook` must have
// static or thread storage duration.
// //
// A default constructed object performs a no-op (and returns a default // A default constructed object performs a no-op (and returns a default
// constructed object) if no hook has been registered. // constructed object) if no hook has been registered.
// //
// Hooks can be pre-registered via constant initialization, for example, // Hooks can be pre-registered via constant initialization, for example,
// ABSL_CONST_INIT static AtomicHook<void(*)()> my_hook(DefaultAction); // `ABSL_CONST_INIT static AtomicHook<void(*)()> my_hook(DefaultAction);`
// and then changed at runtime via a call to Store(). // and then changed at runtime via a call to `Store()`.
// //
// Reads and writes guarantee memory_order_acquire/memory_order_release // Reads and writes guarantee memory_order_acquire/memory_order_release
// semantics. // semantics.
@ -57,12 +59,19 @@ class AtomicHook<ReturnType (*)(Args...)> {
// Constructs an object that by default dispatches to/returns the // Constructs an object that by default dispatches to/returns the
// pre-registered default_fn when no hook has been registered at runtime. // pre-registered default_fn when no hook has been registered at runtime.
#if ABSL_HAVE_WORKING_ATOMIC_POINTER #if ABSL_HAVE_WORKING_ATOMIC_POINTER && ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
explicit constexpr AtomicHook(FnPtr default_fn) explicit constexpr AtomicHook(FnPtr default_fn)
: hook_(default_fn), default_fn_(default_fn) {} : hook_(default_fn), default_fn_(default_fn) {}
#else #else
// On MSVC, this function sometimes executes after dynamic initiazliation =(.
// If a non-zero `hook_` has been installed by a dynamic initializer, we want
// to preserve it. If not, `hook_` will be zero initialized and we have no
// need to set it to `kUninitialized`.
// https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html
explicit constexpr AtomicHook(FnPtr default_fn) explicit constexpr AtomicHook(FnPtr default_fn)
: hook_(kUninitialized), default_fn_(default_fn) {} : /* hook_(deliberately omitted), */ default_fn_(default_fn) {
static_assert(kUninitialized == 0, "here we rely on zero-initialization");
}
#endif #endif
// Stores the provided function pointer as the value for this hook. // Stores the provided function pointer as the value for this hook.
@ -158,6 +167,7 @@ class AtomicHook<ReturnType (*)(Args...)> {
}; };
#undef ABSL_HAVE_WORKING_ATOMIC_POINTER #undef ABSL_HAVE_WORKING_ATOMIC_POINTER
#undef ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
} // namespace base_internal } // namespace base_internal
} // namespace absl } // namespace absl

View file

@ -14,11 +14,15 @@
#include "absl/base/internal/atomic_hook.h" #include "absl/base/internal/atomic_hook.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "absl/base/attributes.h" #include "absl/base/attributes.h"
#include "absl/base/internal/atomic_hook_test_helper.h"
namespace { namespace {
using ::testing::Eq;
int value = 0; int value = 0;
void TestHook(int x) { value = x; } void TestHook(int x) { value = x; }
@ -67,4 +71,24 @@ TEST(AtomicHookTest, WithDefaultFunction) {
EXPECT_EQ(value, 2); EXPECT_EQ(value, 2);
} }
ABSL_CONST_INIT int override_func_calls = 0;
void OverrideFunc() { override_func_calls++; }
static struct OverrideInstaller {
OverrideInstaller() { absl::atomic_hook_internal::func.Store(OverrideFunc); }
} override_installer;
TEST(AtomicHookTest, DynamicInitFromAnotherTU) {
// MSVC 14.2 doesn't do constexpr static init correctly; in particular it
// tends to sequence static init (i.e. defaults) of `AtomicHook` objects
// after their dynamic init (i.e. overrides), overwriting whatever value was
// written during dynamic init. This regression test validates the fix.
// https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html
EXPECT_THAT(absl::atomic_hook_internal::default_func_calls, Eq(0));
EXPECT_THAT(override_func_calls, Eq(0));
absl::atomic_hook_internal::func();
EXPECT_THAT(absl::atomic_hook_internal::default_func_calls, Eq(0));
EXPECT_THAT(override_func_calls, Eq(1));
EXPECT_THAT(absl::atomic_hook_internal::func.Load(), Eq(OverrideFunc));
}
} // namespace } // namespace

View file

@ -0,0 +1,29 @@
// Copyright 2017 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/base/internal/atomic_hook_test_helper.h"
#include "absl/base/attributes.h"
#include "absl/base/internal/atomic_hook.h"
namespace absl {
namespace atomic_hook_internal {
ABSL_CONST_INIT absl::base_internal::AtomicHook<VoidF> func(DefaultFunc);
ABSL_CONST_INIT int default_func_calls = 0;
void DefaultFunc() { default_func_calls++; }
void RegisterFunc(VoidF f) { func.Store(f); }
} // namespace atomic_hook_internal
} // namespace absl

View file

@ -0,0 +1,32 @@
// Copyright 2017 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.
#ifndef ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_
#define ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_
#include "absl/base/internal/atomic_hook.h"
namespace absl {
namespace atomic_hook_internal {
using VoidF = void (*)();
extern absl::base_internal::AtomicHook<VoidF> func;
extern int default_func_calls;
void DefaultFunc();
void RegisterFunc(VoidF func);
} // namespace atomic_hook_internal
} // namespace absl
#endif // ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_

View file

@ -228,8 +228,26 @@ int64_t HashtablezSampler::Iterate(
return dropped_samples_.load(std::memory_order_relaxed); return dropped_samples_.load(std::memory_order_relaxed);
} }
static bool ShouldForceSampling() {
enum ForceState {
kDontForce,
kForce,
kUninitialized
};
ABSL_CONST_INIT static std::atomic<ForceState> global_state{
kUninitialized};
ForceState state = global_state.load(std::memory_order_relaxed);
if (ABSL_PREDICT_TRUE(state == kDontForce)) return false;
if (state == kUninitialized) {
state = AbslContainerInternalSampleEverything() ? kForce : kDontForce;
global_state.store(state, std::memory_order_relaxed);
}
return state == kForce;
}
HashtablezInfo* SampleSlow(int64_t* next_sample) { HashtablezInfo* SampleSlow(int64_t* next_sample) {
if (kAbslContainerInternalSampleEverything) { if (ABSL_PREDICT_FALSE(ShouldForceSampling())) {
*next_sample = 1; *next_sample = 1;
return HashtablezSampler::Global().Register(); return HashtablezSampler::Global().Register();
} }

View file

@ -280,7 +280,7 @@ void SetHashtablezMaxSamples(int32_t max);
// initialization of static storage duration objects. // initialization of static storage duration objects.
// The definition of this constant is weak, which allows us to inject a // The definition of this constant is weak, which allows us to inject a
// different value for it at link time. // different value for it at link time.
extern "C" const bool kAbslContainerInternalSampleEverything; extern "C" bool AbslContainerInternalSampleEverything();
} // namespace container_internal } // namespace container_internal
} // namespace absl } // namespace absl

View file

@ -20,8 +20,9 @@ namespace absl {
namespace container_internal { namespace container_internal {
// See hashtablez_sampler.h for details. // See hashtablez_sampler.h for details.
extern "C" ABSL_ATTRIBUTE_WEAK const bool extern "C" ABSL_ATTRIBUTE_WEAK bool AbslContainerInternalSampleEverything() {
kAbslContainerInternalSampleEverything = false; return false;
}
} // namespace container_internal } // namespace container_internal
} // namespace absl } // namespace absl

View file

@ -46,7 +46,11 @@ using absl::random_internal::kChiSquared;
template <typename RealType> template <typename RealType>
class ExponentialDistributionTypedTest : public ::testing::Test {}; class ExponentialDistributionTypedTest : public ::testing::Test {};
#if defined(__EMSCRIPTEN__)
using RealTypes = ::testing::Types<float, double>;
#else
using RealTypes = ::testing::Types<float, double, long double>; using RealTypes = ::testing::Types<float, double, long double>;
#endif // defined(__EMSCRIPTEN__)
TYPED_TEST_CASE(ExponentialDistributionTypedTest, RealTypes); TYPED_TEST_CASE(ExponentialDistributionTypedTest, RealTypes);
TYPED_TEST(ExponentialDistributionTypedTest, SerializeTest) { TYPED_TEST(ExponentialDistributionTypedTest, SerializeTest) {

View file

@ -272,6 +272,7 @@ TEST(IOStreamStateSaver, RoundTripDoubles) {
} }
} }
#if !defined(__EMSCRIPTEN__)
TEST(IOStreamStateSaver, RoundTripLongDoubles) { TEST(IOStreamStateSaver, RoundTripLongDoubles) {
// Technically, C++ only guarantees that long double is at least as large as a // Technically, C++ only guarantees that long double is at least as large as a
// double. Practically it varies from 64-bits to 128-bits. // double. Practically it varies from 64-bits to 128-bits.
@ -349,6 +350,7 @@ TEST(IOStreamStateSaver, RoundTripLongDoubles) {
} }
} }
} }
#endif // !defined(__EMSCRIPTEN__)
TEST(StrToDTest, DoubleMin) { TEST(StrToDTest, DoubleMin) {
const char kV[] = "2.22507385850720138e-308"; const char kV[] = "2.22507385850720138e-308";

View file

@ -54,7 +54,12 @@ namespace {
template <typename RealType> template <typename RealType>
class UniformRealDistributionTest : public ::testing::Test {}; class UniformRealDistributionTest : public ::testing::Test {};
#if defined(__EMSCRIPTEN__)
using RealTypes = ::testing::Types<float, double>;
#else
using RealTypes = ::testing::Types<float, double, long double>; using RealTypes = ::testing::Types<float, double, long double>;
#endif // defined(__EMSCRIPTEN__)
TYPED_TEST_SUITE(UniformRealDistributionTest, RealTypes); TYPED_TEST_SUITE(UniformRealDistributionTest, RealTypes);
TYPED_TEST(UniformRealDistributionTest, ParamSerializeTest) { TYPED_TEST(UniformRealDistributionTest, ParamSerializeTest) {