From 1bf1084f2b10c3b47fd1a588d85d21ed0eb41d0c Mon Sep 17 00:00:00 2001 From: Lorry Tar Creator Date: Tue, 27 Jun 2017 06:07:23 +0000 Subject: webkitgtk-2.16.5 --- Source/JavaScriptCore/heap/HeapTimer.cpp | 160 ++++++++++++++++++------------- 1 file changed, 92 insertions(+), 68 deletions(-) (limited to 'Source/JavaScriptCore/heap/HeapTimer.cpp') diff --git a/Source/JavaScriptCore/heap/HeapTimer.cpp b/Source/JavaScriptCore/heap/HeapTimer.cpp index 1331b0ac0..9c8b30252 100644 --- a/Source/JavaScriptCore/heap/HeapTimer.cpp +++ b/Source/JavaScriptCore/heap/HeapTimer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2012 Apple Inc. All rights reserved. + * Copyright (C) 2012, 2016 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -26,116 +26,137 @@ #include "config.h" #include "HeapTimer.h" -#include "APIShims.h" +#include "GCActivityCallback.h" +#include "IncrementalSweeper.h" #include "JSObject.h" #include "JSString.h" - +#include "JSCInlines.h" #include #include -#if PLATFORM(EFL) -#include +#if USE(GLIB) +#include #endif namespace JSC { +void HeapTimer::timerDidFire() +{ + m_apiLock->lock(); + + RefPtr vm = m_apiLock->vm(); + if (!vm) { + // The VM has been destroyed, so we should just give up. + m_apiLock->unlock(); + return; + } + + { + JSLockHolder locker(vm.get()); + doWork(); + } + + m_apiLock->unlock(); +} + #if USE(CF) const CFTimeInterval HeapTimer::s_decade = 60 * 60 * 24 * 365 * 10; -static const void* retainAPILock(const void* info) +HeapTimer::HeapTimer(VM* vm) + : m_vm(vm) + , m_apiLock(&vm->apiLock()) { - static_cast(const_cast(info))->ref(); - return info; + setRunLoop(vm->heap.runLoop()); } -static void releaseAPILock(const void* info) +void HeapTimer::setRunLoop(CFRunLoopRef runLoop) { - static_cast(const_cast(info))->deref(); + if (m_runLoop) { + CFRunLoopRemoveTimer(m_runLoop.get(), m_timer.get(), kCFRunLoopCommonModes); + CFRunLoopTimerInvalidate(m_timer.get()); + m_runLoop.clear(); + m_timer.clear(); + } + + if (runLoop) { + m_runLoop = runLoop; + memset(&m_context, 0, sizeof(CFRunLoopTimerContext)); + m_context.info = this; + m_timer = adoptCF(CFRunLoopTimerCreate(kCFAllocatorDefault, s_decade, s_decade, 0, 0, HeapTimer::timerDidFireCallback, &m_context)); + CFRunLoopAddTimer(m_runLoop.get(), m_timer.get(), kCFRunLoopCommonModes); + } } -HeapTimer::HeapTimer(VM* vm, CFRunLoopRef runLoop) - : m_vm(vm) - , m_runLoop(runLoop) +HeapTimer::~HeapTimer() { - memset(&m_context, 0, sizeof(CFRunLoopTimerContext)); - m_context.info = &vm->apiLock(); - m_context.retain = retainAPILock; - m_context.release = releaseAPILock; - m_timer = adoptCF(CFRunLoopTimerCreate(0, s_decade, s_decade, 0, 0, HeapTimer::timerDidFire, &m_context)); - CFRunLoopAddTimer(m_runLoop.get(), m_timer.get(), kCFRunLoopCommonModes); + setRunLoop(0); } -HeapTimer::~HeapTimer() +void HeapTimer::timerDidFireCallback(CFRunLoopTimerRef, void* contextPtr) { - CFRunLoopRemoveTimer(m_runLoop.get(), m_timer.get(), kCFRunLoopCommonModes); - CFRunLoopTimerInvalidate(m_timer.get()); + static_cast(contextPtr)->timerDidFire(); } -void HeapTimer::timerDidFire(CFRunLoopTimerRef timer, void* context) +void HeapTimer::scheduleTimer(double intervalInSeconds) { - JSLock* apiLock = static_cast(context); - apiLock->lock(); - - VM* vm = apiLock->vm(); - // The VM has been destroyed, so we should just give up. - if (!vm) { - apiLock->unlock(); - return; - } + CFRunLoopTimerSetNextFireDate(m_timer.get(), CFAbsoluteTimeGetCurrent() + intervalInSeconds); + m_isScheduled = true; +} - HeapTimer* heapTimer = 0; - if (vm->heap.activityCallback() && vm->heap.activityCallback()->m_timer.get() == timer) - heapTimer = vm->heap.activityCallback(); - else if (vm->heap.sweeper()->m_timer.get() == timer) - heapTimer = vm->heap.sweeper(); - else - RELEASE_ASSERT_NOT_REACHED(); +void HeapTimer::cancelTimer() +{ + CFRunLoopTimerSetNextFireDate(m_timer.get(), CFAbsoluteTimeGetCurrent() + s_decade); + m_isScheduled = false; +} - { - APIEntryShim shim(vm); - heapTimer->doWork(); - } +#elif USE(GLIB) - apiLock->unlock(); -} +const long HeapTimer::s_decade = 60 * 60 * 24 * 365 * 10; -#elif PLATFORM(EFL) +static GSourceFuncs heapTimerSourceFunctions = { + nullptr, // prepare + nullptr, // check + // dispatch + [](GSource*, GSourceFunc callback, gpointer userData) -> gboolean + { + return callback(userData); + }, + nullptr, // finalize + nullptr, // closure_callback + nullptr, // closure_marshall +}; HeapTimer::HeapTimer(VM* vm) : m_vm(vm) - , m_timer(0) + , m_apiLock(&vm->apiLock()) + , m_timer(adoptGRef(g_source_new(&heapTimerSourceFunctions, sizeof(GSource)))) { + g_source_set_name(m_timer.get(), "[JavaScriptCore] HeapTimer"); + g_source_set_callback(m_timer.get(), [](gpointer userData) -> gboolean { + auto& heapTimer = *static_cast(userData); + g_source_set_ready_time(heapTimer.m_timer.get(), g_get_monotonic_time() + HeapTimer::s_decade * G_USEC_PER_SEC); + heapTimer.timerDidFire(); + return G_SOURCE_CONTINUE; + }, this, nullptr); + g_source_attach(m_timer.get(), g_main_context_get_thread_default()); } HeapTimer::~HeapTimer() { - stop(); + g_source_destroy(m_timer.get()); } -Ecore_Timer* HeapTimer::add(double delay, void* agent) +void HeapTimer::scheduleTimer(double intervalInSeconds) { - return ecore_timer_add(delay, reinterpret_cast(timerEvent), agent); -} - -void HeapTimer::stop() -{ - if (!m_timer) - return; - - ecore_timer_del(m_timer); - m_timer = 0; + g_source_set_ready_time(m_timer.get(), g_get_monotonic_time() + intervalInSeconds * G_USEC_PER_SEC); + m_isScheduled = true; } -bool HeapTimer::timerEvent(void* info) +void HeapTimer::cancelTimer() { - HeapTimer* agent = static_cast(info); - - APIEntryShim shim(agent->m_vm); - agent->doWork(); - agent->m_timer = 0; - - return ECORE_CALLBACK_CANCEL; + g_source_set_ready_time(m_timer.get(), g_get_monotonic_time() + s_decade * G_USEC_PER_SEC); + m_isScheduled = false; } #else HeapTimer::HeapTimer(VM* vm) @@ -147,10 +168,13 @@ HeapTimer::~HeapTimer() { } -void HeapTimer::invalidate() +void HeapTimer::scheduleTimer(double) { } +void HeapTimer::cancelTimer() +{ +} #endif -- cgit v1.2.1