Line data    Source code

       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             : #ifndef V8_HEAP_SCAVENGE_JOB_H_
       6             : #define V8_HEAP_SCAVENGE_JOB_H_
       7             : 
       8             : #include "src/cancelable-task.h"
       9             : #include "src/globals.h"
      10             : #include "src/heap/gc-tracer.h"
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : 
      15             : class Heap;
      16             : class Isolate;
      17             : 
      18             : 
      19             : // This class posts idle tasks and performs scavenges in the idle tasks.
      20             : class V8_EXPORT_PRIVATE ScavengeJob {
      21             :  public:
      22       18246 :   class IdleTask : public CancelableIdleTask {
      23             :    public:
      24             :     explicit IdleTask(Isolate* isolate, ScavengeJob* job)
      25        9123 :         : CancelableIdleTask(isolate), job_(job) {}
      26             :     // CancelableIdleTask overrides.
      27             :     void RunInternal(double deadline_in_seconds) override;
      28             : 
      29             :    private:
      30             :     ScavengeJob* job_;
      31             :   };
      32             : 
      33             :   ScavengeJob()
      34             :       : idle_task_pending_(false),
      35             :         idle_task_rescheduled_(false),
      36       60782 :         bytes_allocated_since_the_last_task_(0) {}
      37             : 
      38             :   // Posts an idle task if the cumulative bytes allocated since the last
      39             :   // idle task exceed kBytesAllocatedBeforeNextIdleTask.
      40             :   void ScheduleIdleTaskIfNeeded(Heap* heap, int bytes_allocated);
      41             : 
      42             :   // Posts an idle task ignoring the bytes allocated, but makes sure
      43             :   // that the new idle task cannot reschedule again.
      44             :   // This prevents infinite rescheduling.
      45             :   void RescheduleIdleTask(Heap* heap);
      46             : 
      47             :   bool IdleTaskPending() { return idle_task_pending_; }
      48        9082 :   void NotifyIdleTask() { idle_task_pending_ = false; }
      49             :   bool IdleTaskRescheduled() { return idle_task_rescheduled_; }
      50             : 
      51             :   static bool ReachedIdleAllocationLimit(double scavenge_speed_in_bytes_per_ms,
      52             :                                          size_t new_space_size,
      53             :                                          size_t new_space_capacity);
      54             : 
      55             :   static bool EnoughIdleTimeForScavenge(double idle_time_ms,
      56             :                                         double scavenge_speed_in_bytes_per_ms,
      57             :                                         size_t new_space_size);
      58             : 
      59             :   // If we haven't recorded any scavenger events yet, we use a conservative
      60             :   // lower bound for the scavenger speed.
      61             :   static const int kInitialScavengeSpeedInBytesPerMs = 256 * KB;
      62             :   // Estimate of the average idle time that an idle task gets.
      63             :   static const int kAverageIdleTimeMs = 5;
      64             :   // The number of bytes to be allocated in new space before the next idle
      65             :   // task is posted.
      66             :   static const size_t kBytesAllocatedBeforeNextIdleTask = 512 * KB;
      67             :   // The minimum size of allocated new space objects to trigger a scavenge.
      68             :   static const size_t kMinAllocationLimit = 512 * KB;
      69             :   // The allocation limit cannot exceed this fraction of the new space capacity.
      70             :   static const double kMaxAllocationLimitAsFractionOfNewSpace;
      71             : 
      72             :  private:
      73             :   void ScheduleIdleTask(Heap* heap);
      74             :   bool idle_task_pending_;
      75             :   bool idle_task_rescheduled_;
      76             :   int bytes_allocated_since_the_last_task_;
      77             : };
      78             : }  // namespace internal
      79             : }  // namespace v8
      80             : 
      81             : #endif  // V8_HEAP_SCAVENGE_JOB_H_