initial

td/tdutils/td/utils/HazardPointers.h

@@ -0,0 +1,141 @@
+//
+// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2024
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+#pragma once
+
+#include "td/utils/common.h"
+
+#include <array>
+#include <atomic>
+#include <memory>
+
+namespace td {
+
+template <class T, int MaxPointersN = 1, class Deleter = std::default_delete<T>>
+class HazardPointers {
+ public:
+  explicit HazardPointers(size_t threads_n) : threads_(threads_n) {
+    for (auto &data : threads_) {
+      for (auto &ptr : data.hazard_) {
+// workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64658
+#if TD_GCC && GCC_VERSION <= 40902
+        ptr = nullptr;
+#else
+        std::atomic_init(&ptr, static_cast<T *>(nullptr));
+#endif
+      }
+    }
+  }
+  HazardPointers(const HazardPointers &) = delete;
+  HazardPointers &operator=(const HazardPointers &) = delete;
+  HazardPointers(HazardPointers &&) = delete;
+  HazardPointers &operator=(HazardPointers &&) = delete;
+
+  class Holder {
+   public:
+    template <class S>
+    S *protect(std::atomic<S *> &to_protect) {
+      return do_protect(hazard_ptr_, to_protect);
+    }
+    Holder(HazardPointers &hp, size_t thread_id, size_t pos) : Holder(hp.get_hazard_ptr(thread_id, pos)) {
+      CHECK(hazard_ptr_.load() == 0);
+      hazard_ptr_.store(reinterpret_cast<T *>(1));
+    }
+    Holder(const Holder &) = delete;
+    Holder &operator=(const Holder &) = delete;
+    Holder(Holder &&) = delete;
+    Holder &operator=(Holder &&) = delete;
+    ~Holder() {
+      clear();
+    }
+    void clear() {
+      hazard_ptr_.store(nullptr, std::memory_order_release);
+    }
+
+   private:
+    friend class HazardPointers;
+    explicit Holder(std::atomic<T *> &ptr) : hazard_ptr_(ptr) {
+    }
+    std::atomic<T *> &hazard_ptr_;
+  };
+
+  void retire(size_t thread_id, T *ptr = nullptr) {
+    CHECK(thread_id < threads_.size());
+    auto &data = threads_[thread_id];
+    if (ptr) {
+      data.to_delete_.push_back(std::unique_ptr<T, Deleter>(ptr));
+    }
+    for (auto it = data.to_delete_.begin(); it != data.to_delete_.end();) {
+      if (!is_protected(it->get())) {
+        it->reset();
+        it = data.to_delete_.erase(it);
+      } else {
+        ++it;
+      }
+    }
+  }
+
+  // old inteface
+  T *protect(size_t thread_id, size_t pos, std::atomic<T *> &ptr) {
+    return do_protect(get_hazard_ptr(thread_id, pos), ptr);
+  }
+  void clear(size_t thread_id, size_t pos) {
+    do_clear(get_hazard_ptr(thread_id, pos));
+  }
+
+  size_t to_delete_size_unsafe() const {
+    size_t res = 0;
+    for (auto &thread_data : threads_) {
+      res += thread_data.to_delete_.size();
+    }
+    return res;
+  }
+
+ private:
+  struct ThreadData {
+    std::array<std::atomic<T *>, MaxPointersN> hazard_;
+    char pad[TD_CONCURRENCY_PAD - sizeof(std::array<std::atomic<T *>, MaxPointersN>)];
+
+    // stupid gc
+    std::vector<std::unique_ptr<T, Deleter>> to_delete_;
+    char pad2[TD_CONCURRENCY_PAD - sizeof(std::vector<std::unique_ptr<T, Deleter>>)];
+  };
+  std::vector<ThreadData> threads_;
+  char pad2[TD_CONCURRENCY_PAD - sizeof(std::vector<ThreadData>)];
+
+  template <class S>
+  static S *do_protect(std::atomic<T *> &hazard_ptr, std::atomic<S *> &to_protect) {
+    T *saved = nullptr;
+    T *to_save;
+    while ((to_save = to_protect.load()) != saved) {
+      hazard_ptr.store(to_save);
+      saved = to_save;
+    }
+    return static_cast<S *>(saved);
+  }
+
+  static void do_clear(std::atomic<T *> &hazard_ptr) {
+    hazard_ptr.store(nullptr, std::memory_order_release);
+  }
+
+  bool is_protected(T *ptr) {
+    for (auto &thread_data : threads_) {
+      for (auto &hazard_ptr : thread_data.hazard_) {
+        if (hazard_ptr.load() == ptr) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  std::atomic<T *> &get_hazard_ptr(size_t thread_id, size_t pos) {
+    CHECK(thread_id < threads_.size());
+    return threads_[thread_id].hazard_[pos];
+  }
+};
+
+}  // namespace td