Unreviewed, rolling out r235107.
[WebKit-https.git] / Source / JavaScriptCore / heap / GCActivityCallback.cpp
index f4edd6b..007fdd8 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2010-2017 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 #include "config.h"
 #include "GCActivityCallback.h"
 
-#include "Heap.h"
+#include "HeapInlines.h"
 #include "JSLock.h"
 #include "JSObject.h"
 #include "VM.h"
 
-#include <wtf/RetainPtr.h>
-#include <wtf/WTFThreadData.h>
-
-#if PLATFORM(EFL)
-#include <wtf/MainThread.h>
-#endif
-
 namespace JSC {
 
 bool GCActivityCallback::s_shouldCreateGCTimer = true;
 
-#if USE(CF) || PLATFORM(EFL)
-
-const double gcTimeSlicePerMB = 0.01; // Percentage of CPU time we will spend to reclaim 1 MB
-const double maxGCTimeSlice = 0.05; // The maximum amount of CPU time we want to use for opportunistic timer-triggered collections.
 const double timerSlop = 2.0; // Fudge factor to avoid performance cost of resetting timer.
 
-#if !PLATFORM(IOS)
-const double pagingTimeOut = 0.1; // Time in seconds to allow opportunistic timer to iterate over all blocks to see if the Heap is paged out.
-#endif
-
-#if !USE(CF)
-const double hour = 60 * 60;
-#endif
-
-#if USE(CF)
-DefaultGCActivityCallback::DefaultGCActivityCallback(Heap* heap)
-    : GCActivityCallback(heap->vm(), CFRunLoopGetCurrent())
-    , m_delay(s_decade)
-{
-}
-
-DefaultGCActivityCallback::DefaultGCActivityCallback(Heap* heap, CFRunLoopRef runLoop)
-    : GCActivityCallback(heap->vm(), runLoop)
-    , m_delay(s_decade)
-{
-}
-#elif PLATFORM(EFL)
-DefaultGCActivityCallback::DefaultGCActivityCallback(Heap* heap)
-    : GCActivityCallback(heap->vm(), WTF::isMainThread())
-    , m_delay(hour)
+GCActivityCallback::GCActivityCallback(Heap* heap)
+    : GCActivityCallback(heap->vm())
 {
 }
-#endif
 
-void DefaultGCActivityCallback::doWork()
+void GCActivityCallback::doWork()
 {
     Heap* heap = &m_vm->heap;
     if (!isEnabled())
@@ -87,110 +53,77 @@ void DefaultGCActivityCallback::doWork()
     
     JSLockHolder locker(m_vm);
     if (heap->isDeferred()) {
-        scheduleTimer(0);
+        scheduleTimer(0_s);
         return;
     }
 
-#if !PLATFORM(IOS)
-    double startTime = WTF::monotonicallyIncreasingTime();
-    if (heap->isPagedOut(startTime + pagingTimeOut)) {
-        heap->activityCallback()->cancel();
-        heap->increaseLastGCLength(pagingTimeOut);
-        return;
-    }
-#endif
-    heap->gcTimerDidFire();
-    heap->collect();
+    doCollection();
 }
-    
+
 #if USE(CF)
-void DefaultGCActivityCallback::scheduleTimer(double newDelay)
+void GCActivityCallback::scheduleTimer(Seconds newDelay)
 {
     if (newDelay * timerSlop > m_delay)
         return;
-    double delta = m_delay - newDelay;
+    Seconds delta = m_delay - newDelay;
     m_delay = newDelay;
-    CFRunLoopTimerSetNextFireDate(m_timer.get(), CFRunLoopTimerGetNextFireDate(m_timer.get()) - delta);
+    CFRunLoopTimerSetNextFireDate(m_timer.get(), CFRunLoopTimerGetNextFireDate(m_timer.get()) - delta.seconds());
 }
 
-void DefaultGCActivityCallback::cancelTimer()
+void GCActivityCallback::cancelTimer()
 {
     m_delay = s_decade;
-    CFRunLoopTimerSetNextFireDate(m_timer.get(), CFAbsoluteTimeGetCurrent() + s_decade);
+    CFRunLoopTimerSetNextFireDate(m_timer.get(), CFAbsoluteTimeGetCurrent() + s_decade.seconds());
 }
-#elif PLATFORM(EFL)
-void DefaultGCActivityCallback::scheduleTimer(double newDelay)
+
+MonotonicTime GCActivityCallback::nextFireTime()
+{
+    return MonotonicTime::now() + Seconds(CFRunLoopTimerGetNextFireDate(m_timer.get()) - CFAbsoluteTimeGetCurrent());
+}
+#else
+void GCActivityCallback::scheduleTimer(Seconds newDelay)
 {
     if (newDelay * timerSlop > m_delay)
         return;
-
-    stop();
+    Seconds delta = m_delay - newDelay;
     m_delay = newDelay;
-    
-    ASSERT(!m_timer);
-    m_timer = add(newDelay, this);
+
+    Seconds secondsUntilFire = m_timer.secondsUntilFire();
+    m_timer.startOneShot(std::max<Seconds>(secondsUntilFire - delta, 0_s));
 }
 
-void DefaultGCActivityCallback::cancelTimer()
+void GCActivityCallback::cancelTimer()
 {
-    m_delay = hour;
-    stop();
+    m_delay = s_decade;
+    m_timer.startOneShot(s_decade);
 }
-#endif
 
-void DefaultGCActivityCallback::didAllocate(size_t bytes)
+MonotonicTime GCActivityCallback::nextFireTime()
 {
-#if PLATFORM(EFL)
-    if (!isEnabled())
-        return;
-
-    ASSERT(WTF::isMainThread());
+    return MonotonicTime::now() + m_timer.secondsUntilFire();
+}
 #endif
 
+void GCActivityCallback::didAllocate(size_t bytes)
+{
     // The first byte allocated in an allocation cycle will report 0 bytes to didAllocate. 
     // We pretend it's one byte so that we don't ignore this allocation entirely.
     if (!bytes)
         bytes = 1;
-    Heap* heap = static_cast<Heap*>(&m_vm->heap);
-    double gcTimeSlice = std::min((static_cast<double>(bytes) / MB) * gcTimeSlicePerMB, maxGCTimeSlice);
-    double newDelay = heap->lastGCLength() / gcTimeSlice;
+    double bytesExpectedToReclaim = static_cast<double>(bytes) * deathRate();
+    Seconds newDelay = lastGCLength() / gcTimeSlice(bytesExpectedToReclaim);
     scheduleTimer(newDelay);
 }
 
-void DefaultGCActivityCallback::willCollect()
+void GCActivityCallback::willCollect()
 {
     cancelTimer();
 }
 
-void DefaultGCActivityCallback::cancel()
+void GCActivityCallback::cancel()
 {
     cancelTimer();
 }
 
-#else
-
-DefaultGCActivityCallback::DefaultGCActivityCallback(Heap* heap)
-    : GCActivityCallback(heap->vm())
-{
-}
-
-void DefaultGCActivityCallback::doWork()
-{
-}
-
-void DefaultGCActivityCallback::didAllocate(size_t)
-{
-}
-
-void DefaultGCActivityCallback::willCollect()
-{
-}
-
-void DefaultGCActivityCallback::cancel()
-{
-}
-
-#endif
-
 }