broom.h

Go to the documentation of this file.

#pragma once
 
#include <assert.h>
#include <stddef.h>
 
#include <memory>
#include <type_traits>
 
#if defined(_WIN32)
#define BROOM_EXPORT __declspec(dllexport)
#else
#define BROOM_EXPORT __attribute__((visibility("default")))
#endif
 
#define __BROOM_IMPL_CONSTRUCT_T(v, T, args) \
  new (v) T(std::forward<Args>(args)...)
#define __BROOM_IMPL_DESTRUCTOR_T(T) \
  [](const void* pointer) { static_cast<const T*>(pointer)->~T(); }
#define __BROOM_IMPL_ALLOCATE_T(T, RegisterFunction, AllocateFunction, args) \
  {                                                                          \
    T* t_to_return;                                                          \
    void* to_return;                                                         \
    if constexpr (!std::is_same_v<T, void>) {                                \
      to_return = AllocateFunction(count * sizeof(T));                       \
      t_to_return = __BROOM_IMPL_CONSTRUCT_T(to_return, T, args);            \
      RegisterFunction(to_return, __BROOM_IMPL_DESTRUCTOR_T(T));             \
    } else {                                                                 \
      to_return = AllocateFunction(count);                                   \
      t_to_return = to_return;                                               \
      RegisterFunction(to_return, nullptr);                                  \
    }                                                                        \
    return t_to_return;                                                      \
  }
 
struct broom_configuration_s {
  bool support_sharing = false;
  bool run_destructors_on_shutdown = true;
};
 
typedef struct broom_configuration_s broom_configuration;
 
namespace broom {
class GarbageCollector;
extern thread_local GarbageCollector* t_gc;
BROOM_EXPORT void thread_init(broom_configuration config = {});
BROOM_EXPORT void thread_teardown();
 
#ifdef BROOM_FOR_TESTING
// This is a workaround for Windows thread-local storage.
BROOM_EXPORT GarbageCollector* thread_get_gc();
#endif
 
struct BROOM_EXPORT BroomScope {
  BroomScope(broom_configuration config = {}) { thread_init(config); }
  ~BroomScope() { thread_teardown(); }
 
  BroomScope(const BroomScope& other) = delete;
  BroomScope(BroomScope&& other) = delete;
  BroomScope& operator=(const BroomScope& other) = delete;
  BroomScope& operator=(BroomScope&& other) = delete;
};
 
struct BROOM_EXPORT BroomNoDestructorScope {
  BroomNoDestructorScope(broom_configuration config = {}) {
    config.run_destructors_on_shutdown = false;
    thread_init(config);
  }
  ~BroomNoDestructorScope() { thread_teardown(); }
 
  BroomNoDestructorScope(const BroomNoDestructorScope& other) = delete;
  BroomNoDestructorScope(BroomNoDestructorScope&& other) = delete;
  BroomNoDestructorScope& operator=(const BroomNoDestructorScope& other) =
      delete;
  BroomNoDestructorScope& operator=(BroomNoDestructorScope&& other) = delete;
};
 
struct BROOM_EXPORT BroomSharingScope {
  BroomSharingScope(broom_configuration config = {}) {
    config.support_sharing = true;
    thread_init(config);
  }
  ~BroomSharingScope() { thread_teardown(); }
 
  BroomSharingScope(const BroomSharingScope& other) = delete;
  BroomSharingScope(BroomSharingScope&& other) = delete;
  BroomSharingScope& operator=(const BroomSharingScope& other) = delete;
  BroomSharingScope& operator=(BroomSharingScope&& other) = delete;
};
 
struct BROOM_EXPORT BroomSharingNoDestructorScope {
  BroomSharingNoDestructorScope(broom_configuration config = {}) {
    config.support_sharing = true;
    config.run_destructors_on_shutdown = false;
    thread_init(config);
  }
  ~BroomSharingNoDestructorScope() { thread_teardown(); }
 
  BroomSharingNoDestructorScope(const BroomSharingNoDestructorScope& other) =
      delete;
  BroomSharingNoDestructorScope(BroomSharingNoDestructorScope&& other) = delete;
  BroomSharingNoDestructorScope& operator=(
      const BroomSharingNoDestructorScope& other) = delete;
  BroomSharingNoDestructorScope& operator=(
      BroomSharingNoDestructorScope&& other) = delete;
};
 
using scope = BroomScope;
using sharing_scope = BroomSharingScope;
using no_destructor_scope = BroomNoDestructorScope;
using sharing_no_destructor_scope = BroomSharingNoDestructorScope;
 
using Destructor = std::add_pointer<void(const void*)>::type;
namespace __impl {
BROOM_EXPORT void* AllocateRaw(size_t size);
BROOM_EXPORT void RegisterWithGc(const void* pointer,
                                 Destructor destructor = nullptr);
BROOM_EXPORT void ShareRaw(const void* pointer, uint32_t how_many);
BROOM_EXPORT void UnpinPointer(GarbageCollector* gc, const void* pointer);
BROOM_EXPORT void TurnOnGarbageCollection();
BROOM_EXPORT void TurnOffGarbageCollection();
BROOM_EXPORT GarbageCollector* GetGarbageCollector();
}  // namespace __impl
 
struct BROOM_EXPORT BroomDisableGcScope {
  BroomDisableGcScope() { __impl::TurnOffGarbageCollection(); }
  ~BroomDisableGcScope() { __impl::TurnOnGarbageCollection(); }
 
  BroomDisableGcScope(const BroomDisableGcScope& other) = delete;
  BroomDisableGcScope(BroomDisableGcScope&& other) = delete;
  BroomDisableGcScope& operator=(const BroomDisableGcScope& other) = delete;
  BroomDisableGcScope& operator=(BroomDisableGcScope&& other) noexcept = delete;
};
 
using disable_gc_scope = BroomDisableGcScope;
 
// clang-format off
template <typename T, typename... Args>
T* allocate(size_t count, Args&&... args) {
  __BROOM_IMPL_ALLOCATE_T(T, ::broom::__impl::RegisterWithGc,
                          ::broom::__impl::AllocateRaw, args)
}
// clang-format on
 
BROOM_EXPORT void force_collection();
BROOM_EXPORT void force_slow_collection();
BROOM_EXPORT void register_external(const void* pointer, size_t size);
BROOM_EXPORT void unregister_external(const void* pointer);
 
class BROOM_EXPORT Visitor {
 public:
  Visitor() = default;
  // XXX(gc): Decide if this really needs to be virtual.
  virtual ~Visitor() = default;
  virtual void Visit(const void* pointer) = 0;
};
 
using gc_visitor = Visitor;
 
class BROOM_EXPORT BroomValue {
 public:
  virtual ~BroomValue();
  virtual void Visit(Visitor* visitor) const = 0;
 
 protected:
  BroomValue(GarbageCollector* gc);
  BroomValue();
  BroomValue(const BroomValue& other);
  BroomValue& operator=(const BroomValue& other);
  BroomValue& operator=(BroomValue&& other) noexcept;
 
 private:
  GarbageCollector* gc_;
  void* precise_root_ref_;
};
 
using gc_root = BroomValue;
 
template <typename T>
class BroomLifetimeAnchor;
 
template <typename T>
class BROOM_EXPORT BroomSharingPointer {
 public:
  BroomSharingPointer() = delete;
  BroomSharingPointer(const BroomSharingPointer& other)
      : gc_(other.gc_), ptr_(other.ptr_) {}
  ~BroomSharingPointer() = default;
 
  BroomSharingPointer& operator=(const BroomSharingPointer& other) = delete;
  BroomSharingPointer& operator=(const BroomSharingPointer&& other) noexcept =
      delete;
 
  T* to_unsafe_ptr() const { return ptr_; }
  T* operator->() { return ptr_; }
  T& operator*() { return *ptr_; }
 
  static constexpr BroomSharingPointer make(T* ptr, uint32_t how_many) {
    assert(how_many >= 1);
    __impl::ShareRaw(static_cast<const void*>(ptr), how_many);
    return BroomSharingPointer<T>(ptr);
  }
 
  void dispose() const { __impl::UnpinPointer(gc_, ptr_); }
 
 private:
  explicit BroomSharingPointer(T* ptr)
      : gc_(__impl::GetGarbageCollector()), ptr_(ptr) {}
 
  GarbageCollector* gc_;
  T* ptr_;
  friend class BroomLifetimeAnchor<T>;
};
 
template <typename T>
class BROOM_EXPORT BroomLifetimeAnchor {
 public:
  BroomLifetimeAnchor(BroomSharingPointer<T> ptr) : sharing_pointer_(ptr) {}
  ~BroomLifetimeAnchor() { sharing_pointer_.dispose(); }
 
  T* to_unsafe_ptr() const { return sharing_pointer_.ptr_; }
  T* operator->() { return sharing_pointer_.ptr_; }
  T& operator*() { return *sharing_pointer_.ptr_; }
 
 private:
  BroomSharingPointer<T> sharing_pointer_;
};
 
template <typename T>
using sharing_ptr = BroomSharingPointer<T>;
 
template <typename T>
using lifetime_anchor = BroomLifetimeAnchor<T>;
 
template <typename T>
sharing_ptr<T> share(T* ptr, uint32_t count = 1) {
  return sharing_ptr<T>::make(ptr, count);
}
}  // namespace broom
 
#undef BROOM_EXPORT