Changes imported from Abseil "staging" branch:
- f2c4c517f14afa7a3fac6b35588381462f02dec3 Rollback release of algorithm benchmark. by Alex Strelnikov <strel@google.com> - ec8a9569ac36d58a4fff2f9fc851e5a9474d274a Change AllocInspector to ConstructorTracker by Jon Cohen <cohenjon@google.com> - 6f94f3d65a29b11c692948d23c0fc530f015cd53 Update WORKSPACE for C++ microbenchmarks and release algo... by Alex Strelnikov <strel@google.com> - 79187dd7cec821e47cdd751db71bb23be2b8cef7 Define copy assignment operator for ThrowingAllocator. by Xiaoyi Zhang <zhangxy@google.com> - 8bf5e1048dd7788f4bce60376f5c3992f8525d88 Fix incorrect format string used in str_cat_test.cc code,... by Jorg Brown <jorg@google.com> - 19c51194e6638f05cbb364c6684f14dc7ed1a323 Fix symbolize_test under sanitizers. by Derek Mauro <dmauro@google.com> - d68119cfb845a9d460fc3fd4aae1d2ea7d79ee21 Internal change. by Derek Mauro <dmauro@google.com> - 4ca54d336c7a18050c95c6c1a859f2a0530e1cde Internal change. by Shaindel Schwartz <shaindel@google.com> GitOrigin-RevId: f2c4c517f14afa7a3fac6b35588381462f02dec3 Change-Id: If61a65d65f03b26d6776710040780ddd1c52c4de
This commit is contained in:
parent
4e2e6c5c00
commit
70b5fa948d
7 changed files with 59 additions and 44 deletions
|
@ -44,7 +44,7 @@ class ThrowingValueTest : public ::testing::Test {
|
|||
void SetUp() override { UnsetCountdown(); }
|
||||
|
||||
private:
|
||||
AllocInspector clouseau_;
|
||||
ConstructorTracker clouseau_;
|
||||
};
|
||||
|
||||
TEST_F(ThrowingValueTest, Throws) {
|
||||
|
@ -279,7 +279,7 @@ class ThrowingAllocatorTest : public ::testing::Test {
|
|||
void SetUp() override { UnsetCountdown(); }
|
||||
|
||||
private:
|
||||
AllocInspector borlu_;
|
||||
ConstructorTracker borlu_;
|
||||
};
|
||||
|
||||
TEST_F(ThrowingAllocatorTest, MemoryManagement) {
|
||||
|
@ -652,22 +652,22 @@ struct Tracked : private exceptions_internal::TrackedObject {
|
|||
Tracked() : TrackedObject(ABSL_PRETTY_FUNCTION) {}
|
||||
};
|
||||
|
||||
TEST(AllocInspectorTest, Pass) {
|
||||
AllocInspector javert;
|
||||
TEST(ConstructorTrackerTest, Pass) {
|
||||
ConstructorTracker javert;
|
||||
Tracked t;
|
||||
}
|
||||
|
||||
TEST(AllocInspectorTest, NotDestroyed) {
|
||||
TEST(ConstructorTrackerTest, NotDestroyed) {
|
||||
absl::aligned_storage_t<sizeof(Tracked), alignof(Tracked)> storage;
|
||||
EXPECT_NONFATAL_FAILURE(
|
||||
{
|
||||
AllocInspector gadget;
|
||||
ConstructorTracker gadget;
|
||||
new (&storage) Tracked;
|
||||
},
|
||||
"not destroyed");
|
||||
}
|
||||
|
||||
TEST(AllocInspectorTest, DestroyedTwice) {
|
||||
TEST(ConstructorTrackerTest, DestroyedTwice) {
|
||||
EXPECT_NONFATAL_FAILURE(
|
||||
{
|
||||
Tracked t;
|
||||
|
@ -676,7 +676,7 @@ TEST(AllocInspectorTest, DestroyedTwice) {
|
|||
"destroyed improperly");
|
||||
}
|
||||
|
||||
TEST(AllocInspectorTest, ConstructedTwice) {
|
||||
TEST(ConstructorTrackerTest, ConstructedTwice) {
|
||||
absl::aligned_storage_t<sizeof(Tracked), alignof(Tracked)> storage;
|
||||
EXPECT_NONFATAL_FAILURE(
|
||||
{
|
||||
|
@ -697,5 +697,12 @@ TEST(ThrowingValueTraitsTest, RelationalOperators) {
|
|||
EXPECT_TRUE((std::is_convertible<decltype(a >= b), bool>::value));
|
||||
}
|
||||
|
||||
TEST(ThrowingAllocatorTraitsTest, Assignablility) {
|
||||
EXPECT_TRUE(std::is_move_assignable<ThrowingAllocator<int>>::value);
|
||||
EXPECT_TRUE(std::is_copy_assignable<ThrowingAllocator<int>>::value);
|
||||
EXPECT_TRUE(std::is_nothrow_move_assignable<ThrowingAllocator<int>>::value);
|
||||
EXPECT_TRUE(std::is_nothrow_copy_assignable<ThrowingAllocator<int>>::value);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
} // namespace absl
|
||||
|
|
|
@ -37,7 +37,7 @@
|
|||
namespace absl {
|
||||
struct InternalAbslNamespaceFinder {};
|
||||
|
||||
struct AllocInspector;
|
||||
struct ConstructorTracker;
|
||||
|
||||
// A configuration enum for Throwing*. Operations whose flags are set will
|
||||
// throw, everything else won't. This isn't meant to be exhaustive, more flags
|
||||
|
@ -125,7 +125,7 @@ class TrackedObject {
|
|||
}
|
||||
}
|
||||
|
||||
friend struct ::absl::AllocInspector;
|
||||
friend struct ::absl::ConstructorTracker;
|
||||
};
|
||||
|
||||
template <typename Factory>
|
||||
|
@ -594,6 +594,8 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
|
|||
const ThrowingAllocator<U, Flags>& other) noexcept
|
||||
: TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(other.State()) {}
|
||||
|
||||
// According to C++11 standard [17.6.3.5], Table 28, the move/copy ctors of
|
||||
// allocator shall not exit via an exception, thus they are marked noexcept.
|
||||
ThrowingAllocator(const ThrowingAllocator& other) noexcept
|
||||
: TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(other.State()) {}
|
||||
|
||||
|
@ -607,6 +609,11 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
|
|||
|
||||
~ThrowingAllocator() noexcept = default;
|
||||
|
||||
ThrowingAllocator& operator=(const ThrowingAllocator& other) noexcept {
|
||||
dummy_ = other.State();
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename U>
|
||||
ThrowingAllocator& operator=(
|
||||
const ThrowingAllocator<U, Flags>& other) noexcept {
|
||||
|
@ -704,11 +711,11 @@ int ThrowingAllocator<T, Throws>::next_id_ = 0;
|
|||
// Inspects the constructions and destructions of anything inheriting from
|
||||
// TrackedObject. Place this as a member variable in a test fixture to ensure
|
||||
// that every ThrowingValue was constructed and destroyed correctly. This also
|
||||
// allows us to safely "leak" TrackedObjects, as AllocInspector will destroy
|
||||
// allows us to safely "leak" TrackedObjects, as ConstructorTracker will destroy
|
||||
// everything left over in its destructor.
|
||||
struct AllocInspector {
|
||||
AllocInspector() = default;
|
||||
~AllocInspector() {
|
||||
struct ConstructorTracker {
|
||||
ConstructorTracker() = default;
|
||||
~ConstructorTracker() {
|
||||
auto& allocs = exceptions_internal::TrackedObject::GetAllocs();
|
||||
for (const auto& kv : allocs) {
|
||||
ADD_FAILURE() << "Object at address " << static_cast<void*>(kv.first)
|
||||
|
@ -720,7 +727,7 @@ struct AllocInspector {
|
|||
|
||||
// Tests for resource leaks by attempting to construct a T using args repeatedly
|
||||
// until successful, using the countdown method. Side effects can then be
|
||||
// tested for resource leaks. If an AllocInspector is present in the test
|
||||
// tested for resource leaks. If a ConstructorTracker is present in the test
|
||||
// fixture, then this will also test that memory resources are not leaked as
|
||||
// long as T allocates TrackedObjects.
|
||||
template <typename T, typename... Args>
|
||||
|
|
|
@ -70,7 +70,6 @@ cc_test(
|
|||
":symbolize",
|
||||
"//absl/base",
|
||||
"//absl/base:core_headers",
|
||||
"//absl/base:malloc_extension",
|
||||
"//absl/memory",
|
||||
"@com_google_googletest//:gtest",
|
||||
],
|
||||
|
|
|
@ -27,7 +27,6 @@
|
|||
#include "gtest/gtest.h"
|
||||
#include "absl/base/attributes.h"
|
||||
#include "absl/base/casts.h"
|
||||
#include "absl/base/internal/malloc_extension.h"
|
||||
#include "absl/base/internal/per_thread_tls.h"
|
||||
#include "absl/base/internal/raw_logging.h"
|
||||
#include "absl/base/optimization.h"
|
||||
|
@ -192,14 +191,13 @@ static const char *SymbolizeStackConsumption(void *pc, int *stack_consumed) {
|
|||
|
||||
static int GetStackConsumptionUpperLimit() {
|
||||
// Symbolize stack consumption should be within 2kB.
|
||||
const int kStackConsumptionUpperLimit = 2048;
|
||||
// Account for ASan/TSan instrumentation requiring additional stack space.
|
||||
size_t multiplier = 0;
|
||||
if (absl::base_internal::MallocExtension::instance()->GetNumericProperty(
|
||||
"dynamic_tool.stack_size_multiplier", &multiplier)) {
|
||||
return kStackConsumptionUpperLimit * multiplier;
|
||||
}
|
||||
return kStackConsumptionUpperLimit;
|
||||
int stack_consumption_upper_limit = 2048;
|
||||
#if defined(ADDRESS_SANITIZER) || defined(MEMORY_SANITIZER) || \
|
||||
defined(THREAD_SANITIZER)
|
||||
// Account for sanitizer instrumentation requiring additional stack space.
|
||||
stack_consumption_upper_limit *= 5;
|
||||
#endif
|
||||
return stack_consumption_upper_limit;
|
||||
}
|
||||
|
||||
TEST(Symbolize, SymbolizeStackConsumption) {
|
||||
|
|
|
@ -486,7 +486,7 @@ void CheckHexDec32(uint32_t uv) {
|
|||
if (sizeof(v) == sizeof(&v)) {
|
||||
auto uintptr = static_cast<uintptr_t>(v);
|
||||
void* ptr = reinterpret_cast<void*>(uintptr);
|
||||
CheckHex(ptr, "%llx", "%0*llx", "%*llx");
|
||||
CheckHex(ptr, "%x", "%0*x", "%*x");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -854,7 +854,7 @@ Time FromChrono(const std::chrono::system_clock::time_point& tp);
|
|||
// absl::Time t = absl::FromTimeT(123);
|
||||
// auto tp = absl::ToChronoTime(t);
|
||||
// // tp == std::chrono::system_clock::from_time_t(123);
|
||||
std::chrono::system_clock::time_point ToChronoTime(absl::Time);
|
||||
std::chrono::system_clock::time_point ToChronoTime(Time);
|
||||
|
||||
// RFC3339_full
|
||||
// RFC3339_sec
|
||||
|
@ -1070,13 +1070,16 @@ inline bool LoadTimeZone(const std::string& name, TimeZone* tz) {
|
|||
// Note: If the absolute value of the offset is greater than 24 hours
|
||||
// you'll get UTC (i.e., no offset) instead.
|
||||
inline TimeZone FixedTimeZone(int seconds) {
|
||||
return TimeZone(cctz::fixed_time_zone(std::chrono::seconds(seconds)));
|
||||
return TimeZone(
|
||||
cctz::fixed_time_zone(std::chrono::seconds(seconds)));
|
||||
}
|
||||
|
||||
// UTCTimeZone()
|
||||
//
|
||||
// Convenience method returning the UTC time zone.
|
||||
inline TimeZone UTCTimeZone() { return TimeZone(cctz::utc_time_zone()); }
|
||||
inline TimeZone UTCTimeZone() {
|
||||
return TimeZone(cctz::utc_time_zone());
|
||||
}
|
||||
|
||||
// LocalTimeZone()
|
||||
//
|
||||
|
@ -1084,7 +1087,9 @@ inline TimeZone UTCTimeZone() { return TimeZone(cctz::utc_time_zone()); }
|
|||
// no configured local zone. Warning: Be wary of using LocalTimeZone(),
|
||||
// and particularly so in a server process, as the zone configured for the
|
||||
// local machine should be irrelevant. Prefer an explicit zone name.
|
||||
inline TimeZone LocalTimeZone() { return TimeZone(cctz::local_time_zone()); }
|
||||
inline TimeZone LocalTimeZone() {
|
||||
return TimeZone(cctz::local_time_zone());
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Implementation Details Follow
|
||||
|
@ -1139,16 +1144,16 @@ constexpr Time FromUnixDuration(Duration d) { return Time(d); }
|
|||
constexpr Duration ToUnixDuration(Time t) { return t.rep_; }
|
||||
|
||||
template <std::intmax_t N>
|
||||
constexpr absl::Duration FromInt64(int64_t v, std::ratio<1, N>) {
|
||||
constexpr Duration FromInt64(int64_t v, std::ratio<1, N>) {
|
||||
static_assert(0 < N && N <= 1000 * 1000 * 1000, "Unsupported ratio");
|
||||
// Subsecond ratios cannot overflow.
|
||||
return MakeNormalizedDuration(
|
||||
v / N, v % N * kTicksPerNanosecond * 1000 * 1000 * 1000 / N);
|
||||
}
|
||||
constexpr absl::Duration FromInt64(int64_t v, std::ratio<60>) {
|
||||
constexpr Duration FromInt64(int64_t v, std::ratio<60>) {
|
||||
return Minutes(v);
|
||||
}
|
||||
constexpr absl::Duration FromInt64(int64_t v, std::ratio<3600>) {
|
||||
constexpr Duration FromInt64(int64_t v, std::ratio<3600>) {
|
||||
return Hours(v);
|
||||
}
|
||||
|
||||
|
@ -1166,41 +1171,40 @@ constexpr auto IsValidRep64(char) -> bool {
|
|||
|
||||
// Converts a std::chrono::duration to an absl::Duration.
|
||||
template <typename Rep, typename Period>
|
||||
constexpr absl::Duration FromChrono(
|
||||
const std::chrono::duration<Rep, Period>& d) {
|
||||
constexpr Duration FromChrono(const std::chrono::duration<Rep, Period>& d) {
|
||||
static_assert(IsValidRep64<Rep>(0), "duration::rep is invalid");
|
||||
return FromInt64(int64_t{d.count()}, Period{});
|
||||
}
|
||||
|
||||
template <typename Ratio>
|
||||
int64_t ToInt64(absl::Duration d, Ratio) {
|
||||
int64_t ToInt64(Duration d, Ratio) {
|
||||
// Note: This may be used on MSVC, which may have a system_clock period of
|
||||
// std::ratio<1, 10 * 1000 * 1000>
|
||||
return ToInt64Seconds(d * Ratio::den / Ratio::num);
|
||||
}
|
||||
// Fastpath implementations for the 6 common duration units.
|
||||
inline int64_t ToInt64(absl::Duration d, std::nano) {
|
||||
inline int64_t ToInt64(Duration d, std::nano) {
|
||||
return ToInt64Nanoseconds(d);
|
||||
}
|
||||
inline int64_t ToInt64(absl::Duration d, std::micro) {
|
||||
inline int64_t ToInt64(Duration d, std::micro) {
|
||||
return ToInt64Microseconds(d);
|
||||
}
|
||||
inline int64_t ToInt64(absl::Duration d, std::milli) {
|
||||
inline int64_t ToInt64(Duration d, std::milli) {
|
||||
return ToInt64Milliseconds(d);
|
||||
}
|
||||
inline int64_t ToInt64(absl::Duration d, std::ratio<1>) {
|
||||
inline int64_t ToInt64(Duration d, std::ratio<1>) {
|
||||
return ToInt64Seconds(d);
|
||||
}
|
||||
inline int64_t ToInt64(absl::Duration d, std::ratio<60>) {
|
||||
inline int64_t ToInt64(Duration d, std::ratio<60>) {
|
||||
return ToInt64Minutes(d);
|
||||
}
|
||||
inline int64_t ToInt64(absl::Duration d, std::ratio<3600>) {
|
||||
inline int64_t ToInt64(Duration d, std::ratio<3600>) {
|
||||
return ToInt64Hours(d);
|
||||
}
|
||||
|
||||
// Converts an absl::Duration to a chrono duration of type T.
|
||||
template <typename T>
|
||||
T ToChronoDuration(absl::Duration d) {
|
||||
T ToChronoDuration(Duration d) {
|
||||
using Rep = typename T::rep;
|
||||
using Period = typename T::period;
|
||||
static_assert(IsValidRep64<Rep>(0), "duration::rep is invalid");
|
||||
|
|
|
@ -75,7 +75,7 @@ namespace {
|
|||
|
||||
class AnyExceptionSafety : public ::testing::Test {
|
||||
private:
|
||||
absl::AllocInspector inspector_;
|
||||
absl::ConstructorTracker inspector_;
|
||||
};
|
||||
|
||||
testing::AssertionResult AnyIsEmpty(absl::any* a) {
|
||||
|
|
Loading…
Reference in a new issue