GCActivityCallback.cpp [plain text]
#include "config.h"
#include "GCActivityCallback.h"
#include "Heap.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>
#elif USE(GLIB)
#include <glib.h>
#endif
namespace JSC {
bool GCActivityCallback::s_shouldCreateGCTimer = true;
#if USE(CF) || USE(GLIB)
const double timerSlop = 2.0;
#if USE(CF)
GCActivityCallback::GCActivityCallback(Heap* heap)
: GCActivityCallback(heap->vm(), CFRunLoopGetCurrent())
{
}
GCActivityCallback::GCActivityCallback(Heap* heap, CFRunLoopRef runLoop)
: GCActivityCallback(heap->vm(), runLoop)
{
}
#elif PLATFORM(EFL)
GCActivityCallback::GCActivityCallback(Heap* heap)
: GCActivityCallback(heap->vm(), WTF::isMainThread())
{
}
#elif USE(GLIB)
GCActivityCallback::GCActivityCallback(Heap* heap)
: GCActivityCallback(heap->vm())
{
}
#endif
void GCActivityCallback::doWork()
{
Heap* heap = &m_vm->heap;
if (!isEnabled())
return;
JSLockHolder locker(m_vm);
if (heap->isDeferred()) {
scheduleTimer(0);
return;
}
doCollection();
}
#if USE(CF)
void GCActivityCallback::scheduleTimer(double newDelay)
{
if (newDelay * timerSlop > m_delay)
return;
double delta = m_delay - newDelay;
m_delay = newDelay;
m_nextFireTime = WTF::currentTime() + newDelay;
CFRunLoopTimerSetNextFireDate(m_timer.get(), CFRunLoopTimerGetNextFireDate(m_timer.get()) - delta);
}
void GCActivityCallback::cancelTimer()
{
m_delay = s_decade;
m_nextFireTime = 0;
CFRunLoopTimerSetNextFireDate(m_timer.get(), CFAbsoluteTimeGetCurrent() + s_decade);
}
#elif PLATFORM(EFL)
void GCActivityCallback::scheduleTimer(double newDelay)
{
if (newDelay * timerSlop > m_delay)
return;
stop();
m_delay = newDelay;
ASSERT(!m_timer);
m_timer = add(newDelay, this);
}
void GCActivityCallback::cancelTimer()
{
m_delay = s_hour;
stop();
}
#elif USE(GLIB)
void GCActivityCallback::scheduleTimer(double newDelay)
{
ASSERT(newDelay >= 0);
if (m_delay != -1 && newDelay * timerSlop > m_delay)
return;
m_delay = newDelay;
if (!m_delay) {
g_source_set_ready_time(m_timer.get(), 0);
return;
}
auto delayDuration = std::chrono::duration<double>(m_delay);
auto safeDelayDuration = std::chrono::microseconds::max();
if (delayDuration < safeDelayDuration)
safeDelayDuration = std::chrono::duration_cast<std::chrono::microseconds>(delayDuration);
gint64 currentTime = g_get_monotonic_time();
gint64 targetTime = currentTime + std::min<gint64>(G_MAXINT64 - currentTime, safeDelayDuration.count());
ASSERT(targetTime >= currentTime);
g_source_set_ready_time(m_timer.get(), targetTime);
}
void GCActivityCallback::cancelTimer()
{
m_delay = -1;
g_source_set_ready_time(m_timer.get(), -1);
}
#endif
void GCActivityCallback::didAllocate(size_t bytes)
{
#if PLATFORM(EFL)
if (!isEnabled())
return;
ASSERT(WTF::isMainThread());
#endif
if (!bytes)
bytes = 1;
double bytesExpectedToReclaim = static_cast<double>(bytes) * deathRate();
double newDelay = lastGCLength() / gcTimeSlice(bytesExpectedToReclaim);
scheduleTimer(newDelay);
}
void GCActivityCallback::willCollect()
{
cancelTimer();
}
void GCActivityCallback::cancel()
{
cancelTimer();
}
#else
GCActivityCallback::GCActivityCallback(Heap* heap)
: GCActivityCallback(heap->vm())
{
}
void GCActivityCallback::doWork()
{
}
void GCActivityCallback::didAllocate(size_t)
{
}
void GCActivityCallback::willCollect()
{
}
void GCActivityCallback::cancel()
{
}
#endif
}