-- ca3a0009e675b699b5d6dd41f00ebac0e7d1935c by Derek Mauro <dmauro@google.com>: Internal change PiperOrigin-RevId: 396475923 -- 04d9fff79085bb18612af3da49007907394ae0b6 by Abseil Team <absl-team@google.com>: Move HastablezSampler from container/internal to profiling/internal. PiperOrigin-RevId: 396362093 GitOrigin-RevId: ca3a0009e675b699b5d6dd41f00ebac0e7d1935c Change-Id: I42d6d2944786afa24259fde002fed5e611f4e1f9pull/1016/head
Abseil Team
4 years ago
committed by
Derek Mauro
parent
669184b4f3
commit
b2dc72c17a
11 changed files with 482 additions and 176 deletions
@ -0,0 +1,231 @@ |
|||||||
|
// 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
|
||||||
|
//
|
||||||
|
// 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.
|
||||||
|
//
|
||||||
|
// -----------------------------------------------------------------------------
|
||||||
|
// File: sample_recorder.h
|
||||||
|
// -----------------------------------------------------------------------------
|
||||||
|
//
|
||||||
|
// This header file defines a lock-free linked list for recording samples
|
||||||
|
// collected from a random/stochastic process.
|
||||||
|
//
|
||||||
|
// This utility is internal-only. Use at your own risk.
|
||||||
|
|
||||||
|
#ifndef ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_ |
||||||
|
#define ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_ |
||||||
|
|
||||||
|
#include <atomic> |
||||||
|
#include <cstddef> |
||||||
|
#include <functional> |
||||||
|
|
||||||
|
#include "absl/base/config.h" |
||||||
|
#include "absl/base/thread_annotations.h" |
||||||
|
#include "absl/synchronization/mutex.h" |
||||||
|
#include "absl/time/time.h" |
||||||
|
|
||||||
|
namespace absl { |
||||||
|
ABSL_NAMESPACE_BEGIN |
||||||
|
namespace profiling_internal { |
||||||
|
|
||||||
|
// Sample<T> that has members required for linking samples in the linked list of
|
||||||
|
// samples maintained by the SampleRecorder. Type T defines the sampled data.
|
||||||
|
template <typename T> |
||||||
|
struct Sample { |
||||||
|
public: |
||||||
|
// Guards the ability to restore the sample to a pristine state. This
|
||||||
|
// prevents races with sampling and resurrecting an object.
|
||||||
|
absl::Mutex init_mu; |
||||||
|
T* next = nullptr; |
||||||
|
T* dead ABSL_GUARDED_BY(init_mu) = nullptr; |
||||||
|
}; |
||||||
|
|
||||||
|
// Holds samples and their associated stack traces with a soft limit of
|
||||||
|
// `SetHashtablezMaxSamples()`.
|
||||||
|
//
|
||||||
|
// Thread safe.
|
||||||
|
template <typename T> |
||||||
|
class SampleRecorder { |
||||||
|
public: |
||||||
|
SampleRecorder(); |
||||||
|
~SampleRecorder(); |
||||||
|
|
||||||
|
// Registers for sampling. Returns an opaque registration info.
|
||||||
|
T* Register(); |
||||||
|
|
||||||
|
// Unregisters the sample.
|
||||||
|
void Unregister(T* sample); |
||||||
|
|
||||||
|
// The dispose callback will be called on all samples the moment they are
|
||||||
|
// being unregistered. Only affects samples that are unregistered after the
|
||||||
|
// callback has been set.
|
||||||
|
// Returns the previous callback.
|
||||||
|
using DisposeCallback = void (*)(const T&); |
||||||
|
DisposeCallback SetDisposeCallback(DisposeCallback f); |
||||||
|
|
||||||
|
// Iterates over all the registered `StackInfo`s. Returning the number of
|
||||||
|
// samples that have been dropped.
|
||||||
|
int64_t Iterate(const std::function<void(const T& stack)>& f); |
||||||
|
|
||||||
|
void SetMaxSamples(int32_t max); |
||||||
|
|
||||||
|
private: |
||||||
|
void PushNew(T* sample); |
||||||
|
void PushDead(T* sample); |
||||||
|
T* PopDead(); |
||||||
|
|
||||||
|
std::atomic<size_t> dropped_samples_; |
||||||
|
std::atomic<size_t> size_estimate_; |
||||||
|
std::atomic<int32_t> max_samples_{1 << 20}; |
||||||
|
|
||||||
|
// Intrusive lock free linked lists for tracking samples.
|
||||||
|
//
|
||||||
|
// `all_` records all samples (they are never removed from this list) and is
|
||||||
|
// terminated with a `nullptr`.
|
||||||
|
//
|
||||||
|
// `graveyard_.dead` is a circular linked list. When it is empty,
|
||||||
|
// `graveyard_.dead == &graveyard`. The list is circular so that
|
||||||
|
// every item on it (even the last) has a non-null dead pointer. This allows
|
||||||
|
// `Iterate` to determine if a given sample is live or dead using only
|
||||||
|
// information on the sample itself.
|
||||||
|
//
|
||||||
|
// For example, nodes [A, B, C, D, E] with [A, C, E] alive and [B, D] dead
|
||||||
|
// looks like this (G is the Graveyard):
|
||||||
|
//
|
||||||
|
// +---+ +---+ +---+ +---+ +---+
|
||||||
|
// all -->| A |--->| B |--->| C |--->| D |--->| E |
|
||||||
|
// | | | | | | | | | |
|
||||||
|
// +---+ | | +->| |-+ | | +->| |-+ | |
|
||||||
|
// | G | +---+ | +---+ | +---+ | +---+ | +---+
|
||||||
|
// | | | | | |
|
||||||
|
// | | --------+ +--------+ |
|
||||||
|
// +---+ |
|
||||||
|
// ^ |
|
||||||
|
// +--------------------------------------+
|
||||||
|
//
|
||||||
|
std::atomic<T*> all_; |
||||||
|
T graveyard_; |
||||||
|
|
||||||
|
std::atomic<DisposeCallback> dispose_; |
||||||
|
}; |
||||||
|
|
||||||
|
template <typename T> |
||||||
|
typename SampleRecorder<T>::DisposeCallback |
||||||
|
SampleRecorder<T>::SetDisposeCallback(DisposeCallback f) { |
||||||
|
return dispose_.exchange(f, std::memory_order_relaxed); |
||||||
|
} |
||||||
|
|
||||||
|
template <typename T> |
||||||
|
SampleRecorder<T>::SampleRecorder() |
||||||
|
: dropped_samples_(0), size_estimate_(0), all_(nullptr), dispose_(nullptr) { |
||||||
|
absl::MutexLock l(&graveyard_.init_mu); |
||||||
|
graveyard_.dead = &graveyard_; |
||||||
|
} |
||||||
|
|
||||||
|
template <typename T> |
||||||
|
SampleRecorder<T>::~SampleRecorder() { |
||||||
|
T* s = all_.load(std::memory_order_acquire); |
||||||
|
while (s != nullptr) { |
||||||
|
T* next = s->next; |
||||||
|
delete s; |
||||||
|
s = next; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
template <typename T> |
||||||
|
void SampleRecorder<T>::PushNew(T* sample) { |
||||||
|
sample->next = all_.load(std::memory_order_relaxed); |
||||||
|
while (!all_.compare_exchange_weak(sample->next, sample, |
||||||
|
std::memory_order_release, |
||||||
|
std::memory_order_relaxed)) { |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
template <typename T> |
||||||
|
void SampleRecorder<T>::PushDead(T* sample) { |
||||||
|
if (auto* dispose = dispose_.load(std::memory_order_relaxed)) { |
||||||
|
dispose(*sample); |
||||||
|
} |
||||||
|
|
||||||
|
absl::MutexLock graveyard_lock(&graveyard_.init_mu); |
||||||
|
absl::MutexLock sample_lock(&sample->init_mu); |
||||||
|
sample->dead = graveyard_.dead; |
||||||
|
graveyard_.dead = sample; |
||||||
|
} |
||||||
|
|
||||||
|
template <typename T> |
||||||
|
T* SampleRecorder<T>::PopDead() { |
||||||
|
absl::MutexLock graveyard_lock(&graveyard_.init_mu); |
||||||
|
|
||||||
|
// The list is circular, so eventually it collapses down to
|
||||||
|
// graveyard_.dead == &graveyard_
|
||||||
|
// when it is empty.
|
||||||
|
T* sample = graveyard_.dead; |
||||||
|
if (sample == &graveyard_) return nullptr; |
||||||
|
|
||||||
|
absl::MutexLock sample_lock(&sample->init_mu); |
||||||
|
graveyard_.dead = sample->dead; |
||||||
|
sample->dead = nullptr; |
||||||
|
sample->PrepareForSampling(); |
||||||
|
return sample; |
||||||
|
} |
||||||
|
|
||||||
|
template <typename T> |
||||||
|
T* SampleRecorder<T>::Register() { |
||||||
|
int64_t size = size_estimate_.fetch_add(1, std::memory_order_relaxed); |
||||||
|
if (size > max_samples_.load(std::memory_order_relaxed)) { |
||||||
|
size_estimate_.fetch_sub(1, std::memory_order_relaxed); |
||||||
|
dropped_samples_.fetch_add(1, std::memory_order_relaxed); |
||||||
|
return nullptr; |
||||||
|
} |
||||||
|
|
||||||
|
T* sample = PopDead(); |
||||||
|
if (sample == nullptr) { |
||||||
|
// Resurrection failed. Hire a new warlock.
|
||||||
|
sample = new T(); |
||||||
|
PushNew(sample); |
||||||
|
} |
||||||
|
|
||||||
|
return sample; |
||||||
|
} |
||||||
|
|
||||||
|
template <typename T> |
||||||
|
void SampleRecorder<T>::Unregister(T* sample) { |
||||||
|
PushDead(sample); |
||||||
|
size_estimate_.fetch_sub(1, std::memory_order_relaxed); |
||||||
|
} |
||||||
|
|
||||||
|
template <typename T> |
||||||
|
int64_t SampleRecorder<T>::Iterate( |
||||||
|
const std::function<void(const T& stack)>& f) { |
||||||
|
T* s = all_.load(std::memory_order_acquire); |
||||||
|
while (s != nullptr) { |
||||||
|
absl::MutexLock l(&s->init_mu); |
||||||
|
if (s->dead == nullptr) { |
||||||
|
f(*s); |
||||||
|
} |
||||||
|
s = s->next; |
||||||
|
} |
||||||
|
|
||||||
|
return dropped_samples_.load(std::memory_order_relaxed); |
||||||
|
} |
||||||
|
|
||||||
|
template <typename T> |
||||||
|
void SampleRecorder<T>::SetMaxSamples(int32_t max) { |
||||||
|
max_samples_.store(max, std::memory_order_release); |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace profiling_internal
|
||||||
|
ABSL_NAMESPACE_END |
||||||
|
} // namespace absl
|
||||||
|
|
||||||
|
#endif // ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_
|
||||||
@ -0,0 +1,171 @@ |
|||||||
|
// 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
|
||||||
|
//
|
||||||
|
// 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/profiling/internal/sample_recorder.h" |
||||||
|
|
||||||
|
#include <atomic> |
||||||
|
#include <random> |
||||||
|
#include <vector> |
||||||
|
|
||||||
|
#include "gmock/gmock.h" |
||||||
|
#include "absl/base/thread_annotations.h" |
||||||
|
#include "absl/synchronization/internal/thread_pool.h" |
||||||
|
#include "absl/synchronization/mutex.h" |
||||||
|
#include "absl/synchronization/notification.h" |
||||||
|
#include "absl/time/time.h" |
||||||
|
|
||||||
|
namespace absl { |
||||||
|
ABSL_NAMESPACE_BEGIN |
||||||
|
namespace profiling_internal { |
||||||
|
|
||||||
|
namespace { |
||||||
|
using ::absl::synchronization_internal::ThreadPool; |
||||||
|
using ::testing::IsEmpty; |
||||||
|
using ::testing::UnorderedElementsAre; |
||||||
|
|
||||||
|
struct Info : public Sample<Info> { |
||||||
|
public: |
||||||
|
void PrepareForSampling() {} |
||||||
|
std::atomic<size_t> size; |
||||||
|
absl::Time create_time; |
||||||
|
}; |
||||||
|
|
||||||
|
std::vector<size_t> GetSizes(SampleRecorder<Info>* s) { |
||||||
|
std::vector<size_t> res; |
||||||
|
s->Iterate([&](const Info& info) { |
||||||
|
res.push_back(info.size.load(std::memory_order_acquire)); |
||||||
|
}); |
||||||
|
return res; |
||||||
|
} |
||||||
|
|
||||||
|
Info* Register(SampleRecorder<Info>* s, size_t size) { |
||||||
|
auto* info = s->Register(); |
||||||
|
assert(info != nullptr); |
||||||
|
info->size.store(size); |
||||||
|
return info; |
||||||
|
} |
||||||
|
|
||||||
|
TEST(SampleRecorderTest, Registration) { |
||||||
|
SampleRecorder<Info> 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(SampleRecorderTest, Unregistration) { |
||||||
|
SampleRecorder<Info> sampler; |
||||||
|
std::vector<Info*> 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(SampleRecorderTest, MultiThreaded) { |
||||||
|
SampleRecorder<Info> 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<Info*> 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); |
||||||
|
Info* info = infoz[p]; |
||||||
|
infoz[p] = infoz.back(); |
||||||
|
infoz.pop_back(); |
||||||
|
sampler.Unregister(info); |
||||||
|
break; |
||||||
|
} |
||||||
|
case 2: { |
||||||
|
absl::Duration oldest = absl::ZeroDuration(); |
||||||
|
sampler.Iterate([&](const Info& 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(); |
||||||
|
} |
||||||
|
|
||||||
|
TEST(SampleRecorderTest, Callback) { |
||||||
|
SampleRecorder<Info> sampler; |
||||||
|
|
||||||
|
auto* info1 = Register(&sampler, 1); |
||||||
|
auto* info2 = Register(&sampler, 2); |
||||||
|
|
||||||
|
static const Info* expected; |
||||||
|
|
||||||
|
auto callback = [](const Info& info) { |
||||||
|
// We can't use `info` outside of this callback because the object will be
|
||||||
|
// disposed as soon as we return from here.
|
||||||
|
EXPECT_EQ(&info, expected); |
||||||
|
}; |
||||||
|
|
||||||
|
// Set the callback.
|
||||||
|
EXPECT_EQ(sampler.SetDisposeCallback(callback), nullptr); |
||||||
|
expected = info1; |
||||||
|
sampler.Unregister(info1); |
||||||
|
|
||||||
|
// Unset the callback.
|
||||||
|
EXPECT_EQ(callback, sampler.SetDisposeCallback(nullptr)); |
||||||
|
expected = nullptr; // no more calls.
|
||||||
|
sampler.Unregister(info2); |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace
|
||||||
|
} // namespace profiling_internal
|
||||||
|
ABSL_NAMESPACE_END |
||||||
|
} // namespace absl
|
||||||
Loading…
Reference in new issue