Changeset 47795 in webkit for trunk/JavaScriptCore/runtime/Collector.cpp

Timestamp:

Aug 26, 2009, 2:33:30 PM (16 years ago)

Author:

[email protected]

Message:

End re-roll-in of r47738:47740 with Windows crash fixed

2009-08-26 Geoffrey Garen <​[email protected]>

Build fix: start out with a 32-bit value to avoid a shortening warning.

• runtime/Collector.cpp: (JSC::Heap::sweep):

2009-08-24 Geoffrey Garen <​[email protected]>

Reviewed by Oliver Hunt.

Substantially reduced VM thrash in the GC heap.

1.08x faster on v8 (1.60x faster on v8-splay).

1.40x faster on bench-alloc-nonretained.

1.90x faster on bench-alloc-retained.

SunSpider says no change.

• runtime/Collector.cpp: (JSC::Heap::heapAllocate): Fixed a long-standing bug: update a few local variables unconditionally after calling collect(), since they may be used even if we don't "goto scan". (In the bug I saw, usedBlocks got out of sync with heap.usedBlocks). (JSC::Heap::sweep): Keep enough free heap space to accomodate the number of objects we'll allocate before the next GC, plus 25%, for good measure.
• runtime/Collector.h: Bumped the block size to 256k. This seems to give the best cache performance, and it prevents us from initiating lots of VM traffic to recover very small chunks of memory.

Begin re-roll-in of r47738:47740 with Windows crash fixed

File:

• trunk/JavaScriptCore/runtime/Collector.cpp (modified) (6 diffs)

trunk/JavaScriptCore/runtime/Collector.cpp

@@ -61 +61 @@
 
 #include <windows.h>
+#include <malloc.h>
 
 #elif PLATFORM(HAIKU)
@@ -102 +103 @@
 // tunable parameters
 
-const size_t SPARE_EMPTY_BLOCKS = 2;
 const size_t GROWTH_FACTOR = 2;
 const size_t LOW_WATER_FACTOR = 4;
@@ -241 +241 @@
     memset(reinterpret_cast<void*>(address), 0, BLOCK_SIZE);
 #elif PLATFORM(WIN_OS)
-     // windows virtual address granularity is naturally 64k
-    LPVOID address = VirtualAlloc(NULL, BLOCK_SIZE, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+    void* address = _aligned_malloc(BLOCK_SIZE, BLOCK_SIZE);
 #elif HAVE(POSIX_MEMALIGN)
     void* address;
@@ -285 +284 @@
     userChunk->Free(reinterpret_cast<TAny*>(block));
 #elif PLATFORM(WIN_OS)
-    VirtualFree(block, 0, MEM_RELEASE);
+    _aligned_free(block);
 #elif HAVE(POSIX_MEMALIGN)
     free(block);
@@ -386 +385 @@
             heap.operationInProgress = NoOperation;
 #endif
-            bool collected = collect();
+            bool foundGarbage = collect();
+            numLiveObjects = heap.numLiveObjects;
+            usedBlocks = heap.usedBlocks;
+            i = heap.firstBlockWithPossibleSpace;
 #ifndef NDEBUG
             heap.operationInProgress = Allocation;
 #endif
-            if (collected) {
-                numLiveObjects = heap.numLiveObjects;
-                usedBlocks = heap.usedBlocks;
-                i = heap.firstBlockWithPossibleSpace;
+            if (foundGarbage)
                 goto scan;
-            }
         }
   
@@ -1085 +1083 @@
         curBlock->marked.clearAll();
         
-        if (usedCells == 0) {
-            emptyBlocks++;
-            if (emptyBlocks > SPARE_EMPTY_BLOCKS) {
-#if !DEBUG_COLLECTOR
-                freeBlock(reinterpret_cast<CollectorBlock*>(curBlock));
-#endif
-                // swap with the last block so we compact as we go
-                heap.blocks[block] = heap.blocks[heap.usedBlocks - 1];
-                heap.usedBlocks--;
-                block--; // Don't move forward a step in this case
-                
-                if (heap.numBlocks > MIN_ARRAY_SIZE && heap.usedBlocks < heap.numBlocks / LOW_WATER_FACTOR) {
-                    heap.numBlocks = heap.numBlocks / GROWTH_FACTOR; 
-                    heap.blocks = static_cast<CollectorBlock**>(fastRealloc(heap.blocks, heap.numBlocks * sizeof(CollectorBlock*)));
-                }
-            }
-        }
+        if (!usedCells)
+            ++emptyBlocks;
     }
     
     if (heap.numLiveObjects != numLiveObjects)
         heap.firstBlockWithPossibleSpace = 0;
-        
+    
     heap.numLiveObjects = numLiveObjects;
     heap.numLiveObjectsAtLastCollect = numLiveObjects;
     heap.extraCost = 0;
+    
+    if (!emptyBlocks)
+        return numLiveObjects;
+
+    size_t neededCells = 1.25f * (numLiveObjects + max(ALLOCATIONS_PER_COLLECTION, numLiveObjects));
+    size_t neededBlocks = (neededCells + HeapConstants<heapType>::cellsPerBlock - 1) / HeapConstants<heapType>::cellsPerBlock;
+    for (size_t block = 0; block < heap.usedBlocks; block++) {
+        if (heap.usedBlocks <= neededBlocks)
+            break;
+
+        Block* curBlock = reinterpret_cast<Block*>(heap.blocks[block]);
+        if (curBlock->usedCells)
+            continue;
+
+#if !DEBUG_COLLECTOR
+        freeBlock(reinterpret_cast<CollectorBlock*>(curBlock));
+#endif
+        // swap with the last block so we compact as we go
+        heap.blocks[block] = heap.blocks[heap.usedBlocks - 1];
+        heap.usedBlocks--;
+        block--; // Don't move forward a step in this case
+
+        if (heap.numBlocks > MIN_ARRAY_SIZE && heap.usedBlocks < heap.numBlocks / LOW_WATER_FACTOR) {
+            heap.numBlocks = heap.numBlocks / GROWTH_FACTOR; 
+            heap.blocks = static_cast<CollectorBlock**>(fastRealloc(heap.blocks, heap.numBlocks * sizeof(CollectorBlock*)));
+        }
+    }
+
     return numLiveObjects;
 }