[heap, api] Add a memory measurement mode that doesn't force GC

By default the v8::MeasureMemory API forces GC after some timeout.
There are use cases that require low overhead measurements without
forcing GC at all.

Change-Id: I7d57c552d78d86800c4f37acb680c70c6422477f
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2257856Reviewed-by: Dominik Inführ <dinfuehr@chromium.org>
Commit-Queue: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#68718}

include/v8.h

@@ -8086,10 +8086,11 @@ enum class MeasureMemoryMode { kSummary, kDetailed };
 /**
  * Controls how promptly a memory measurement request is executed.
  * By default the measurement is folded with the next scheduled GC which may
- * happen after a while. The kEager starts increment GC right away and
- * is useful for testing.
+ * happen after a while and is forced after some timeout.
+ * The kEager mode starts incremental GC right away and is useful for testing.
+ * The kLazy mode does not force GC.
  */
-enum class MeasureMemoryExecution { kDefault, kEager };
+enum class MeasureMemoryExecution { kDefault, kEager, kLazy };
 
 /**
  * The delegate is used in Isolate::MeasureMemory API.

src/heap/memory-measurement.cc

@@ -243,12 +243,16 @@ void MemoryMeasurement::ScheduleReportingTask() {
 }
 
 bool MemoryMeasurement::IsGCTaskPending(v8::MeasureMemoryExecution execution) {
+  DCHECK(execution == v8::MeasureMemoryExecution::kEager ||
+         execution == v8::MeasureMemoryExecution::kDefault);
   return execution == v8::MeasureMemoryExecution::kEager
              ? eager_gc_task_pending_
              : delayed_gc_task_pending_;
 }
 
 void MemoryMeasurement::SetGCTaskPending(v8::MeasureMemoryExecution execution) {
+  DCHECK(execution == v8::MeasureMemoryExecution::kEager ||
+         execution == v8::MeasureMemoryExecution::kDefault);
   if (execution == v8::MeasureMemoryExecution::kEager) {
     eager_gc_task_pending_ = true;
   } else {
@@ -257,6 +261,8 @@ void MemoryMeasurement::SetGCTaskPending(v8::MeasureMemoryExecution execution) {
 }
 
 void MemoryMeasurement::SetGCTaskDone(v8::MeasureMemoryExecution execution) {
+  DCHECK(execution == v8::MeasureMemoryExecution::kEager ||
+         execution == v8::MeasureMemoryExecution::kDefault);
   if (execution == v8::MeasureMemoryExecution::kEager) {
     eager_gc_task_pending_ = false;
   } else {
@@ -265,6 +271,7 @@ void MemoryMeasurement::SetGCTaskDone(v8::MeasureMemoryExecution execution) {
 }
 
 void MemoryMeasurement::ScheduleGCTask(v8::MeasureMemoryExecution execution) {
+  if (execution == v8::MeasureMemoryExecution::kLazy) return;
   if (IsGCTaskPending(execution)) return;
   SetGCTaskPending(execution);
   auto taskrunner = V8::GetCurrentPlatform()->GetForegroundTaskRunner(

test/cctest/heap/test-memory-measurement.cc

@@ -152,6 +152,8 @@ class MockPlatform : public TestPlatform {
 
   void PerformTask() { mock_task_runner_->PerformTask(); }
 
+  bool TaskPosted() { return mock_task_runner_->TaskPosted(); }
+
  private:
   class MockTaskRunner : public v8::TaskRunner {
    public:
@@ -176,6 +178,8 @@ class MockPlatform : public TestPlatform {
       task->Run();
     }
 
+    bool TaskPosted() { return task_.get(); }
+
    private:
     double delay_ = -1;
     std::unique_ptr<Task> task_;
@@ -212,6 +216,15 @@ TEST(RandomizedTimeout) {
   CHECK_LT(delays[0], delays.back());
 }
 
+TEST(LazyMemoryMeasurement) {
+  CcTest::InitializeVM();
+  MockPlatform platform;
+  CcTest::isolate()->MeasureMemory(
+      std::make_unique<MockMeasureMemoryDelegate>(),
+      v8::MeasureMemoryExecution::kLazy);
+  CHECK(!platform.TaskPosted());
+}
+
 }  // namespace heap
 }  // namespace internal
 }  // namespace v8