cppgc: Move sweeper to regular tasks

- Use non-idle tasks to be able to process finalizers on time.
- Only process finalizers while concurrent marking is still running.

Bug: v8:13294
Change-Id: I1a2812c3fc350ea679c4c916c230cf736f2aa3ea
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3904648
Commit-Queue: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Anton Bikineev <bikineev@chromium.org>
Cr-Commit-Position: refs/heads/main@{#83367}

BUILD.bazel

@@ -3105,6 +3105,7 @@ filegroup(
         "src/heap/cppgc/stats-collector.h",
         "src/heap/cppgc/sweeper.cc",
         "src/heap/cppgc/sweeper.h",
+        "src/heap/cppgc/heap-config.h",
         "src/heap/cppgc/task-handle.h",
         "src/heap/cppgc/trace-event.h",
         "src/heap/cppgc/trace-trait.cc",

BUILD.gn

@@ -5860,6 +5860,7 @@ v8_source_set("cppgc_base") {
     "src/heap/cppgc/globals.h",
     "src/heap/cppgc/heap-base.cc",
     "src/heap/cppgc/heap-base.h",
+    "src/heap/cppgc/heap-config.h",
     "src/heap/cppgc/heap-consistency.cc",
     "src/heap/cppgc/heap-growing.cc",
     "src/heap/cppgc/heap-growing.h",

src/heap/cppgc-js/cpp-heap.cc

@@ -753,14 +753,14 @@ void CppHeap::TraceEpilogue() {
 
   {
     cppgc::subtle::NoGarbageCollectionScope no_gc(*this);
-    cppgc::internal::Sweeper::SweepingConfig::CompactableSpaceHandling
+    cppgc::internal::SweepingConfig::CompactableSpaceHandling
         compactable_space_handling = compactor_.CompactSpacesIfEnabled();
-    const cppgc::internal::Sweeper::SweepingConfig sweeping_config{
+    const cppgc::internal::SweepingConfig sweeping_config{
         SelectSweepingType(), compactable_space_handling,
         ShouldReduceMemory(current_gc_flags_)
-            ? cppgc::internal::Sweeper::SweepingConfig::FreeMemoryHandling::
+            ? cppgc::internal::SweepingConfig::FreeMemoryHandling::
                   kDiscardWherePossible
-            : cppgc::internal::Sweeper::SweepingConfig::FreeMemoryHandling::
+            : cppgc::internal::SweepingConfig::FreeMemoryHandling::
                   kDoNotDiscard};
     DCHECK_IMPLIES(!isolate_,
                    SweepingType::kAtomic == sweeping_config.sweeping_type);
@@ -928,8 +928,8 @@ class CollectCustomSpaceStatisticsAtLastGCTask final : public v8::Task {
   void Run() final {
     cppgc::internal::Sweeper& sweeper = heap_.sweeper();
     if (sweeper.PerformSweepOnMutatorThread(
-            heap_.platform()->MonotonicallyIncreasingTime() +
-            kStepSizeMs.InSecondsF())) {
+            kStepSizeMs,
+            cppgc::internal::StatsCollector::kSweepInTaskForStatistics)) {
       // Sweeping is done.
       DCHECK(!sweeper.IsSweepingInProgress());
       ReportCustomSpaceStatistics(heap_.raw_heap(), std::move(custom_spaces_),

src/heap/cppgc/compactor.h

@@ -13,8 +13,7 @@ namespace cppgc {
 namespace internal {
 
 class V8_EXPORT_PRIVATE Compactor final {
-  using CompactableSpaceHandling =
-      Sweeper::SweepingConfig::CompactableSpaceHandling;
+  using CompactableSpaceHandling = SweepingConfig::CompactableSpaceHandling;
 
  public:
   explicit Compactor(RawHeap&);

src/heap/cppgc/garbage-collector.h

@@ -6,8 +6,8 @@
 #define V8_HEAP_CPPGC_GARBAGE_COLLECTOR_H_
 
 #include "include/cppgc/common.h"
+#include "src/heap/cppgc/heap-config.h"
 #include "src/heap/cppgc/marker.h"
-#include "src/heap/cppgc/sweeper.h"
 
 namespace cppgc {
 namespace internal {
@@ -20,8 +20,8 @@ class GarbageCollector {
     using CollectionType = Marker::MarkingConfig::CollectionType;
     using StackState = cppgc::Heap::StackState;
     using MarkingType = Marker::MarkingConfig::MarkingType;
-    using SweepingType = Sweeper::SweepingConfig::SweepingType;
-    using FreeMemoryHandling = Sweeper::SweepingConfig::FreeMemoryHandling;
+    using SweepingType = SweepingConfig::SweepingType;
+    using FreeMemoryHandling = SweepingConfig::FreeMemoryHandling;
     using IsForcedGC = Marker::MarkingConfig::IsForcedGC;
 
     static constexpr Config ConservativeAtomicConfig() {

src/heap/cppgc/heap-base.cc

@@ -259,9 +259,8 @@ void HeapBase::Terminate() {
     ExecutePreFinalizers();
     // TODO(chromium:1029379): Prefinalizers may black-allocate objects (under a
     // compile-time option). Run sweeping with forced finalization here.
-    sweeper().Start(
-        {Sweeper::SweepingConfig::SweepingType::kAtomic,
-         Sweeper::SweepingConfig::CompactableSpaceHandling::kSweep});
+    sweeper().Start({SweepingConfig::SweepingType::kAtomic,
+                     SweepingConfig::CompactableSpaceHandling::kSweep});
     in_atomic_pause_ = false;
 
     sweeper().NotifyDoneIfNeeded();

src/heap/cppgc/heap-config.h

+// 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_HEAP_CONFIG_H_
+#define V8_HEAP_CPPGC_HEAP_CONFIG_H_
+
+#include "include/cppgc/heap.h"
+
+namespace cppgc::internal {
+
+struct SweepingConfig {
+  using SweepingType = cppgc::Heap::SweepingType;
+  enum class CompactableSpaceHandling { kSweep, kIgnore };
+  enum class FreeMemoryHandling { kDoNotDiscard, kDiscardWherePossible };
+
+  SweepingType sweeping_type = SweepingType::kIncrementalAndConcurrent;
+  CompactableSpaceHandling compactable_space_handling =
+      CompactableSpaceHandling::kSweep;
+  FreeMemoryHandling free_memory_handling = FreeMemoryHandling::kDoNotDiscard;
+};
+
+}  // namespace cppgc::internal
+
+#endif  // V8_HEAP_CPPGC_HEAP_CONFIG_H_

src/heap/cppgc/heap.cc

@@ -203,9 +203,8 @@ void Heap::FinalizeGarbageCollection(Config::StackState stack_state) {
 #endif  // defined(CPPGC_YOUNG_GENERATION)
 
   subtle::NoGarbageCollectionScope no_gc(*this);
-  const Sweeper::SweepingConfig sweeping_config{
-      config_.sweeping_type,
-      Sweeper::SweepingConfig::CompactableSpaceHandling::kSweep,
+  const SweepingConfig sweeping_config{
+      config_.sweeping_type, SweepingConfig::CompactableSpaceHandling::kSweep,
       config_.free_memory_handling};
   sweeper_.Start(sweeping_config);
   in_atomic_pause_ = false;

src/heap/cppgc/stats-collector.h

@@ -54,8 +54,8 @@ namespace internal {
   V(MarkVisitRememberedSets)                \
   V(SweepFinishIfOutOfWork)                 \
   V(SweepInvokePreFinalizers)               \
-  V(SweepIdleStep)                          \
   V(SweepInTask)                            \
+  V(SweepInTaskForStatistics)               \
   V(SweepOnAllocation)                      \
   V(SweepFinalize)
 

src/heap/cppgc/sweeper.h

@@ -7,16 +7,13 @@
 
 #include <memory>
 
-#include "include/cppgc/heap.h"
 #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 {
-
-class Platform;
-
-namespace internal {
+namespace cppgc::internal {
 
 class HeapBase;
 class ConcurrentSweeperTest;
@@ -24,17 +21,6 @@ class NormalPageSpace;
 
 class V8_EXPORT_PRIVATE Sweeper final {
  public:
-  struct SweepingConfig {
-    using SweepingType = cppgc::Heap::SweepingType;
-    enum class CompactableSpaceHandling { kSweep, kIgnore };
-    enum class FreeMemoryHandling { kDoNotDiscard, kDiscardWherePossible };
-
-    SweepingType sweeping_type = SweepingType::kIncrementalAndConcurrent;
-    CompactableSpaceHandling compactable_space_handling =
-        CompactableSpaceHandling::kSweep;
-    FreeMemoryHandling free_memory_handling = FreeMemoryHandling::kDoNotDiscard;
-  };
-
   static constexpr bool CanDiscardMemory() {
     return CheckMemoryIsInaccessibleIsNoop();
   }
@@ -63,7 +49,8 @@ class V8_EXPORT_PRIVATE Sweeper final {
   bool IsSweepingInProgress() const;
 
   // Assist with sweeping. Returns true if sweeping is done.
-  bool PerformSweepOnMutatorThread(double deadline_in_seconds);
+  bool PerformSweepOnMutatorThread(v8::base::TimeDelta max_duration,
+                                   StatsCollector::ScopeId);
 
  private:
   void WaitForConcurrentSweepingForTesting();
@@ -76,7 +63,6 @@ class V8_EXPORT_PRIVATE Sweeper final {
   friend class ConcurrentSweeperTest;
 };
 
-}  // namespace internal
-}  // namespace cppgc
+}  // namespace cppgc::internal
 
 #endif  // V8_HEAP_CPPGC_SWEEPER_H_

test/unittests/heap/cppgc/compactor-unittest.cc

@@ -95,9 +95,9 @@ class CompactorTest : public testing::TestWithPlatform {
     heap()->GetMarkerRefForTesting().reset();
     FinishCompaction();
     // Sweeping also verifies the object start bitmap.
-    const Sweeper::SweepingConfig sweeping_config{
-        Sweeper::SweepingConfig::SweepingType::kAtomic,
-        Sweeper::SweepingConfig::CompactableSpaceHandling::kIgnore};
+    const SweepingConfig sweeping_config{
+        SweepingConfig::SweepingType::kAtomic,
+        SweepingConfig::CompactableSpaceHandling::kIgnore};
     heap()->sweeper().Start(sweeping_config);
   }
 

test/unittests/heap/cppgc/concurrent-sweeper-unittest.cc

@@ -78,9 +78,9 @@ class ConcurrentSweeperTest : public testing::TestWithHeap {
         GarbageCollector::Config::IsForcedGC::kNotForced);
     heap->stats_collector()->NotifyMarkingCompleted(0);
     Sweeper& sweeper = heap->sweeper();
-    const Sweeper::SweepingConfig sweeping_config{
-        Sweeper::SweepingConfig::SweepingType::kIncrementalAndConcurrent,
-        Sweeper::SweepingConfig::CompactableSpaceHandling::kSweep};
+    const SweepingConfig sweeping_config{
+        SweepingConfig::SweepingType::kIncrementalAndConcurrent,
+        SweepingConfig::CompactableSpaceHandling::kSweep};
     sweeper.Start(sweeping_config);
   }
 

test/unittests/heap/cppgc/sweeper-unittest.cc

@@ -52,9 +52,9 @@ class SweeperTest : public testing::TestWithHeap {
         GarbageCollector::Config::MarkingType::kAtomic,
         GarbageCollector::Config::IsForcedGC::kNotForced);
     heap->stats_collector()->NotifyMarkingCompleted(0);
-    const Sweeper::SweepingConfig sweeping_config{
-        Sweeper::SweepingConfig::SweepingType::kAtomic,
-        Sweeper::SweepingConfig::CompactableSpaceHandling::kSweep};
+    const SweepingConfig sweeping_config{
+        SweepingConfig::SweepingType::kAtomic,
+        SweepingConfig::CompactableSpaceHandling::kSweep};
     sweeper.Start(sweeping_config);
     sweeper.FinishIfRunning();
   }