garbage-collector.cc

Go to the documentation of this file.

#include "src/garbage-collector.h"
 
#include "src/allocator-inl.h"
#include "src/allocator.h"
#include "src/garbage-collector.h"
#include "src/globals.h"
#include "src/macros.h"
#include "src/roots-inl.h"
#include "src/roots.h"
 
namespace broom {
// Atomically mark all the managed pointers. This will never be interrupted.
void GarbageCollector::AtomicMark() {
  BASSERT_EQ(to_collect_.size(), 0, "to_collect size is not 0");
  to_collect_.swap(alive_);
  // First go through the stack to try and identify our roots on the stack.
  root_visitor_.IterateStackAndVisitRoots();
  // Now go through the external roots, such as unmanaged pointers that might be
  // pointing to managed memory as the application told us.
  for (const ExternalRoot& external_root : external_roots_) {
    root_visitor_.Visit<RootKind::kExternal>(&external_root);
  }
  // Finally, go through the precise roots for which the application will trace
  // its own pointers for us.
  for (PreciseRoot& precise_root : precise_roots_) {
    root_visitor_.Visit<RootKind::kPrecise>(&precise_root);
  }
 
  // If we support sharing, mark through the pinned allocations.
  if (configuration_.support_sharing) {
    // Now go through the unmarked pointers and check if any of them are pinned.
    // This can happen through BroomSharingPointers. If the pointer is pinned,
    // move it to the alive set. Otherwise, we will sweep it later. We do this
    // during marking because it is easier to reason about in the context of
    // concurrency. When we implement concurrent and incremental sweeping, we
    // might choose to do it differently.
    // FIXME(gc): This is a quite ugly way to do this.
    auto it = to_collect_.begin();
    while (it != to_collect_.end()) {
      if (Allocator::IsPinnedBasePointer(it->Pointer())) {
        // Scan anything that this root points to.
        root_visitor_.Visit<RootKind::kRegular>(it->Pointer());
        it = to_collect_.begin();
      } else {
        ++it;
      }
    }
  }
}
 
void GarbageCollector::AtomicSweep() {
  for (const GcNode& node : alive_) {
    AllocatorFrontMetadata* metadata = UnsafeCast<AllocatorFrontMetadata*>(
        SafeCast<UintPtr>(node.Pointer()) - Allocator::kFrontMetadataSize);
    metadata->UnmarkScanned();
  }
  for (auto it = to_collect_.begin(); it != to_collect_.end();) {
    if (it->HasDestructor()) {
      it->RunDestructor();
    }
 
    allocator_->Dispose(const_cast<void*>(it->Pointer()));
    it = to_collect_.erase(it);
  }
}
}  // namespace broom