api.cc

Go to the documentation of this file.

#include "include/broom.h"
#include "src/allocator.h"
#include "src/garbage-collector.h"
 
namespace broom {
thread_local GarbageCollector* t_gc = nullptr;
void thread_init(broom_configuration config) {
  BENSURE_EQ(t_gc, nullptr, "Garbage collector state already initialized.");
  t_gc = new GarbageCollector(config);
  BENSURE_NE(t_gc, nullptr, "Garbage collector could not be initialized.");
}
void thread_teardown() {
  BENSURE_NE(t_gc, nullptr,
             "Attempting to delete an uninitialized garbage collector state");
  delete t_gc;
  t_gc = nullptr;
}
 
#ifdef BROOM_FOR_TESTING
GarbageCollector* thread_get_gc() { return t_gc; }
#endif
 
namespace __impl {
void* AllocateRaw(size_t size) { return t_gc->AllocateRawDontRegister(size); }
void RegisterWithGc(const void* pointer, Destructor destructor) {
  t_gc->RegisterPointer(pointer, destructor);
}
void ShareRaw(const void* pointer, uint32_t how_many) {
  t_gc->Pin(SafeCast<const void*>(pointer), how_many);
}
void UnpinPointer(GarbageCollector* gc, const void* pointer) {
  gc->Unpin(pointer);
}
GarbageCollector* GetGarbageCollector() { return t_gc; }
void TurnOffGarbageCollection() { t_gc->DisableAutomatedCollection(); }
void TurnOnGarbageCollection() { t_gc->EnableAutomatedCollection(); }
}  // namespace __impl
 
void force_collection() { t_gc->ForceFastCollection(); }
void force_slow_collection() { t_gc->ForceSlowCollection(); }
void register_external(const void* pointer, size_t size) {
  t_gc->RegisterExternalRoot(ExternalRoot{pointer, size});
}
void unregister_external(const void* pointer) {
  t_gc->UnregisterExternalRoot(ExternalRoot{pointer, 0});
}
 
BroomValue::BroomValue(GarbageCollector* gc)
    : gc_(gc), precise_root_ref_(gc_->RegisterPreciseRoot(PreciseRoot(this))) {}
BroomValue::BroomValue() : BroomValue(t_gc) {}
BroomValue::BroomValue(const BroomValue& other) : BroomValue(other.gc_) {}
BroomValue::~BroomValue() { gc_->UnregisterPreciseRoot(precise_root_ref_); }
 
BroomValue& BroomValue::operator=(const BroomValue& other) {
  if (this == &other) return *this;
  BENSURE(gc_ == other.gc_, "Expected the garbage collector pointers");
  BASSERT_NE(precise_root_ref_, nullptr,
             "Expected a valid precise root reference");
  gc_->UnregisterPreciseRoot(precise_root_ref_);
  precise_root_ref_ = gc_->RegisterPreciseRoot(PreciseRoot(this));
  return *this;
}
 
BroomValue& BroomValue::operator=(BroomValue&& other) noexcept {
  if (this == &other) return *this;
  BENSURE(gc_ == other.gc_, "Expected the garbage collector pointers");
  gc_->UnregisterPreciseRoot(precise_root_ref_);
  BASSERT_NE(precise_root_ref_, nullptr,
             "Expected a valid precise root reference");
  precise_root_ref_ = gc_->RegisterPreciseRoot(PreciseRoot(this));
  return *this;
}
}  // namespace broom