1// Copyright 2015 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "src/heap/scavenge-job.h"
6
7#include "src/base/platform/time.h"
8#include "src/heap/heap-inl.h"
9#include "src/heap/heap.h"
10#include "src/isolate.h"
11#include "src/v8.h"
12
13namespace v8 {
14namespace internal {
15
16
17const double ScavengeJob::kMaxAllocationLimitAsFractionOfNewSpace = 0.8;
18
19void ScavengeJob::IdleTask::RunInternal(double deadline_in_seconds) {
20  Heap* heap = isolate()->heap();
21  double deadline_in_ms =
22      deadline_in_seconds *
23      static_cast<double>(base::Time::kMillisecondsPerSecond);
24  double start_ms = heap->MonotonicallyIncreasingTimeInMs();
25  double idle_time_in_ms = deadline_in_ms - start_ms;
26  double scavenge_speed_in_bytes_per_ms =
27      heap->tracer()->ScavengeSpeedInBytesPerMillisecond();
28  size_t new_space_size = heap->new_space()->Size();
29  size_t new_space_capacity = heap->new_space()->Capacity();
30
31  job_->NotifyIdleTask();
32
33  if (ReachedIdleAllocationLimit(scavenge_speed_in_bytes_per_ms, new_space_size,
34                                 new_space_capacity)) {
35    if (EnoughIdleTimeForScavenge(
36            idle_time_in_ms, scavenge_speed_in_bytes_per_ms, new_space_size)) {
37      heap->CollectGarbage(NEW_SPACE, GarbageCollectionReason::kIdleTask);
38    } else {
39      // Immediately request another idle task that can get larger idle time.
40      job_->RescheduleIdleTask(heap);
41    }
42  }
43}
44
45bool ScavengeJob::ReachedIdleAllocationLimit(
46    double scavenge_speed_in_bytes_per_ms, size_t new_space_size,
47    size_t new_space_capacity) {
48  if (scavenge_speed_in_bytes_per_ms == 0) {
49    scavenge_speed_in_bytes_per_ms = kInitialScavengeSpeedInBytesPerMs;
50  }
51
52  // Set the allocation limit to the number of bytes we can scavenge in an
53  // average idle task.
54  double allocation_limit = kAverageIdleTimeMs * scavenge_speed_in_bytes_per_ms;
55
56  // Keep the limit smaller than the new space capacity.
57  allocation_limit =
58      Min<double>(allocation_limit,
59                  new_space_capacity * kMaxAllocationLimitAsFractionOfNewSpace);
60  // Adjust the limit to take into account bytes that will be allocated until
61  // the next check and keep the limit large enough to avoid scavenges in tiny
62  // new space.
63  allocation_limit =
64      Max<double>(allocation_limit - kBytesAllocatedBeforeNextIdleTask,
65                  kMinAllocationLimit);
66
67  return allocation_limit <= new_space_size;
68}
69
70bool ScavengeJob::EnoughIdleTimeForScavenge(
71    double idle_time_in_ms, double scavenge_speed_in_bytes_per_ms,
72    size_t new_space_size) {
73  if (scavenge_speed_in_bytes_per_ms == 0) {
74    scavenge_speed_in_bytes_per_ms = kInitialScavengeSpeedInBytesPerMs;
75  }
76  return new_space_size <= idle_time_in_ms * scavenge_speed_in_bytes_per_ms;
77}
78
79
80void ScavengeJob::RescheduleIdleTask(Heap* heap) {
81  // Make sure that we don't reschedule more than one time.
82  // Otherwise, we might spam the scheduler with idle tasks.
83  if (!idle_task_rescheduled_) {
84    ScheduleIdleTask(heap);
85    idle_task_rescheduled_ = true;
86  }
87}
88
89
90void ScavengeJob::ScheduleIdleTaskIfNeeded(Heap* heap, int bytes_allocated) {
91  bytes_allocated_since_the_last_task_ += bytes_allocated;
92  if (bytes_allocated_since_the_last_task_ >=
93      static_cast<int>(kBytesAllocatedBeforeNextIdleTask)) {
94    ScheduleIdleTask(heap);
95    bytes_allocated_since_the_last_task_ = 0;
96    idle_task_rescheduled_ = false;
97  }
98}
99
100
101void ScavengeJob::ScheduleIdleTask(Heap* heap) {
102  if (!idle_task_pending_) {
103    v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(heap->isolate());
104    if (V8::GetCurrentPlatform()->IdleTasksEnabled(isolate)) {
105      idle_task_pending_ = true;
106      auto task = new IdleTask(heap->isolate(), this);
107      V8::GetCurrentPlatform()->CallIdleOnForegroundThread(isolate, task);
108    }
109  }
110}
111}  // namespace internal
112}  // namespace v8
113