Oilpan: We shouldn't schedule a GC before we complete sweeping

Source/platform/heap/Heap.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 784 matching lines @@
 #endif
 
     // 1. If this allocation is big enough, allocate a large object.
     if (allocationSize >= largeObjectSizeThreshold) {
         LargeObjectHeap* largeObjectHeap = static_cast<LargeObjectHeap*>(threadState()->heap(LargeObjectHeapIndex));
         Address largeObject = largeObjectHeap->allocateLargeObjectPage(allocationSize, gcInfoIndex);
         ASAN_MARK_LARGE_VECTOR_CONTAINER(this, largeObject);
         return largeObject;
     }
 
-    // 2. Check if we should trigger a GC.
+    // 2. Try to allocate from a free list.
     updateRemainingAllocationSize();
-    threadState()->scheduleGCIfNeeded();
-
-    // 3. Try to allocate from a free list.
     Address result = allocateFromFreeList(allocationSize, gcInfoIndex);
     if (result)
         return result;
 
-    // 4. Reset the allocation point.
+    // 3. Reset the allocation point.
     setAllocationPoint(nullptr, 0);
 
-    // 5. Lazily sweep pages of this heap until we find a freed area for
+    // 4. Lazily sweep pages of this heap until we find a freed area for
     // this allocation or we finish sweeping all pages of this heap.
     result = lazySweep(allocationSize, gcInfoIndex);
     if (result)
         return result;
 
-    // 6. Coalesce promptly freed areas and then try to allocate from a free
+    // 5. Coalesce promptly freed areas and then try to allocate from a free
     // list.
     if (coalesce()) {
         result = allocateFromFreeList(allocationSize, gcInfoIndex);
         if (result)
             return result;
     }
 
-    // 7. Complete sweeping.
+    // 6. Complete sweeping.
     threadState()->completeSweep();
 
+    // 7. Check if we should trigger a GC.
+    threadState()->scheduleGCIfNeeded();
+
     // 8. Add a new page to this heap.
     allocatePage();
 
     // 9. Try to allocate from a free list. This allocation must succeed.
     result = allocateFromFreeList(allocationSize, gcInfoIndex);
     RELEASE_ASSERT(result);
     return result;
 }
 
 Address NormalPageHeap::allocateFromFreeList(size_t allocationSize, size_t gcInfoIndex)
@@ skipping 31 matching lines @@
     : BaseHeap(state, index)
 {
 }
 
 Address LargeObjectHeap::allocateLargeObjectPage(size_t allocationSize, size_t gcInfoIndex)
 {
     // Caller already added space for object header and rounded up to allocation
     // alignment
     ASSERT(!(allocationSize & allocationMask));
 
-    // 1. Check if we should trigger a GC.
-    threadState()->scheduleGCIfNeeded();
-
-    // 2. Try to sweep large objects more than allocationSize bytes
+    // 1. Try to sweep large objects more than allocationSize bytes
     // before allocating a new large object.
     Address result = lazySweep(allocationSize, gcInfoIndex);
     if (result)
         return result;
 
-    // 3. If we have failed in sweeping allocationSize bytes,
+    // 2. If we have failed in sweeping allocationSize bytes,
     // we complete sweeping before allocating this large object.
     threadState()->completeSweep();
+
+    // 3. Check if we should trigger a GC.
+    threadState()->scheduleGCIfNeeded();
+
     return doAllocateLargeObjectPage(allocationSize, gcInfoIndex);
 }
 
 Address LargeObjectHeap::doAllocateLargeObjectPage(size_t allocationSize, size_t gcInfoIndex)
 {
     size_t largeObjectSize = LargeObjectPage::pageHeaderSize() + allocationSize;
     // If ASan is supported we add allocationGranularity bytes to the allocated
     // space and poison that to detect overflows
 #if defined(ADDRESS_SANITIZER)
     largeObjectSize += allocationGranularity;
@@ skipping 1352 matching lines @@
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 // We don't want to use 0 KB for the initial value because it may end up
 // triggering the first GC of some thread too prematurely.
 size_t Heap::s_estimatedLiveObjectSize = 512 * 1024;
 size_t Heap::s_externalObjectSizeAtLastGC = 0;
 double Heap::s_estimatedMarkingTimePerByte = 0.0;
 
 } // namespace blink