roots.h

Go to the documentation of this file.

#pragma once
 
#include <absl/container/btree_set.h>
 
#include <cstdint>
#include <list>
#include <type_traits>
 
#include "include/broom.h"
#include "src/allocator.h"
#include "src/globals.h"
 
namespace broom {
enum class RootKind {
  kStack,     // No special class
  kExternal,  // class ExternalRoot
  kPrecise,   // class PreciseRoot
  kRegular,   // Heap pointer, no special class.
};
 
// An external root is one that was explicitly registered with Broom with a
// given base pointer and size. The base pointer can be a managed or unmanaged
// root, but any pointers inside of the region must be pointer-aligned.
class ExternalRoot {
 private:
  static bool SetCompareFn(const ExternalRoot& r1, const ExternalRoot& r2) {
    return SafeCast<MemoryAddress>(r1.Pointer()) <
           SafeCast<MemoryAddress>(r2.Pointer());
  }
 
 public:
  static constexpr const RootKind kRootKind = RootKind::kExternal;
  explicit ExternalRoot(UintPtr pointer, size_t size)
      : pointer_(pointer), size_(size) {}
  explicit ExternalRoot(const void* pointer, size_t size)
      : pointer_(SafeCast<UintPtr>(pointer)), size_(size) {}
  ~ExternalRoot() = default;
 
  const void* const* Start() const {
    return SafeCast<const void* const*>(pointer_);
  }
  const void* Pointer() const { return SafeCast<const void*>(pointer_); }
  const void* const* End() const {
    return SafeCast<const void* const*>(pointer_ + size_);
  }
 
  UintPtr StartUintPtr() const { return pointer_; }
  UintPtr EndUintPtr() const { return pointer_ + size_; }
 
  using SetCompare =
      std::integral_constant<decltype(&SetCompareFn), &SetCompareFn>;
 
 private:
  UintPtr pointer_;
  size_t size_;
};
 
static_assert(std::is_trivially_destructible_v<ExternalRoot>);
static_assert(sizeof(ExternalRoot) == kPointerSize + sizeof(size_t));
 
class GarbageCollector;
 
// A precise root is created by inheriting from the BroomValue/gc_root class and
// calling its constructor. Any precise root must have a
//
//   void Visit(Visitor*) const;
//
// method implemented, as this method will be called during the marking phase of
// the GC, allowing each root to mark its own pointer members.
class PreciseRoot {
 public:
  static constexpr const RootKind kRootKind = RootKind::kPrecise;
  explicit PreciseRoot(UintPtr pointer)
      : broom_value_(SafeCast<const BroomValue*>(pointer)) {}
  explicit PreciseRoot(const void* pointer)
      : broom_value_(SafeCast<const BroomValue*>(pointer)) {}
  const BroomValue* Class() const { return broom_value_; }
 
 private:
  using List = std::list<PreciseRoot>;
  using Reference = List::iterator;
  const Reference GetReference() const { return reference_in_list_; }
  void UpdateReference(PreciseRoot::Reference ref) { reference_in_list_ = ref; }
 
  const BroomValue* broom_value_;
  Reference reference_in_list_;
  friend class GarbageCollector;
};
 
// The main visitor for our roots. Its responsibility is to recursively visit
// every managed pointer from a given root. RootVisitor also exposes
// IterateStackAndVisitStackRoots, which iterates through the thread's stack
// from top to bottom, visiting each pointer.
class RootVisitor : public Visitor {
 public:
  explicit RootVisitor(Allocator* allocator, GarbageCollector* gc)
      : allocator_(allocator), gc_(gc) {}
  virtual void Visit(const void* pointer) { VisitRegularRoot(pointer); }
  void IterateStackAndVisitRoots();
  template <RootKind kind>
  void Visit(const void* root);
 
 private:
  void VisitRegularRoot(const void* pointer);
  void VisitStackRoot(const void* pointer);
  void VisitExternalRoot(const ExternalRoot* external_root);
  void VisitPreciseRoot(const PreciseRoot* precise_root);
 
  Allocator* allocator_;
  GarbageCollector* gc_;
};
}  // namespace broom