sweeper.h

Go to the documentation of this file.

// Copyright 2020 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#ifndef V8_HEAP_CPPGC_SWEEPER_H_
#define V8_HEAP_CPPGC_SWEEPER_H_
 
#include <memory>
 
#include "src/base/macros.h"
#include "src/base/platform/time.h"
#include "src/heap/cppgc/heap-config.h"
#include "src/heap/cppgc/memory.h"
#include "src/heap/cppgc/stats-collector.h"
 
namespace cppgc::internal {
 
class HeapBase;
class ConcurrentSweeperTest;
class BaseSpace;
 
class V8_EXPORT_PRIVATE Sweeper final {
 public:
  class V8_EXPORT_PRIVATE SweepingOnMutatorThreadObserver {
   public:
    explicit SweepingOnMutatorThreadObserver(Sweeper&);
    virtual ~SweepingOnMutatorThreadObserver();
 
    virtual void Start() = 0;
    virtual void End() = 0;
 
   private:
    Sweeper& sweeper_;
  };
 
  static constexpr bool CanDiscardMemory() {
#if defined(V8_OS_WIN)
    // Discarding memory on Windows does not decommit the memory and does not
    // contribute to reduce the memory footprint. On the other hand, these
    // calls become expensive the more memory is allocated in the system and
    // can result in hangs. Thus, it is better to not discard on Windows.
    return false;
#else
    return CheckMemoryIsInaccessibleIsNoop();
#endif
  }
 
  explicit Sweeper(HeapBase&);
  ~Sweeper();
 
  Sweeper(const Sweeper&) = delete;
  Sweeper& operator=(const Sweeper&) = delete;
 
  // Starts sweeping. Assumes that the heap holds no linear allocation buffers.
  // Will not finish sweeping in case SweepingConfig::sweeping_type is
  // SweepingType::kAtomic but rely on the caller to finish sweeping
  // immediately.
  void Start(SweepingConfig);
  // Returns true when sweeping was finished and false if it was not running or
  // couldn't be finished due to being a recursive sweep call.
  bool FinishIfRunning();
  void FinishIfOutOfWork();
  // SweepForAllocationIfRunning sweeps the given `space` until a slot that can
  // fit an allocation of `min_wanted_size` bytes is found. Returns true if a
  // slot was found. Aborts after `max_duration`.
  bool SweepForAllocationIfRunning(BaseSpace* space, size_t min_wanted_size,
                                   v8::base::TimeDelta max_duration);
 
  bool IsSweepingOnMutatorThread() const;
  bool IsSweepingInProgress() const;
 
  // Assist with sweeping. Returns true if sweeping is done.
  bool PerformSweepOnMutatorThread(v8::base::TimeDelta max_duration,
                                   StatsCollector::ScopeId);
 
 private:
  void WaitForConcurrentSweepingForTesting();
 
  class SweeperImpl;
 
  HeapBase& heap_;
  std::unique_ptr<SweeperImpl> impl_;
 
  friend class ConcurrentSweeperTest;
};
 
}  // namespace cppgc::internal
 
#endif  // V8_HEAP_CPPGC_SWEEPER_H_