@nxtedition/rocksdb 15.2.3 → 15.2.4

package/deps/abseil-cpp/absl/strings/internal/cordz_handle.cc

@@ -1,165 +0,0 @@
-// Copyright 2019 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/strings/internal/cordz_handle.h"
-
-#include <atomic>
-
-#include "absl/base/internal/raw_logging.h"  // For ABSL_RAW_CHECK
-#include "absl/base/no_destructor.h"
-#include "absl/synchronization/mutex.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-namespace {
-
-struct Queue {
-  Queue() = default;
-
-  absl::Mutex mutex;
-  std::atomic<CordzHandle*> dq_tail ABSL_GUARDED_BY(mutex){nullptr};
-
-  // Returns true if this delete queue is empty. This method does not acquire
-  // the lock, but does a 'load acquire' observation on the delete queue tail.
-  // It is used inside Delete() to check for the presence of a delete queue
-  // without holding the lock. The assumption is that the caller is in the
-  // state of 'being deleted', and can not be newly discovered by a concurrent
-  // 'being constructed' snapshot instance. Practically, this means that any
-  // such discovery (`find`, 'first' or 'next', etc) must have proper 'happens
-  // before / after' semantics and atomic fences.
-  bool IsEmpty() const ABSL_NO_THREAD_SAFETY_ANALYSIS {
-    return dq_tail.load(std::memory_order_acquire) == nullptr;
-  }
-};
-
-static Queue& GlobalQueue() {
-  static absl::NoDestructor<Queue> global_queue;
-  return *global_queue;
-}
-
-}  // namespace
-
-CordzHandle::CordzHandle(bool is_snapshot) : is_snapshot_(is_snapshot) {
-  Queue& global_queue = GlobalQueue();
-  if (is_snapshot) {
-    MutexLock lock(global_queue.mutex);
-    CordzHandle* dq_tail = global_queue.dq_tail.load(std::memory_order_acquire);
-    if (dq_tail != nullptr) {
-      dq_prev_ = dq_tail;
-      dq_tail->dq_next_ = this;
-    }
-    global_queue.dq_tail.store(this, std::memory_order_release);
-  }
-}
-
-CordzHandle::~CordzHandle() {
-  Queue& global_queue = GlobalQueue();
-  if (is_snapshot_) {
-    std::vector<CordzHandle*> to_delete;
-    {
-      MutexLock lock(global_queue.mutex);
-      CordzHandle* next = dq_next_;
-      if (dq_prev_ == nullptr) {
-        // We were head of the queue, delete every CordzHandle until we reach
-        // either the end of the list, or a snapshot handle.
-        while (next && !next->is_snapshot_) {
-          to_delete.push_back(next);
-          next = next->dq_next_;
-        }
-      } else {
-        // Another CordzHandle existed before this one, don't delete anything.
-        dq_prev_->dq_next_ = next;
-      }
-      if (next) {
-        next->dq_prev_ = dq_prev_;
-      } else {
-        global_queue.dq_tail.store(dq_prev_, std::memory_order_release);
-      }
-    }
-    for (CordzHandle* handle : to_delete) {
-      delete handle;
-    }
-  }
-}
-
-bool CordzHandle::SafeToDelete() const {
-  return is_snapshot_ || GlobalQueue().IsEmpty();
-}
-
-void CordzHandle::Delete(CordzHandle* handle) {
-  assert(handle);
-  if (handle) {
-    Queue& queue = GlobalQueue();
-    if (!handle->SafeToDelete()) {
-      MutexLock lock(queue.mutex);
-      CordzHandle* dq_tail = queue.dq_tail.load(std::memory_order_acquire);
-      if (dq_tail != nullptr) {
-        handle->dq_prev_ = dq_tail;
-        dq_tail->dq_next_ = handle;
-        queue.dq_tail.store(handle, std::memory_order_release);
-        return;
-      }
-    }
-    delete handle;
-  }
-}
-
-std::vector<const CordzHandle*> CordzHandle::DiagnosticsGetDeleteQueue() {
-  std::vector<const CordzHandle*> handles;
-  Queue& global_queue = GlobalQueue();
-  MutexLock lock(global_queue.mutex);
-  CordzHandle* dq_tail = global_queue.dq_tail.load(std::memory_order_acquire);
-  for (const CordzHandle* p = dq_tail; p; p = p->dq_prev_) {
-    handles.push_back(p);
-  }
-  return handles;
-}
-
-bool CordzHandle::DiagnosticsHandleIsSafeToInspect(
-    const CordzHandle* handle) const {
-  if (!is_snapshot_) return false;
-  if (handle == nullptr) return true;
-  if (handle->is_snapshot_) return false;
-  bool snapshot_found = false;
-  Queue& global_queue = GlobalQueue();
-  MutexLock lock(global_queue.mutex);
-  for (const CordzHandle* p = global_queue.dq_tail; p; p = p->dq_prev_) {
-    if (p == handle) return !snapshot_found;
-    if (p == this) snapshot_found = true;
-  }
-  ABSL_ASSERT(snapshot_found);  // Assert that 'this' is in delete queue.
-  return true;
-}
-
-std::vector<const CordzHandle*>
-CordzHandle::DiagnosticsGetSafeToInspectDeletedHandles() {
-  std::vector<const CordzHandle*> handles;
-  if (!is_snapshot()) {
-    return handles;
-  }
-
-  Queue& global_queue = GlobalQueue();
-  MutexLock lock(global_queue.mutex);
-  for (const CordzHandle* p = dq_next_; p != nullptr; p = p->dq_next_) {
-    if (!p->is_snapshot()) {
-      handles.push_back(p);
-    }
-  }
-  return handles;
-}
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/strings/internal/cordz_handle.h

@@ -1,98 +0,0 @@
-// Copyright 2019 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_STRINGS_INTERNAL_CORDZ_HANDLE_H_
-#define ABSL_STRINGS_INTERNAL_CORDZ_HANDLE_H_
-
-#include <atomic>
-#include <vector>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/raw_logging.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// This base class allows multiple types of object (CordzInfo and
-// CordzSampleToken) to exist simultaneously on the delete queue (pointed to by
-// global_dq_tail and traversed using dq_prev_ and dq_next_). The
-// delete queue guarantees that once a profiler creates a CordzSampleToken and
-// has gained visibility into a CordzInfo object, that CordzInfo object will not
-// be deleted prematurely. This allows the profiler to inspect all CordzInfo
-// objects that are alive without needing to hold a global lock.
-class ABSL_DLL CordzHandle {
- public:
-  CordzHandle() : CordzHandle(false) {}
-
-  bool is_snapshot() const { return is_snapshot_; }
-
-  // Returns true if this instance is safe to be deleted because it is either a
-  // snapshot, which is always safe to delete, or not included in the global
-  // delete queue and thus not included in any snapshot.
-  // Callers are responsible for making sure this instance can not be newly
-  // discovered by other threads. For example, CordzInfo instances first de-list
-  // themselves from the global CordzInfo list before determining if they are
-  // safe to be deleted directly.
-  // If SafeToDelete returns false, callers MUST use the Delete() method to
-  // safely queue CordzHandle instances for deletion.
-  bool SafeToDelete() const;
-
-  // Deletes the provided instance, or puts it on the delete queue to be deleted
-  // once there are no more sample tokens (snapshot) instances potentially
-  // referencing the instance. `handle` should not be null.
-  static void Delete(CordzHandle* handle);
-
-  // Returns the current entries in the delete queue in LIFO order.
-  static std::vector<const CordzHandle*> DiagnosticsGetDeleteQueue();
-
-  // Returns true if the provided handle is nullptr or guarded by this handle.
-  // Since the CordzSnapshot token is itself a CordzHandle, this method will
-  // allow tests to check if that token is keeping an arbitrary CordzHandle
-  // alive.
-  bool DiagnosticsHandleIsSafeToInspect(const CordzHandle* handle) const;
-
-  // Returns the current entries in the delete queue, in LIFO order, that are
-  // protected by this. CordzHandle objects are only placed on the delete queue
-  // after CordzHandle::Delete is called with them as an argument. Only
-  // CordzHandle objects that are not also CordzSnapshot objects will be
-  // included in the return vector. For each of the handles in the return
-  // vector, the earliest that their memory can be freed is when this
-  // CordzSnapshot object is deleted.
-  std::vector<const CordzHandle*> DiagnosticsGetSafeToInspectDeletedHandles();
-
- protected:
-  explicit CordzHandle(bool is_snapshot);
-  virtual ~CordzHandle();
-
- private:
-  const bool is_snapshot_;
-
-  // dq_prev_ and dq_next_ require the global queue mutex to be held.
-  // Unfortunately we can't use thread annotations such that the thread safety
-  // analysis understands that queue_ and global_queue_ are one and the same.
-  CordzHandle* dq_prev_  = nullptr;
-  CordzHandle* dq_next_ = nullptr;
-};
-
-class CordzSnapshot : public CordzHandle {
- public:
-  CordzSnapshot() : CordzHandle(true) {}
-};
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_STRINGS_INTERNAL_CORDZ_HANDLE_H_

package/deps/abseil-cpp/absl/strings/internal/cordz_handle_test.cc

@@ -1,265 +0,0 @@
-// Copyright 2019 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/strings/internal/cordz_handle.h"
-
-#include <random>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/memory/memory.h"
-#include "absl/synchronization/internal/thread_pool.h"
-#include "absl/synchronization/notification.h"
-#include "absl/time/clock.h"
-#include "absl/time/time.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-namespace {
-
-using ::testing::ElementsAre;
-using ::testing::Gt;
-using ::testing::IsEmpty;
-using ::testing::SizeIs;
-
-// Local less verbose helper
-std::vector<const CordzHandle*> DeleteQueue() {
-  return CordzHandle::DiagnosticsGetDeleteQueue();
-}
-
-struct CordzHandleDeleteTracker : public CordzHandle {
-  bool* deleted;
-  explicit CordzHandleDeleteTracker(bool* deleted) : deleted(deleted) {}
-  ~CordzHandleDeleteTracker() override { *deleted = true; }
-};
-
-TEST(CordzHandleTest, DeleteQueueIsEmpty) {
-  EXPECT_THAT(DeleteQueue(), SizeIs(0));
-}
-
-TEST(CordzHandleTest, CordzHandleCreateDelete) {
-  bool deleted = false;
-  auto* handle = new CordzHandleDeleteTracker(&deleted);
-  EXPECT_FALSE(handle->is_snapshot());
-  EXPECT_TRUE(handle->SafeToDelete());
-  EXPECT_THAT(DeleteQueue(), SizeIs(0));
-
-  CordzHandle::Delete(handle);
-  EXPECT_THAT(DeleteQueue(), SizeIs(0));
-  EXPECT_TRUE(deleted);
-}
-
-TEST(CordzHandleTest, CordzSnapshotCreateDelete) {
-  auto* snapshot = new CordzSnapshot();
-  EXPECT_TRUE(snapshot->is_snapshot());
-  EXPECT_TRUE(snapshot->SafeToDelete());
-  EXPECT_THAT(DeleteQueue(), ElementsAre(snapshot));
-  delete snapshot;
-  EXPECT_THAT(DeleteQueue(), SizeIs(0));
-}
-
-TEST(CordzHandleTest, CordzHandleCreateDeleteWithSnapshot) {
-  bool deleted = false;
-  auto* snapshot = new CordzSnapshot();
-  auto* handle = new CordzHandleDeleteTracker(&deleted);
-  EXPECT_FALSE(handle->SafeToDelete());
-
-  CordzHandle::Delete(handle);
-  EXPECT_THAT(DeleteQueue(), ElementsAre(handle, snapshot));
-  EXPECT_FALSE(deleted);
-  EXPECT_FALSE(handle->SafeToDelete());
-
-  delete snapshot;
-  EXPECT_THAT(DeleteQueue(), SizeIs(0));
-  EXPECT_TRUE(deleted);
-}
-
-TEST(CordzHandleTest, MultiSnapshot) {
-  bool deleted[3] = {false, false, false};
-
-  CordzSnapshot* snapshot[3];
-  CordzHandleDeleteTracker* handle[3];
-  for (int i = 0; i < 3; ++i) {
-    snapshot[i] = new CordzSnapshot();
-    handle[i] = new CordzHandleDeleteTracker(&deleted[i]);
-    CordzHandle::Delete(handle[i]);
-  }
-
-  EXPECT_THAT(DeleteQueue(), ElementsAre(handle[2], snapshot[2], handle[1],
-                                         snapshot[1], handle[0], snapshot[0]));
-  EXPECT_THAT(deleted, ElementsAre(false, false, false));
-
-  delete snapshot[1];
-  EXPECT_THAT(DeleteQueue(), ElementsAre(handle[2], snapshot[2], handle[1],
-                                         handle[0], snapshot[0]));
-  EXPECT_THAT(deleted, ElementsAre(false, false, false));
-
-  delete snapshot[0];
-  EXPECT_THAT(DeleteQueue(), ElementsAre(handle[2], snapshot[2]));
-  EXPECT_THAT(deleted, ElementsAre(true, true, false));
-
-  delete snapshot[2];
-  EXPECT_THAT(DeleteQueue(), SizeIs(0));
-  EXPECT_THAT(deleted, ElementsAre(true, true, deleted));
-}
-
-TEST(CordzHandleTest, DiagnosticsHandleIsSafeToInspect) {
-  CordzSnapshot snapshot1;
-  EXPECT_TRUE(snapshot1.DiagnosticsHandleIsSafeToInspect(nullptr));
-
-  auto* handle1 = new CordzHandle();
-  EXPECT_TRUE(snapshot1.DiagnosticsHandleIsSafeToInspect(handle1));
-
-  CordzHandle::Delete(handle1);
-  EXPECT_TRUE(snapshot1.DiagnosticsHandleIsSafeToInspect(handle1));
-
-  CordzSnapshot snapshot2;
-  auto* handle2 = new CordzHandle();
-  EXPECT_TRUE(snapshot1.DiagnosticsHandleIsSafeToInspect(handle1));
-  EXPECT_TRUE(snapshot1.DiagnosticsHandleIsSafeToInspect(handle2));
-  EXPECT_FALSE(snapshot2.DiagnosticsHandleIsSafeToInspect(handle1));
-  EXPECT_TRUE(snapshot2.DiagnosticsHandleIsSafeToInspect(handle2));
-
-  CordzHandle::Delete(handle2);
-  EXPECT_TRUE(snapshot1.DiagnosticsHandleIsSafeToInspect(handle1));
-}
-
-TEST(CordzHandleTest, DiagnosticsGetSafeToInspectDeletedHandles) {
-  EXPECT_THAT(DeleteQueue(), IsEmpty());
-
-  auto* handle = new CordzHandle();
-  auto* snapshot1 = new CordzSnapshot();
-
-  // snapshot1 should be able to see handle.
-  EXPECT_THAT(DeleteQueue(), ElementsAre(snapshot1));
-  EXPECT_TRUE(snapshot1->DiagnosticsHandleIsSafeToInspect(handle));
-  EXPECT_THAT(snapshot1->DiagnosticsGetSafeToInspectDeletedHandles(),
-              IsEmpty());
-
-  // This handle will be safe to inspect as long as snapshot1 is alive. However,
-  // since only snapshot1 can prove that it's alive, it will be hidden from
-  // snapshot2.
-  CordzHandle::Delete(handle);
-
-  // This snapshot shouldn't be able to see handle because handle was already
-  // sent to Delete.
-  auto* snapshot2 = new CordzSnapshot();
-
-  // DeleteQueue elements are LIFO order.
-  EXPECT_THAT(DeleteQueue(), ElementsAre(snapshot2, handle, snapshot1));
-
-  EXPECT_TRUE(snapshot1->DiagnosticsHandleIsSafeToInspect(handle));
-  EXPECT_FALSE(snapshot2->DiagnosticsHandleIsSafeToInspect(handle));
-
-  EXPECT_THAT(snapshot1->DiagnosticsGetSafeToInspectDeletedHandles(),
-              ElementsAre(handle));
-  EXPECT_THAT(snapshot2->DiagnosticsGetSafeToInspectDeletedHandles(),
-              IsEmpty());
-
-  CordzHandle::Delete(snapshot1);
-  EXPECT_THAT(DeleteQueue(), ElementsAre(snapshot2));
-
-  CordzHandle::Delete(snapshot2);
-  EXPECT_THAT(DeleteQueue(), IsEmpty());
-}
-
-// Create and delete CordzHandle and CordzSnapshot objects in multiple threads
-// so that tsan has some time to chew on it and look for memory problems.
-TEST(CordzHandleTest, MultiThreaded) {
-  Notification stop;
-  static constexpr int kNumThreads = 4;
-  // Keep the number of handles relatively small so that the test will naturally
-  // transition to an empty delete queue during the test. If there are, say, 100
-  // handles, that will virtually never happen. With 10 handles and around 50k
-  // iterations in each of 4 threads, the delete queue appears to become empty
-  // around 200 times.
-  static constexpr int kNumHandles = 10;
-
-  // Each thread is going to pick a random index and atomically swap its
-  // CordzHandle with one in handles. This way, each thread can avoid
-  // manipulating a CordzHandle that might be operated upon in another thread.
-  std::vector<std::atomic<CordzHandle*>> handles(kNumHandles);
-
-  // global bool which is set when any thread did get some 'safe to inspect'
-  // handles. On some platforms and OSS tests, we might risk that some pool
-  // threads are starved, stalled, or just got a few unlikely random 'handle'
-  // coin tosses, so we satisfy this test with simply observing 'some' thread
-  // did something meaningful, which should minimize the potential for flakes.
-  std::atomic<bool> found_safe_to_inspect(false);
-
-  {
-    absl::synchronization_internal::ThreadPool pool(kNumThreads);
-    for (int i = 0; i < kNumThreads; ++i) {
-      pool.Schedule([&stop, &handles, &found_safe_to_inspect]() {
-        std::minstd_rand gen;
-        std::uniform_int_distribution<int> dist_type(0, 2);
-        std::uniform_int_distribution<int> dist_handle(0, kNumHandles - 1);
-
-        while (!stop.HasBeenNotified()) {
-          CordzHandle* handle;
-          switch (dist_type(gen)) {
-            case 0:
-              handle = new CordzHandle();
-              break;
-            case 1:
-              handle = new CordzSnapshot();
-              break;
-            default:
-              handle = nullptr;
-              break;
-          }
-          CordzHandle* old_handle = handles[dist_handle(gen)].exchange(handle);
-          if (old_handle != nullptr) {
-            std::vector<const CordzHandle*> safe_to_inspect =
-                old_handle->DiagnosticsGetSafeToInspectDeletedHandles();
-            for (const CordzHandle* handle : safe_to_inspect) {
-              // We're in a tight loop, so don't generate too many error
-              // messages.
-              ASSERT_FALSE(handle->is_snapshot());
-            }
-            if (!safe_to_inspect.empty()) {
-              found_safe_to_inspect.store(true);
-            }
-            CordzHandle::Delete(old_handle);
-          }
-        }
-
-        // Have each thread attempt to clean up everything. Some thread will be
-        // the last to reach this cleanup code, and it will be guaranteed to
-        // clean up everything because nothing remains to create new handles.
-        for (auto& h : handles) {
-          if (CordzHandle* handle = h.exchange(nullptr)) {
-            CordzHandle::Delete(handle);
-          }
-        }
-      });
-    }
-
-    // The threads will hammer away.  Give it a little bit of time for tsan to
-    // spot errors.
-    absl::SleepFor(absl::Seconds(3));
-    stop.Notify();
-  }
-
-  // Confirm that the test did *something*. This check will be satisfied as
-  // long as any thread has deleted a CordzSnapshot object and a non-snapshot
-  // CordzHandle was deleted after the CordzSnapshot was created.
-  // See also comments on `found_safe_to_inspect`
-  EXPECT_TRUE(found_safe_to_inspect.load());
-}
-
-}  // namespace
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
-}  // namespace absl