Export of internal Abseil changes.
-- 7fa1107161a03dac53fb84c2b06d8092616c7b13 by Abseil Team <absl-team@google.com>: Harden the generic stacktrace implementation for use during early program execution PiperOrigin-RevId: 226375950 -- 079f9969329f5eb66f647dd3c44b17541b1bf217 by Matt Kulukundis <kfm@google.com>: Workaround platforms that have over-aggressive warnings on -Wexit-time-destructors PiperOrigin-RevId: 226362948 -- 1447943f509be681ca5495add0162c750ef237f1 by Matt Kulukundis <kfm@google.com>: Switch from 64 to size_t atomics so they work on embedded platforms that do not have 64 bit atomics. PiperOrigin-RevId: 226210704 -- d14d49837ae2bcde74051e0c79c18ee0f43866b9 by Tom Manshreck <shreck@google.com>: Develop initial documentation for API breaking changes process: PiperOrigin-RevId: 226210021 -- 7ea3d7fe0e86979dab83a5fc9cc3bf1d6cb3bd53 by Abseil Team <absl-team@google.com>: Import of CCTZ from GitHub. PiperOrigin-RevId: 226195522 -- 7de873e880d7f016a4fa1e08d626f0535cc470af by Abseil Team <absl-team@google.com>: Make Abseil LICENSE files newline terminated, with a single trailing blank line. Also remove line-ending whitespace. PiperOrigin-RevId: 226182949 -- 7d00643fadfad7f0d992c68bd9d2ed2e5bc960b0 by Matt Kulukundis <kfm@google.com>: Internal cleanup PiperOrigin-RevId: 226045282 -- c4a0a11c0ce2875271191e477f3d36eaaeca4613 by Matt Kulukundis <kfm@google.com>: Internal cleanup PiperOrigin-RevId: 226038273 -- 8ee4ebbb1ae5cda119e436e5ff7e3aa966608c10 by Matt Kulukundis <kfm@google.com>: Adds a global sampler which tracks a fraction of live tables for collecting telemetry data. PiperOrigin-RevId: 226032080 -- d576446f050518cd1b0ae447d682d8552f0e7e30 by Mark Barolak <mbar@google.com>: Replace an internal CaseEqual function with calls to the identical absl::EqualsIgnoreCase. This closes out a rather old TODO. PiperOrigin-RevId: 226024779 -- 6b23f1ee028a5ffa608c920424f1220a117a8f3d by Abseil Team <absl-team@google.com>: Add December 2018 LTS branch to list of LTS branches. PiperOrigin-RevId: 226011333 -- bb0833a43bdaef4c8c059b17bcd27ba9a085a114 by Mark Barolak <mbar@google.com>: Explicitly state that when the SimpleAtoi family of functions encounter an error, the value of their output parameter is unspecified. Also standardize the name of the output parameter to be `out`. PiperOrigin-RevId: 225997035 -- 46c1876b1a248eabda7545daa61a74a4cdfe9077 by Abseil Team <absl-team@google.com>: Remove deprecated CMake function absl_test, absl_library and absl_header_library PiperOrigin-RevId: 225950041 GitOrigin-RevId: 7fa1107161a03dac53fb84c2b06d8092616c7b13 Change-Id: I2ca9d3aada9292614527d1339a7557494139b806
This commit is contained in:
Abseil Team
Xiaoyi Zhang
parent
3e2e9b5557
commit
968a34ffda
16 changed files with 1313 additions and 348 deletions
307
absl/container/internal/hashtablez_sampler_test.cc
Normal file
307
absl/container/internal/hashtablez_sampler_test.cc
Normal file
|
|
@ -0,0 +1,307 @@
|
|||
// Copyright 2018 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
|
||||
//
|
||||
// http://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/container/internal/hashtablez_sampler.h"
|
||||
|
||||
#include <atomic>
|
||||
#include <limits>
|
||||
#include <random>
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
#include "absl/base/attributes.h"
|
||||
#include "absl/container/internal/have_sse.h"
|
||||
#include "absl/synchronization/blocking_counter.h"
|
||||
#include "absl/synchronization/internal/thread_pool.h"
|
||||
#include "absl/synchronization/mutex.h"
|
||||
#include "absl/synchronization/notification.h"
|
||||
#include "absl/time/clock.h"
|
||||
#include "absl/time/time.h"
|
||||
|
||||
#if SWISSTABLE_HAVE_SSE2
|
||||
constexpr int kProbeLength = 16;
|
||||
#else
|
||||
constexpr int kProbeLength = 8;
|
||||
#endif
|
||||
|
||||
namespace absl {
|
||||
namespace container_internal {
|
||||
class HashtablezInfoHandlePeer {
|
||||
public:
|
||||
static bool IsSampled(const HashtablezInfoHandle& h) {
|
||||
return h.info_ != nullptr;
|
||||
}
|
||||
|
||||
static HashtablezInfo* GetInfo(HashtablezInfoHandle* h) { return h->info_; }
|
||||
};
|
||||
|
||||
namespace {
|
||||
using ::absl::synchronization_internal::ThreadPool;
|
||||
using ::testing::IsEmpty;
|
||||
using ::testing::UnorderedElementsAre;
|
||||
|
||||
std::vector<size_t> GetSizes(HashtablezSampler* s) {
|
||||
std::vector<size_t> res;
|
||||
s->Iterate([&](const HashtablezInfo& info) {
|
||||
res.push_back(info.size.load(std::memory_order_acquire));
|
||||
});
|
||||
return res;
|
||||
}
|
||||
|
||||
HashtablezInfo* Register(HashtablezSampler* s, size_t size) {
|
||||
auto* info = s->Register();
|
||||
assert(info != nullptr);
|
||||
info->size.store(size);
|
||||
return info;
|
||||
}
|
||||
|
||||
TEST(HashtablezInfoTest, PrepareForSampling) {
|
||||
absl::Time test_start = absl::Now();
|
||||
HashtablezInfo info;
|
||||
absl::MutexLock l(&info.init_mu);
|
||||
info.PrepareForSampling();
|
||||
|
||||
EXPECT_EQ(info.capacity.load(), 0);
|
||||
EXPECT_EQ(info.size.load(), 0);
|
||||
EXPECT_EQ(info.num_erases.load(), 0);
|
||||
EXPECT_EQ(info.max_probe_length.load(), 0);
|
||||
EXPECT_EQ(info.total_probe_length.load(), 0);
|
||||
EXPECT_EQ(info.hashes_bitwise_or.load(), 0);
|
||||
EXPECT_EQ(info.hashes_bitwise_and.load(), ~size_t{});
|
||||
EXPECT_GE(info.create_time, test_start);
|
||||
|
||||
info.capacity.store(1, std::memory_order_relaxed);
|
||||
info.size.store(1, std::memory_order_relaxed);
|
||||
info.num_erases.store(1, std::memory_order_relaxed);
|
||||
info.max_probe_length.store(1, std::memory_order_relaxed);
|
||||
info.total_probe_length.store(1, std::memory_order_relaxed);
|
||||
info.hashes_bitwise_or.store(1, std::memory_order_relaxed);
|
||||
info.hashes_bitwise_and.store(1, std::memory_order_relaxed);
|
||||
info.create_time = test_start - absl::Hours(20);
|
||||
|
||||
info.PrepareForSampling();
|
||||
EXPECT_EQ(info.capacity.load(), 0);
|
||||
EXPECT_EQ(info.size.load(), 0);
|
||||
EXPECT_EQ(info.num_erases.load(), 0);
|
||||
EXPECT_EQ(info.max_probe_length.load(), 0);
|
||||
EXPECT_EQ(info.total_probe_length.load(), 0);
|
||||
EXPECT_EQ(info.hashes_bitwise_or.load(), 0);
|
||||
EXPECT_EQ(info.hashes_bitwise_and.load(), ~size_t{});
|
||||
EXPECT_GE(info.create_time, test_start);
|
||||
}
|
||||
|
||||
TEST(HashtablezInfoTest, RecordStorageChanged) {
|
||||
HashtablezInfo info;
|
||||
absl::MutexLock l(&info.init_mu);
|
||||
info.PrepareForSampling();
|
||||
RecordStorageChangedSlow(&info, 17, 47);
|
||||
EXPECT_EQ(info.size.load(), 17);
|
||||
EXPECT_EQ(info.capacity.load(), 47);
|
||||
RecordStorageChangedSlow(&info, 20, 20);
|
||||
EXPECT_EQ(info.size.load(), 20);
|
||||
EXPECT_EQ(info.capacity.load(), 20);
|
||||
}
|
||||
|
||||
TEST(HashtablezInfoTest, RecordInsert) {
|
||||
HashtablezInfo info;
|
||||
absl::MutexLock l(&info.init_mu);
|
||||
info.PrepareForSampling();
|
||||
EXPECT_EQ(info.max_probe_length.load(), 0);
|
||||
RecordInsertSlow(&info, 0x0000FF00, 6 * kProbeLength);
|
||||
EXPECT_EQ(info.max_probe_length.load(), 6);
|
||||
EXPECT_EQ(info.hashes_bitwise_and.load(), 0x0000FF00);
|
||||
EXPECT_EQ(info.hashes_bitwise_or.load(), 0x0000FF00);
|
||||
RecordInsertSlow(&info, 0x000FF000, 4 * kProbeLength);
|
||||
EXPECT_EQ(info.max_probe_length.load(), 6);
|
||||
EXPECT_EQ(info.hashes_bitwise_and.load(), 0x0000F000);
|
||||
EXPECT_EQ(info.hashes_bitwise_or.load(), 0x000FFF00);
|
||||
RecordInsertSlow(&info, 0x00FF0000, 12 * kProbeLength);
|
||||
EXPECT_EQ(info.max_probe_length.load(), 12);
|
||||
EXPECT_EQ(info.hashes_bitwise_and.load(), 0x00000000);
|
||||
EXPECT_EQ(info.hashes_bitwise_or.load(), 0x00FFFF00);
|
||||
}
|
||||
|
||||
TEST(HashtablezInfoTest, RecordErase) {
|
||||
HashtablezInfo info;
|
||||
absl::MutexLock l(&info.init_mu);
|
||||
info.PrepareForSampling();
|
||||
EXPECT_EQ(info.num_erases.load(), 0);
|
||||
EXPECT_EQ(info.size.load(), 0);
|
||||
RecordInsertSlow(&info, 0x0000FF00, 6 * kProbeLength);
|
||||
EXPECT_EQ(info.size.load(), 1);
|
||||
RecordEraseSlow(&info);
|
||||
EXPECT_EQ(info.size.load(), 0);
|
||||
EXPECT_EQ(info.num_erases.load(), 1);
|
||||
}
|
||||
|
||||
TEST(HashtablezSamplerTest, SmallSampleParameter) {
|
||||
SetHashtablezEnabled(true);
|
||||
SetHashtablezSampleParameter(100);
|
||||
|
||||
for (int i = 0; i < 1000; ++i) {
|
||||
int64_t next_sample = 0;
|
||||
HashtablezInfo* sample = SampleSlow(&next_sample);
|
||||
EXPECT_GT(next_sample, 0);
|
||||
EXPECT_NE(sample, nullptr);
|
||||
UnsampleSlow(sample);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(HashtablezSamplerTest, LargeSampleParameter) {
|
||||
SetHashtablezEnabled(true);
|
||||
SetHashtablezSampleParameter(std::numeric_limits<int32_t>::max());
|
||||
|
||||
for (int i = 0; i < 1000; ++i) {
|
||||
int64_t next_sample = 0;
|
||||
HashtablezInfo* sample = SampleSlow(&next_sample);
|
||||
EXPECT_GT(next_sample, 0);
|
||||
EXPECT_NE(sample, nullptr);
|
||||
UnsampleSlow(sample);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(HashtablezSamplerTest, Sample) {
|
||||
SetHashtablezEnabled(true);
|
||||
SetHashtablezSampleParameter(100);
|
||||
int64_t num_sampled = 0;
|
||||
int64_t total = 0;
|
||||
double sample_rate;
|
||||
for (int i = 0; i < 1000000; ++i) {
|
||||
HashtablezInfoHandle h = Sample();
|
||||
++total;
|
||||
if (HashtablezInfoHandlePeer::IsSampled(h)) {
|
||||
++num_sampled;
|
||||
}
|
||||
sample_rate = static_cast<double>(num_sampled) / total;
|
||||
if (0.005 < sample_rate && sample_rate < 0.015) break;
|
||||
}
|
||||
EXPECT_NEAR(sample_rate, 0.01, 0.005);
|
||||
}
|
||||
|
||||
TEST(HashtablezSamplerTest, Handle) {
|
||||
auto& sampler = HashtablezSampler::Global();
|
||||
HashtablezInfoHandle h(sampler.Register());
|
||||
auto* info = HashtablezInfoHandlePeer::GetInfo(&h);
|
||||
info->hashes_bitwise_and.store(0x12345678, std::memory_order_relaxed);
|
||||
|
||||
bool found = false;
|
||||
sampler.Iterate([&](const HashtablezInfo& h) {
|
||||
if (&h == info) {
|
||||
EXPECT_EQ(h.hashes_bitwise_and.load(), 0x12345678);
|
||||
found = true;
|
||||
}
|
||||
});
|
||||
EXPECT_TRUE(found);
|
||||
|
||||
h = HashtablezInfoHandle();
|
||||
found = false;
|
||||
sampler.Iterate([&](const HashtablezInfo& h) {
|
||||
if (&h == info) {
|
||||
// this will only happen if some other thread has resurrected the info
|
||||
// the old handle was using.
|
||||
if (h.hashes_bitwise_and.load() == 0x12345678) {
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
});
|
||||
EXPECT_FALSE(found);
|
||||
}
|
||||
|
||||
TEST(HashtablezSamplerTest, Registration) {
|
||||
HashtablezSampler sampler;
|
||||
auto* info1 = Register(&sampler, 1);
|
||||
EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(1));
|
||||
|
||||
auto* info2 = Register(&sampler, 2);
|
||||
EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(1, 2));
|
||||
info1->size.store(3);
|
||||
EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(3, 2));
|
||||
|
||||
sampler.Unregister(info1);
|
||||
sampler.Unregister(info2);
|
||||
}
|
||||
|
||||
TEST(HashtablezSamplerTest, Unregistration) {
|
||||
HashtablezSampler sampler;
|
||||
std::vector<HashtablezInfo*> infos;
|
||||
for (size_t i = 0; i < 3; ++i) {
|
||||
infos.push_back(Register(&sampler, i));
|
||||
}
|
||||
EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(0, 1, 2));
|
||||
|
||||
sampler.Unregister(infos[1]);
|
||||
EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(0, 2));
|
||||
|
||||
infos.push_back(Register(&sampler, 3));
|
||||
infos.push_back(Register(&sampler, 4));
|
||||
EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(0, 2, 3, 4));
|
||||
sampler.Unregister(infos[3]);
|
||||
EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(0, 2, 4));
|
||||
|
||||
sampler.Unregister(infos[0]);
|
||||
sampler.Unregister(infos[2]);
|
||||
sampler.Unregister(infos[4]);
|
||||
EXPECT_THAT(GetSizes(&sampler), IsEmpty());
|
||||
}
|
||||
|
||||
TEST(HashtablezSamplerTest, MultiThreaded) {
|
||||
HashtablezSampler sampler;
|
||||
Notification stop;
|
||||
ThreadPool pool(10);
|
||||
|
||||
for (int i = 0; i < 10; ++i) {
|
||||
pool.Schedule([&sampler, &stop]() {
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
std::vector<HashtablezInfo*> infoz;
|
||||
while (!stop.HasBeenNotified()) {
|
||||
if (infoz.empty()) {
|
||||
infoz.push_back(sampler.Register());
|
||||
}
|
||||
switch (std::uniform_int_distribution<>(0, 2)(gen)) {
|
||||
case 0: {
|
||||
infoz.push_back(sampler.Register());
|
||||
break;
|
||||
}
|
||||
case 1: {
|
||||
size_t p =
|
||||
std::uniform_int_distribution<>(0, infoz.size() - 1)(gen);
|
||||
HashtablezInfo* info = infoz[p];
|
||||
infoz[p] = infoz.back();
|
||||
infoz.pop_back();
|
||||
sampler.Unregister(info);
|
||||
break;
|
||||
}
|
||||
case 2: {
|
||||
absl::Duration oldest = absl::ZeroDuration();
|
||||
sampler.Iterate([&](const HashtablezInfo& info) {
|
||||
oldest = std::max(oldest, absl::Now() - info.create_time);
|
||||
});
|
||||
ASSERT_GE(oldest, absl::ZeroDuration());
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
// The threads will hammer away. Give it a little bit of time for tsan to
|
||||
// spot errors.
|
||||
absl::SleepFor(absl::Seconds(3));
|
||||
stop.Notify();
|
||||
}
|
||||
|
||||
} // namespace
|
||||
} // namespace container_internal
|
||||
} // namespace absl
|
||||
Loading…
Add table
Add a link
Reference in a new issue