Add the rate of js invocations from the api as a signal of idleness

src/heap/memory-reducer.h

 // Copyright 2015 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_memory_reducer_H
 #define V8_HEAP_memory_reducer_H
 
 #include "include/v8-platform.h"
 #include "src/base/macros.h"
 #include "src/cancelable-task.h"
@@ skipping 89 matching lines @@
 
   struct Event {
     EventType type;
     double time_ms;
     bool next_gc_likely_to_collect_more;
     bool should_start_incremental_gc;
     bool can_start_incremental_gc;
   };
 
   explicit MemoryReducer(Heap* heap)
-      : heap_(heap), state_(kDone, 0, 0.0, 0.0) {}
+      : heap_(heap),
+        state_(kDone, 0, 0.0, 0.0),
+        js_calls_counter_(0),

[Hannes Payer (out of office), 2015/10/28 14:58:08]

I am wondering if the js call rate live on the isolate? WDYT? The memory reducer
is also asking the heap about the allocation rate. Logically it sounds like a
better home for this counter.
Hmm, but the isolate is not computing it, the memory reducer is taking care of
that.

[ulan, 2015/10/29 12:39:25]

I think this is very specific to memory reducer so as much as possible should
live here.

I would move the remaining counter from isolate to memory reducer, but that is
perf sensitive.

+        js_calls_sample_time_ms_(0.0) {}
   // Callbacks.
   void NotifyMarkCompact(const Event& event);
   void NotifyContextDisposed(const Event& event);
   void NotifyBackgroundIdleNotification(const Event& event);
   // The step function that computes the next state from the current state and
   // the incoming event.
   static State Step(const State& state, const Event& event);
   // Posts a timer task that will call NotifyTimer after the given delay.
-  void ScheduleTimer(double delay_ms);
+  void ScheduleTimer(double time_ms, double delay_ms);
   void TearDown();
   static const int kLongDelayMs;
   static const int kShortDelayMs;
   static const int kWatchdogDelayMs;
   static const int kMaxNumberOfGCs;
 
   Heap* heap() { return heap_; }
 
   bool ShouldGrowHeapSlowly() {
     return state_.action == kDone && state_.started_gcs > 0;
   }
 
  private:
   class TimerTask : public v8::internal::CancelableTask {
    public:
     explicit TimerTask(MemoryReducer* memory_reducer);
 
    private:
     // v8::internal::CancelableTask overrides.
     void RunInternal() override;
     MemoryReducer* memory_reducer_;
     DISALLOW_COPY_AND_ASSIGN(TimerTask);
   };
 
   void NotifyTimer(const Event& event);
 
   static bool WatchdogGC(const State& state, const Event& event);
 
+  // Returns the rate of JS calls initiated from the API.
+  double SampleAndGetJsCallsPerMs(double time_ms);
+
   Heap* heap_;
   State state_;
+  unsigned int js_calls_counter_;
+  double js_calls_sample_time_ms_;
+
+  // Used in cctest.
+  friend class HeapTester;
   DISALLOW_COPY_AND_ASSIGN(MemoryReducer);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_memory_reducer_H