@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/profiling/internal/profile_builder.h

@@ -1,161 +0,0 @@
-// Copyright 2025 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_PROFILING_INTERNAL_PROFILE_BUILDER_H_
-#define ABSL_PROFILING_INTERNAL_PROFILE_BUILDER_H_
-
-#include <cstddef>
-#include <cstdint>
-#include <string>
-#include <vector>
-
-#include "absl/container/btree_map.h"
-#include "absl/container/flat_hash_map.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-// Field numbers for perftools.profiles.Profile.
-// https://github.com/google/pprof/blob/master/proto/profile.proto
-struct ProfileProto {
-  static constexpr int kSampleType = 1;
-  static constexpr int kSample = 2;
-  static constexpr int kMapping = 3;
-  static constexpr int kLocation = 4;
-  static constexpr int kStringTable = 6;
-  static constexpr int kDropFrames = 7;
-  static constexpr int kComment = 13;
-  static constexpr int kDefaultSampleType = 14;
-};
-
-struct ValueTypeProto {
-  static constexpr int kType = 1;
-  static constexpr int kUnit = 2;
-};
-
-struct SampleProto {
-  static constexpr int kLocationId = 1;
-  static constexpr int kValue = 2;
-  static constexpr int kLabel = 3;
-};
-
-struct LabelProto {
-  static constexpr int kKey = 1;
-  static constexpr int kStr = 2;
-  static constexpr int kNum = 3;
-  static constexpr int kNumUnit = 4;
-};
-
-struct MappingProto {
-  static constexpr int kId = 1;
-  static constexpr int kMemoryStart = 2;
-  static constexpr int kMemoryLimit = 3;
-  static constexpr int kFileOffset = 4;
-  static constexpr int kFilename = 5;
-  static constexpr int kBuildId = 6;
-};
-
-struct LocationProto {
-  static constexpr int kId = 1;
-  static constexpr int kMappingId = 2;
-  static constexpr int kAddress = 3;
-};
-
-enum class StringId : size_t {};
-enum class LocationId : size_t {};
-enum class MappingId : size_t {};
-
-// A helper class to build a profile protocol buffer.
-class ProfileBuilder {
- public:
-  struct Mapping {
-    uint64_t start;
-    uint64_t limit;
-    uint64_t offset;
-    std::string filename;
-    std::string build_id;
-  };
-
-  StringId InternString(absl::string_view str);
-
-  LocationId InternLocation(const void* address);
-
-  void AddSample(int64_t value, absl::Span<const void* const> stack,
-                 absl::Span<const std::pair<StringId, int64_t>> labels);
-
-  void AddSampleType(StringId type, StringId unit);
-
-  // Adds the current process mappings to the profile.
-  void AddCurrentMappings();
-
-  // Adds a single mapping to the profile and to lookup cache and returns the
-  // resulting ID.
-  MappingId AddMapping(uintptr_t memory_start, uintptr_t memory_limit,
-                       uintptr_t file_offset, absl::string_view filename,
-                       absl::string_view build_id);
-
-  std::string Emit() &&;
-
-  void set_drop_frames_id(StringId drop_frames_id);
-  void set_comment_id(StringId comment_id);
-  void set_default_sample_type_id(StringId default_sample_type_id);
-
- private:
-  // We turn off hashtable profiling for the ProfileBuilder's own tables.
-  //
-  // This is necessary since we use this class to construct hashtable profiles,
-  // which entails walking the hashtable profiling data and we don't want to
-  // encounter it reentrantly.
-  template <typename T>
-  struct HashtablezBarrier : std::allocator<T> {
-    HashtablezBarrier() = default;
-
-    template <typename U>
-    HashtablezBarrier(const HashtablezBarrier<U>&) {}
-
-    template <class U>
-    struct rebind {
-      using other = HashtablezBarrier<U>;
-    };
-  };
-
-  template <typename K, typename V>
-  using UnprofiledHashMap = absl::flat_hash_map<
-      K, V, DefaultHashContainerHash<K>, DefaultHashContainerEq<K>,
-      HashtablezBarrier<std::pair<const K, V>>>;
-
-  UnprofiledHashMap<std::string, StringId> string_table_{{"", StringId(0)}};
-  UnprofiledHashMap<uintptr_t, LocationId> location_table_;
-  // mapping_table_ stores the start address of each mapping in mapping_
-  // to its index.
-  absl::btree_map<uintptr_t, size_t> mapping_table_;
-  std::vector<Mapping> mappings_;
-
-  std::vector<std::string> sample_types_;
-  std::vector<std::string> samples_;
-
-  StringId drop_frames_id_{};
-  StringId comment_id_{};
-  StringId default_sample_type_id_{};
-};
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_PROFILING_INTERNAL_PROFILE_BUILDER_H_

package/deps/abseil-cpp/absl/profiling/internal/sample_recorder.h

@@ -1,253 +0,0 @@
-// 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 {
-  // 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;
-  int64_t weight;  // How many sampling events were required to sample this one.
-};
-
-// 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.
-  template <typename... Targs>
-  T* Register(Targs&&... args);
-
-  // 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.
-  size_t Iterate(const std::function<void(const T& stack)>& f);
-
-  size_t GetMaxSamples() const;
-  void SetMaxSamples(size_t max);
-
- private:
-  void PushNew(T* sample);
-  void PushDead(T* sample);
-  template <typename... Targs>
-  T* PopDead(Targs... args);
-
-  std::atomic<size_t> dropped_samples_;
-  std::atomic<size_t> size_estimate_;
-  std::atomic<size_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>
-template <typename... Targs>
-T* SampleRecorder<T>::PopDead(Targs... args) {
-  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(std::forward<Targs>(args)...);
-  return sample;
-}
-
-template <typename T>
-template <typename... Targs>
-T* SampleRecorder<T>::Register(Targs&&... args) {
-  size_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(args...);
-  if (sample == nullptr) {
-    // Resurrection failed.  Hire a new warlock.
-    sample = new T();
-    {
-      absl::MutexLock sample_lock(sample->init_mu);
-      // If flag initialization happens to occur (perhaps in another thread)
-      // while in this block, it will lock `graveyard_` which is usually always
-      // locked before any sample. This will appear as a lock inversion.
-      // However, this code is run exactly once per sample, and this sample
-      // cannot be accessed until after it is returned from this method.  This
-      // means that this lock state can never be recreated, so we can safely
-      // inform the deadlock detector to ignore it.
-      sample->init_mu.ForgetDeadlockInfo();
-      sample->PrepareForSampling(std::forward<Targs>(args)...);
-    }
-    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>
-size_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(size_t max) {
-  max_samples_.store(max, std::memory_order_release);
-}
-
-template <typename T>
-size_t SampleRecorder<T>::GetMaxSamples() const {
-  return max_samples_.load(std::memory_order_acquire);
-}
-
-}  // namespace profiling_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_

package/deps/abseil-cpp/absl/profiling/internal/sample_recorder_test.cc

@@ -1,188 +0,0 @@
-// 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 <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <random>
-#include <vector>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/base/thread_annotations.h"
-#include "absl/random/random.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"
-
-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(int64_t w) { weight = w; }
-  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;
-}
-
-std::vector<int64_t> GetWeights(SampleRecorder<Info>* s) {
-  std::vector<int64_t> res;
-  s->Iterate([&](const Info& info) { res.push_back(info.weight); });
-  return res;
-}
-
-Info* Register(SampleRecorder<Info>* s, int64_t weight, size_t size) {
-  auto* info = s->Register(weight);
-  assert(info != nullptr);
-  info->size.store(size);
-  return info;
-}
-
-TEST(SampleRecorderTest, Registration) {
-  SampleRecorder<Info> sampler;
-  auto* info1 = Register(&sampler, 31, 1);
-  EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(1));
-  EXPECT_THAT(GetWeights(&sampler), UnorderedElementsAre(31));
-
-  auto* info2 = Register(&sampler, 32, 2);
-  EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(1, 2));
-  info1->size.store(3);
-  EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(3, 2));
-  EXPECT_THAT(GetWeights(&sampler), UnorderedElementsAre(31, 32));
-
-  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, 33 + i, i));
-  }
-  EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(0, 1, 2));
-  EXPECT_THAT(GetWeights(&sampler), UnorderedElementsAre(33, 34, 35));
-
-  sampler.Unregister(infos[1]);
-  EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(0, 2));
-  EXPECT_THAT(GetWeights(&sampler), UnorderedElementsAre(33, 35));
-
-  infos.push_back(Register(&sampler, 36, 3));
-  infos.push_back(Register(&sampler, 37, 4));
-  EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(0, 2, 3, 4));
-  EXPECT_THAT(GetWeights(&sampler), UnorderedElementsAre(33, 35, 36, 37));
-  sampler.Unregister(infos[3]);
-  EXPECT_THAT(GetSizes(&sampler), UnorderedElementsAre(0, 2, 4));
-  EXPECT_THAT(GetWeights(&sampler), UnorderedElementsAre(33, 35, 37));
-
-  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, i]() {
-      absl::InsecureBitGen gen;
-      std::vector<Info*> infoz;
-      while (!stop.HasBeenNotified()) {
-        if (infoz.empty()) {
-          infoz.push_back(sampler.Register(i));
-        }
-        switch (std::uniform_int_distribution<>(0, 2)(gen)) {
-          case 0: {
-            infoz.push_back(sampler.Register(i));
-            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();
-            EXPECT_EQ(info->weight, i);
-            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, 39, 1);
-  auto* info2 = Register(&sampler, 40, 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