mdebray/tvl-depot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Export of internal Abseil changes.

Browse source 
--
0925eb11f7730d5a1e538b9e6c2d1f8239f5fdc0 by Abseil Team <absl-team@google.com>:

Import of CCTZ from GitHub.

PiperOrigin-RevId: 250694613

--
4e1690e492a8399da1b1450ff5f21adf435fcef5 by Greg Falcon <gfalcon@google.com>:

Import of CCTZ from GitHub.

PiperOrigin-RevId: 250684222

--
c7281b44eb005c21d45bdc0b437e47c7787275bc by Derek Mauro <dmauro@google.com>:

Fix warnings on Xcode/clang.

PiperOrigin-RevId: 250552120

--
5ea3b1cfa759a7e6c70e7558f27c762baf818f7d by CJ Johnson <johnsoncj@google.com>:

Minor edits to InlinedVector benchmarks: Adds DoNotOptimize to the member functions of NontrivialType, removes unused template parameter for InlVec typeder

PiperOrigin-RevId: 250505482

--
7fe9c02b49121936c5b47034f20272a916111174 by Matt Kulukundis <kfm@google.com>:

Internal change.

PiperOrigin-RevId: 250376825

--
ad348c9c0eb37449874648e8544c56343c1dfaef by CJ Johnson <johnsoncj@google.com>:

Minor edits to InlinedVector benchmark

PiperOrigin-RevId: 250361830

--
55e8b411431e982059af73b160fa6bcef90e87f7 by CJ Johnson <johnsoncj@google.com>:

Switches use of allocator_traits to the Abseil backport to leverage existing bug fixes and workarounds

PiperOrigin-RevId: 250359321

--
b0edbe3218940128523e36388a31ff90df01a364 by CJ Johnson <johnsoncj@google.com>:

Updates exception safety test for InlinedVector to use TYPED_TEST (with fixtures) which increases the coverage without complicating the code.

PiperOrigin-RevId: 250359198

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

Internal change.

PiperOrigin-RevId: 250281509

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

Change the suggestions for the non-strict Next/PrevWeekday() calls.

Previously we suggested `PrevWeekday(d, Weekday::thursday) + 7`
to get the _following_ Thursday if d is not already a Thursday,
but `NextWeekday(d - 1, Weekday::thursday)` is more intuitive,
and probably even a little faster.

Similarly for the _previous_ Thursday if d is not already a
Thursday, suggest `PrevWeekday(d + 1, Weekday::thursday)`
instead of `NextWeekday(d, Weekday::thursday) - 7`.

PiperOrigin-RevId: 249840844

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

Change the DbgHelp lib pragma to use lowercase and an extension.

This matches the conventions used in the Windows SDK.

PiperOrigin-RevId: 249826229

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

Introduce Abseil prefixed thread annotation macros.

PiperOrigin-RevId: 249825200

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

Internal change.

PiperOrigin-RevId: 249737936

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

Tell CMake Abseil is a C++ project.

PiperOrigin-RevId: 249726509

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

Internal change.

PiperOrigin-RevId: 249726377
GitOrigin-RevId: 0925eb11f7730d5a1e538b9e6c2d1f8239f5fdc0
Change-Id: I05d18d30ad4e9ace6b60a17d2dc6fd699643fe30
This commit is contained in:
Abseil Team 2019-05-30 08:42:34 -07:00 • committed by vslashg
parent 4adaf54909
commit 2f76a9bf50
18 changed files with 486 additions and 153 deletions
Download patch file Download diff file Expand all files Collapse all files

1
absl/container/BUILD.bazel
View file

@ -124,6 +124,7 @@ cc_library(
linkopts = ABSL_DEFAULT_LINKOPTS,
deps = [
":compressed_tuple",
"//absl/memory",
"//absl/meta:type_traits",
],
)

1
absl/container/CMakeLists.txt
View file

@ -124,6 +124,7 @@ absl_cc_library(
${ABSL_DEFAULT_COPTS}
DEPS
absl::compressed_tuple
absl::memory
absl::type_traits
PUBLIC
)

6
absl/container/inlined_vector.h
View file

@ -890,7 +890,7 @@ class InlinedVector {
template <typename... Args>
reference Construct(pointer p, Args&&... args) {
std::allocator_traits<allocator_type>::construct(
absl::allocator_traits<allocator_type>::construct(
*storage_.GetAllocPtr(), p, std::forward<Args>(args)...);
return *p;
}
@ -908,8 +908,8 @@ class InlinedVector {
// Destroy [`from`, `to`) in place.
void Destroy(pointer from, pointer to) {
for (pointer cur = from; cur != to; ++cur) {
std::allocator_traits<allocator_type>::destroy(*storage_.GetAllocPtr(),
cur);
absl::allocator_traits<allocator_type>::destroy(*storage_.GetAllocPtr(),
cur);
}
#if !defined(NDEBUG)
// Overwrite unused memory with `0xab` so we can catch uninitialized usage.

59
absl/container/inlined_vector_benchmark.cc
View file

@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include <array>
#include <string>
#include <vector>
@ -373,71 +374,75 @@ void BM_StdVectorEmpty(benchmark::State& state) {
}
BENCHMARK(BM_StdVectorEmpty);
constexpr size_t kInlineElements = 4;
constexpr size_t kSmallSize = kInlineElements / 2;
constexpr size_t kLargeSize = kInlineElements * 2;
constexpr size_t kInlinedCapacity = 4;
constexpr size_t kLargeSize = kInlinedCapacity * 2;
constexpr size_t kSmallSize = kInlinedCapacity / 2;
constexpr size_t kBatchSize = 100;
template <typename T>
using InlVec = absl::InlinedVector<T, kInlinedCapacity>;
struct TrivialType {
size_t val;
};
using TrivialVec = absl::InlinedVector<TrivialType, kInlineElements>;
class NontrivialType {
public:
ABSL_ATTRIBUTE_NOINLINE NontrivialType() : val_() {}
ABSL_ATTRIBUTE_NOINLINE NontrivialType() : val_() {
benchmark::DoNotOptimize(*this);
}
ABSL_ATTRIBUTE_NOINLINE NontrivialType(const NontrivialType& other)
: val_(other.val_) {}
: val_(other.val_) {
benchmark::DoNotOptimize(*this);
}
ABSL_ATTRIBUTE_NOINLINE NontrivialType& operator=(
const NontrivialType& other) {
val_ = other.val_;
benchmark::DoNotOptimize(*this);
return *this;
}
ABSL_ATTRIBUTE_NOINLINE ~NontrivialType() noexcept {}
ABSL_ATTRIBUTE_NOINLINE ~NontrivialType() noexcept {
benchmark::DoNotOptimize(*this);
}
private:
size_t val_;
};
using NontrivialVec = absl::InlinedVector<NontrivialType, kInlineElements>;
template <typename VecT, typename PrepareVec, typename TestVec>
void BatchedBenchmark(benchmark::State& state, PrepareVec prepare_vec,
TestVec test_vec) {
VecT vectors[kBatchSize];
template <typename T, typename PrepareVecFn, typename TestVecFn>
void BatchedBenchmark(benchmark::State& state, PrepareVecFn prepare_vec,
TestVecFn test_vec) {
std::array<InlVec<T>, kBatchSize> vector_batch{};
while (state.KeepRunningBatch(kBatchSize)) {
// Prepare batch
state.PauseTiming();
for (auto& vec : vectors) {
for (auto& vec : vector_batch) {
prepare_vec(&vec);
}
benchmark::DoNotOptimize(vectors);
benchmark::DoNotOptimize(vector_batch);
state.ResumeTiming();
// Test batch
for (auto& vec : vectors) {
for (auto& vec : vector_batch) {
test_vec(&vec);
}
}
}
template <typename VecT, size_t FromSize>
template <typename T, size_t FromSize>
void BM_Clear(benchmark::State& state) {
BatchedBenchmark<VecT>(
BatchedBenchmark<T>(
state,
/* prepare_vec = */ [](VecT* vec) { vec->resize(FromSize); },
/* test_vec = */ [](VecT* vec) { vec->clear(); });
/* prepare_vec = */ [](InlVec<T>* vec) { vec->resize(FromSize); },
/* test_vec = */ [](InlVec<T>* vec) { vec->clear(); });
}
BENCHMARK_TEMPLATE(BM_Clear, TrivialVec, kSmallSize);
BENCHMARK_TEMPLATE(BM_Clear, TrivialVec, kLargeSize);
BENCHMARK_TEMPLATE(BM_Clear, NontrivialVec, kSmallSize);
BENCHMARK_TEMPLATE(BM_Clear, NontrivialVec, kLargeSize);
BENCHMARK_TEMPLATE(BM_Clear, TrivialType, kLargeSize);
BENCHMARK_TEMPLATE(BM_Clear, TrivialType, kSmallSize);
BENCHMARK_TEMPLATE(BM_Clear, NontrivialType, kLargeSize);
BENCHMARK_TEMPLATE(BM_Clear, NontrivialType, kSmallSize);
} // namespace

87
absl/container/inlined_vector_exception_safety_test.cc
View file

@ -20,36 +20,85 @@
namespace {
constexpr size_t kInlined = 4;
constexpr size_t kSmallSize = kInlined / 2;
constexpr size_t kLargeSize = kInlined * 2;
constexpr size_t kInlinedCapacity = 4;
constexpr size_t kLargeSize = kInlinedCapacity * 2;
constexpr size_t kSmallSize = kInlinedCapacity / 2;
using Thrower = testing::ThrowingValue<>;
using ThrowerAlloc = testing::ThrowingAllocator<Thrower>;
using MovableThrower = testing::ThrowingValue<testing::TypeSpec::kNoThrowMove>;
using ThrowAlloc = testing::ThrowingAllocator<Thrower>;
template <typename Allocator = std::allocator<Thrower>>
using InlVec = absl::InlinedVector<Thrower, kInlined, Allocator>;
using ThrowerVec = absl::InlinedVector<Thrower, kInlinedCapacity>;
using MovableThrowerVec = absl::InlinedVector<MovableThrower, kInlinedCapacity>;
TEST(InlinedVector, DefaultConstructor) {
testing::TestThrowingCtor<InlVec<>>();
using ThrowAllocThrowerVec =
absl::InlinedVector<Thrower, kInlinedCapacity, ThrowAlloc>;
using ThrowAllocMovableThrowerVec =
absl::InlinedVector<MovableThrower, kInlinedCapacity, ThrowAlloc>;
testing::TestThrowingCtor<InlVec<ThrowerAlloc>>();
template <typename TheVecT, size_t... TheSizes>
class TestParams {
public:
using VecT = TheVecT;
constexpr static size_t GetSizeAt(size_t i) { return kSizes[1 + i]; }
private:
constexpr static size_t kSizes[1 + sizeof...(TheSizes)] = {1, TheSizes...};
};
using NoSizeTestParams =
::testing::Types<TestParams<ThrowerVec>, TestParams<MovableThrowerVec>,
TestParams<ThrowAllocThrowerVec>,
TestParams<ThrowAllocMovableThrowerVec>>;
using OneSizeTestParams =
::testing::Types<TestParams<ThrowerVec, kLargeSize>,
TestParams<ThrowerVec, kSmallSize>,
TestParams<MovableThrowerVec, kLargeSize>,
TestParams<MovableThrowerVec, kSmallSize>,
TestParams<ThrowAllocThrowerVec, kLargeSize>,
TestParams<ThrowAllocThrowerVec, kSmallSize>,
TestParams<ThrowAllocMovableThrowerVec, kLargeSize>,
TestParams<ThrowAllocMovableThrowerVec, kSmallSize>>;
template <typename>
struct NoSizeTest : ::testing::Test {};
TYPED_TEST_SUITE(NoSizeTest, NoSizeTestParams);
template <typename>
struct OneSizeTest : ::testing::Test {};
TYPED_TEST_SUITE(OneSizeTest, OneSizeTestParams);
// Function that always returns false is correct, but refactoring is required
// for clarity. It's needed to express that, as a contract, certain operations
// should not throw at all. Execution of this function means an exception was
// thrown and thus the test should fail.
// TODO(johnsoncj): Add `testing::NoThrowGuarantee` to the framework
template <typename VecT>
bool NoThrowGuarantee(VecT* /* vec */) {
return false;
}
TEST(InlinedVector, AllocConstructor) {
auto alloc = std::allocator<Thrower>();
testing::TestThrowingCtor<InlVec<>>(alloc);
TYPED_TEST(NoSizeTest, DefaultConstructor) {
using VecT = typename TypeParam::VecT;
using allocator_type = typename VecT::allocator_type;
auto throw_alloc = ThrowerAlloc();
testing::TestThrowingCtor<InlVec<ThrowerAlloc>>(throw_alloc);
testing::TestThrowingCtor<VecT>();
testing::TestThrowingCtor<VecT>(allocator_type{});
}
TEST(InlinedVector, Clear) {
auto small_vec = InlVec<>(kSmallSize);
EXPECT_TRUE(testing::TestNothrowOp([&]() { small_vec.clear(); }));
TYPED_TEST(OneSizeTest, Clear) {
using VecT = typename TypeParam::VecT;
constexpr static auto size = TypeParam::GetSizeAt(0);
auto large_vec = InlVec<>(kLargeSize);
EXPECT_TRUE(testing::TestNothrowOp([&]() { large_vec.clear(); }));
auto tester = testing::MakeExceptionSafetyTester()
.WithInitialValue(VecT(size))
.WithContracts(NoThrowGuarantee<VecT>);
EXPECT_TRUE(tester.Test([](VecT* vec) {
vec->clear(); //
}));
}
} // namespace

2
absl/container/internal/hashtablez_sampler_test.cc
View file

@ -199,7 +199,7 @@ TEST(HashtablezSamplerTest, Sample) {
SetHashtablezSampleParameter(100);
int64_t num_sampled = 0;
int64_t total = 0;
double sample_rate;
double sample_rate = 0.0;
for (int i = 0; i < 1000000; ++i) {
HashtablezInfoHandle h = Sample();
++total;

13
absl/container/internal/inlined_vector.h
View file

@ -22,6 +22,7 @@
#include <utility>
#include "absl/container/internal/compressed_tuple.h"
#include "absl/memory/memory.h"
#include "absl/meta/type_traits.h"
namespace absl {
@ -35,15 +36,7 @@ using IsAtLeastForwardIterator = std::is_convertible<
template <typename AllocatorType, typename ValueType, typename SizeType>
void DestroyElements(AllocatorType* alloc_ptr, ValueType* destroy_first,
SizeType destroy_size) {
using AllocatorTraits = std::allocator_traits<AllocatorType>;
// Destroys `destroy_size` elements from `destroy_first`.
//
// Destroys the range
// [`destroy_first`, `destroy_first + destroy_size`).
//
// NOTE: We assume destructors do not throw and thus make no attempt to roll
// back.
using AllocatorTraits = absl::allocator_traits<AllocatorType>;
for (SizeType i = 0; i < destroy_size; ++i) {
AllocatorTraits::destroy(*alloc_ptr, destroy_first + i);
}
@ -75,7 +68,7 @@ class Storage {
using const_iterator = const_pointer;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using AllocatorTraits = std::allocator_traits<allocator_type>;
using AllocatorTraits = absl::allocator_traits<allocator_type>;
explicit Storage(const allocator_type& alloc)
: metadata_(alloc, /* empty and inlined */ 0) {}