Ticket #2808: GC_Scheduling_PATCH2_WIP_v1.diff

source/scriptinterface/ScriptInterface.cpp

@@ -139 +139 @@
         m_rooter(NULL),
         m_LastGCBytes(0),
         m_LastGCCheck(0.0f),
-        m_HeapGrowthBytesGCTrigger(heapGrowthBytesGCTrigger)
+        m_HeapGrowthBytesGCTrigger(heapGrowthBytesGCTrigger),
+        m_RuntimeSize(runtimeSize)
     {
         m_rt = JS_NewRuntime(runtimeSize, JS_USE_HELPER_THREADS);
 
@@ -161 +162 @@
         
         JS::SetGCSliceCallback(m_rt, GCSliceCallbackHook);
         
-        JS_SetGCParameter(m_rt, JSGC_MAX_MALLOC_BYTES, 384 * 1024 * 1024);
-        JS_SetGCParameter(m_rt, JSGC_MAX_BYTES, 384 * 1024 * 1024);
+        JS_SetGCParameter(m_rt, JSGC_MAX_MALLOC_BYTES, m_RuntimeSize);
+        JS_SetGCParameter(m_rt, JSGC_MAX_BYTES, m_RuntimeSize);
         JS_SetGCParameter(m_rt, JSGC_MODE, JSGC_MODE_INCREMENTAL);
-        //JS_SetGCParameter(m_rt, JSGC_SLICE_TIME_BUDGET, 5);
-        JS_SetGCParameter(m_rt, JSGC_ALLOCATION_THRESHOLD, 256);
+        JS_SetGCParameter(m_rt, JSGC_ALLOCATION_THRESHOLD, m_RuntimeSize / 1024 / 1024);
         
         // The whole heap-growth mechanism seems to work only for non-incremental GCs.
         // We disable it to make it more clear if full GCs happen triggered by this JSAPI internal mechanism.
@@ -177 +177 @@
         ENSURE(m_dummyContext);
     }
     
+    #define GC_DEBUG_PRINT 1
     void MaybeIncrementalGC(double delay)
     {
         PROFILE2("MaybeIncrementalGC");
@@ -201 +202 @@
             m_LastGCCheck = timer_Time();
             
             int gcBytes = JS_GetGCParameter(m_rt, JSGC_BYTES);
-            //std::cout << "gcBytes: " << std::endl; // debugging
+            
+#if GC_DEBUG_PRINT
+                std::cout << "gcBytes: " << gcBytes / 1024 << " KB" << std::endl;
+#endif
+            
             if (m_LastGCBytes > gcBytes || m_LastGCBytes == 0)
             {
-                //printf("Setting m_LastGCBytes: %d \n", gcBytes); // debugging
+#if GC_DEBUG_PRINT
+                printf("Setting m_LastGCBytes: %d KB \n", gcBytes / 1024);
+#endif
                 m_LastGCBytes = gcBytes;
             }
-            
+
             // Run an additional incremental GC slice if the currently running incremental GC isn't over yet 
             // ... or
             // start a new incremental GC if the JS heap size has grown enough for a GC to make sense
             if (JS::IsIncrementalGCInProgress(m_rt) || (gcBytes - m_LastGCBytes > m_HeapGrowthBytesGCTrigger))
-            {
-                // Use for debugging
-                /*if (JS::IsIncrementalGCInProgress(m_rt))
-                    printf("Running incremental GC because an incremental cycle is in progress. \n");
+            {               
+#if GC_DEBUG_PRINT
+                if (JS::IsIncrementalGCInProgress(m_rt))
+                    printf("An incremental GC cycle is in progress. \n");
                 else
-                    printf("Running incremental GC because JSGC_BYTES - m_LastGCBytes > m_HeapGrowthBytesGCTrigger "
-                        " ---- JSGC_BYTES: %d    m_LastGCBytes: %d    m_HeapGrowthBytesGCTrigger: %d ", 
-                        gcBytes, 
-                        m_LastGCBytes, 
-                        m_HeapGrowthBytesGCTrigger);
-                }*/
-                PrepareContextsForIncrementalGC();
-                JS::IncrementalGC(m_rt, JS::gcreason::REFRESH_FRAME, GCSliceTimeBudget);
+                    printf("GC needed because JSGC_BYTES - m_LastGCBytes > m_HeapGrowthBytesGCTrigger \n"
+                        "    JSGC_BYTES: %d KB \n    m_LastGCBytes: %d KB \n    m_HeapGrowthBytesGCTrigger: %d KB \n", 
+                        gcBytes / 1024, 
+                        m_LastGCBytes / 1024, 
+                        m_HeapGrowthBytesGCTrigger / 1024);
+#endif
+                
+                // A hack to make sure we never exceed the runtime size because we can't collect the memory
+                // fast enough.
+                if(gcBytes > m_RuntimeSize / 2)
+                {
+                    if (JS::IsIncrementalGCInProgress(m_rt))
+                    {
+#if GC_DEBUG_PRINT
+                        printf("Finishing incremental GC because gcBytes > m_RuntimeSize / 2. \n");
+#endif
+                        PrepareContextsForIncrementalGC();
+                        JS::FinishIncrementalGC(m_rt, JS::gcreason::REFRESH_FRAME);
+                    }
+                    else
+                    {
+#if GC_DEBUG_PRINT
+                        printf("Running full GC because gcBytes > m_RuntimeSize / 2. \n");
+#endif
+                        JS_GC(m_rt);
+                    }
+                }
+                else
+                {
+#if GC_DEBUG_PRINT
+                    if (!JS::IsIncrementalGCInProgress(m_rt))
+                        printf("Starting incremental GC \n");
+                    else
+                        printf("Running incremental GC slice \n");
+#endif
+                    PrepareContextsForIncrementalGC();
+                    JS::IncrementalGC(m_rt, JS::gcreason::REFRESH_FRAME, GCSliceTimeBudget);
+                }
                 m_LastGCBytes = gcBytes;
             }
         }
@@ -255 +292 @@
     // Workaround for: https://bugzilla.mozilla.org/show_bug.cgi?id=890243
     JSContext* m_dummyContext;
     
+    int m_RuntimeSize;
     int m_HeapGrowthBytesGCTrigger;
     int m_LastGCBytes;
     double m_LastGCCheck;