Changeset 151149 in webkit

Timestamp:

Jun 3, 2013 8:20:32 PM (11 years ago)

Author:

commit-queue@webkit.org

Message:

[EFL] Implement GCActivityCallback
​https://bugs.webkit.org/show_bug.cgi?id=95923

Patch by Hojong Han <​hojong.han@samsung.com> on 2013-06-03
Reviewed by Geoffrey Garen.

Implements the activity triggered garbage collector.
Additional GCs can be triggered by platfrom timer.
It has sort of compaction effect not to make JSC heap grow fast
so that memory usage becomes lower than usual.

• PlatformEfl.cmake: Added.
• heap/HeapTimer.cpp:

(JSC):
(JSC::HeapTimer::HeapTimer):
(JSC::HeapTimer::~HeapTimer):
(JSC::HeapTimer::add):
(JSC::HeapTimer::stop):
(JSC::HeapTimer::timerEvent):

• heap/HeapTimer.h:

(HeapTimer):

• jsc.cpp:

(main):

• runtime/GCActivityCallback.cpp:

(JSC):
(JSC::DefaultGCActivityCallback::DefaultGCActivityCallback):
(JSC::DefaultGCActivityCallback::scheduleTimer):
(JSC::DefaultGCActivityCallback::cancelTimer):
(JSC::DefaultGCActivityCallback::didAllocate):

• runtime/GCActivityCallback.h:

(GCActivityCallback):
(JSC::GCActivityCallback::GCActivityCallback):
(DefaultGCActivityCallback):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• PlatformEfl.cmake (added)
• heap/HeapTimer.cpp (modified) (2 diffs)
• heap/HeapTimer.h (modified) (2 diffs)
• jsc.cpp (modified) (3 diffs)
• runtime/GCActivityCallback.cpp (modified) (3 diffs)
• runtime/GCActivityCallback.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2013-06-03  Hojong Han  <hojong.han@samsung.com>
+
+        [EFL] Implement GCActivityCallback
+        https://bugs.webkit.org/show_bug.cgi?id=95923
+
+        Reviewed by Geoffrey Garen.
+
+        Implements the activity triggered garbage collector.
+        Additional GCs can be triggered by platfrom timer.
+        It has sort of compaction effect not to make JSC heap grow fast
+        so that memory usage becomes lower than usual.
+
+        * PlatformEfl.cmake: Added.
+        * heap/HeapTimer.cpp:
+        (JSC):
+        (JSC::HeapTimer::HeapTimer):
+        (JSC::HeapTimer::~HeapTimer):
+        (JSC::HeapTimer::add):
+        (JSC::HeapTimer::stop):
+        (JSC::HeapTimer::timerEvent):
+        * heap/HeapTimer.h:
+        (HeapTimer):
+        * jsc.cpp:
+        (main):
+        * runtime/GCActivityCallback.cpp:
+        (JSC):
+        (JSC::DefaultGCActivityCallback::DefaultGCActivityCallback):
+        (JSC::DefaultGCActivityCallback::scheduleTimer):
+        (JSC::DefaultGCActivityCallback::cancelTimer):
+        (JSC::DefaultGCActivityCallback::didAllocate):
+        * runtime/GCActivityCallback.h:
+        (GCActivityCallback):
+        (JSC::GCActivityCallback::GCActivityCallback):
+        (DefaultGCActivityCallback):
+
 2013-06-03  Roger Fong  <roger_fong@apple.com>
 

trunk/Source/JavaScriptCore/heap/HeapTimer.cpp

@@ -39 +39 @@
 #include <QThread>
 #include <QTimerEvent>
+#elif PLATFORM(EFL)
+#include <Ecore.h>
 #endif
 
@@ -166 +168 @@
 }
 
+#elif PLATFORM(EFL)
+
+HeapTimer::HeapTimer(VM* vm)
+    : m_vm(vm)
+    , m_timer(0)
+{
+}
+
+HeapTimer::~HeapTimer()
+{
+    stop();
+}
+
+Ecore_Timer* HeapTimer::add(double delay, void* agent)
+{
+    return ecore_timer_add(delay, reinterpret_cast<Ecore_Task_Cb>(timerEvent), agent);
+}
+    
+void HeapTimer::stop()
+{
+    if (!m_timer)
+        return;
+
+    ecore_timer_del(m_timer);
+    m_timer = 0;
+}
+
+bool HeapTimer::timerEvent(void* info)
+{
+    HeapTimer* agent = static_cast<HeapTimer*>(info);
+    
+    APIEntryShim shim(agent->m_vm);
+    agent->doWork();
+    agent->m_timer = 0;
+    
+    return ECORE_CALLBACK_CANCEL;
+}
+
 #else
 HeapTimer::HeapTimer(VM* vm)

trunk/Source/JavaScriptCore/heap/HeapTimer.h

@@ -39 +39 @@
 #include <QObject>
 #include <QThread>
+#elif PLATFORM(EFL)
+typedef struct _Ecore_Timer Ecore_Timer;
 #endif
 
@@ -82 +84 @@
     QThread* m_newThread;
     QMutex m_mutex;
+#elif PLATFORM(EFL)
+    static bool timerEvent(void*);
+    Ecore_Timer* add(double delay, void* agent);
+    void stop();
+    Ecore_Timer* m_timer;
 #endif
     

trunk/Source/JavaScriptCore/jsc.cpp

@@ -91 +91 @@
 #endif
 
+#if PLATFORM(EFL)
+#include <Ecore.h>
+#endif
+
 using namespace JSC;
 using namespace WTF;
@@ -538 +542 @@
 #endif
 
+#if PLATFORM(EFL)
+    ecore_init();
+#endif
+
     // Initialize JSC before getting VM.
 #if ENABLE(SAMPLING_REGIONS)
@@ -552 +560 @@
     if (Options::logHeapStatisticsAtExit())
         HeapStatistics::reportSuccess();
+
+#if PLATFORM(EFL)
+    ecore_shutdown();
+#endif
+
     return res;
 }

trunk/Source/JavaScriptCore/runtime/GCActivityCallback.cpp

@@ -39 +39 @@
 #include <wtf/WTFThreadData.h>
 
+#if PLATFORM(EFL)
+#include <wtf/MainThread.h>
+#endif
+
 namespace JSC {
 
-#if USE(CF) || PLATFORM(QT)
+#if USE(CF) || PLATFORM(QT) || PLATFORM(EFL)
 
 const double gcTimeSlicePerMB = 0.01; // Percentage of CPU time we will spend to reclaim 1 MB
@@ -64 +68 @@
 DefaultGCActivityCallback::DefaultGCActivityCallback(Heap* heap)
     : GCActivityCallback(heap->vm())
+    , m_delay(hour)
+{
+}
+#elif PLATFORM(EFL)
+DefaultGCActivityCallback::DefaultGCActivityCallback(Heap* heap)
+    : GCActivityCallback(heap->vm(), WTF::isMainThread())
     , m_delay(hour)
 {
@@ -117 +127 @@
     m_timer.stop();
 }
+#elif PLATFORM(EFL)
+void DefaultGCActivityCallback::scheduleTimer(double newDelay)
+{
+    if (newDelay * timerSlop > m_delay)
+        return;
+
+    stop();
+    m_delay = newDelay;
+    
+    ASSERT(!m_timer);
+    m_timer = add(newDelay, this);
+}
+
+void DefaultGCActivityCallback::cancelTimer()
+{
+    m_delay = hour;
+    stop();
+}
 #endif
 
 void DefaultGCActivityCallback::didAllocate(size_t bytes)
 {
+#if PLATFORM(EFL)
+    if (!isEnabled())
+        return;
+
+    ASSERT(WTF::isMainThread());
+#endif
+
     // 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.

trunk/Source/JavaScriptCore/runtime/GCActivityCallback.h

@@ -58 +58 @@
     {
     }
+#elif PLATFORM(EFL)
+    GCActivityCallback(VM* vm, bool flag)
+        : HeapTimer(vm)
+        , m_enabled(flag)
+    {
+    }
 #else
     GCActivityCallback(VM* vm)
@@ -85 +91 @@
     DefaultGCActivityCallback(Heap*, CFRunLoopRef);
 #endif
-#if USE(CF) || PLATFORM(QT)
+#if USE(CF) || PLATFORM(QT) || PLATFORM(EFL)
 protected:
     void cancelTimer();