Changeset 20722 in webkit

Timestamp:

Apr 5, 2007 9:35:43 AM (17 years ago)

Author:

mjs

Message:

Not reviewed, experimental change.

• remove the concept of oversize objects, now that there aren't any (for now only enforced with an assert).

This change is a .66% speedup on JS iBench for 32-bit platforms, probably much more
for 64-bit since it finally gives a reasonable cell size, but I did not test that.

• kjs/collector.cpp: (KJS::): Use different cell size for 32-bit and 64-bit, now that there is no oversize allocation. (KJS::Collector::allocate): Remove oversize allocator. (KJS::Collector::markStackObjectsConservatively): Don't check oversize objects. (KJS::Collector::markMainThreadOnlyObjects): Ditto. (KJS::Collector::collect): Ditto.

Location:

branches/js-collector-tweaks/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• kjs/collector.cpp (modified) (9 diffs)

branches/js-collector-tweaks/JavaScriptCore/ChangeLog

@@ +1 @@
+2007-04-05  Maciej Stachowiak  <mjs@apple.com>
+
+        Not reviewed, experimental change.
+        
+        - remove the concept of oversize objects, now that there aren't any (for now
+        only enforced with an assert).
+
+        This change is a .66% speedup on JS iBench for 32-bit platforms, probably much more
+        for 64-bit since it finally gives a reasonable cell size, but I did not test that.
+        
+        * kjs/collector.cpp:
+        (KJS::): Use different cell size for 32-bit and 64-bit, now that there is no
+        oversize allocation.
+        (KJS::Collector::allocate): Remove oversize allocator.
+        (KJS::Collector::markStackObjectsConservatively): Don't check oversize objects.
+        (KJS::Collector::markMainThreadOnlyObjects): Ditto.
+        (KJS::Collector::collect): Ditto.
+
 2007-04-03  Kevin McCullough  <kmccullough@apple.com>
 

branches/js-collector-tweaks/JavaScriptCore/kjs/collector.cpp

@@ -59 +59 @@
 namespace KJS {
 
+
+
 // tunable parameters
-const size_t MINIMUM_CELL_SIZE = 48;
+
+template<bool is32Bit, bool is64Bit> struct CellSize;
+template<> struct CellSize<true, false> { static const size_t m_value = 48; }; // 32-bit
+template<> struct CellSize<false, true> { static const size_t m_value = 80; }; // 64-bit
+
 const size_t BLOCK_SIZE = (8 * 4096);
 const size_t SPARE_EMPTY_BLOCKS = 2;
@@ -69 +75 @@
 
 // derived constants
-const size_t CELL_ARRAY_LENGTH = (MINIMUM_CELL_SIZE / sizeof(double)) + (MINIMUM_CELL_SIZE % sizeof(double) != 0 ? sizeof(double) : 0);
+const size_t MINIMUM_CELL_SIZE = CellSize<sizeof(void*) == sizeof(uint32_t), sizeof(void*) == sizeof(uint64_t)>::m_value;
+const size_t CELL_ARRAY_LENGTH = (MINIMUM_CELL_SIZE / sizeof(double)) + (MINIMUM_CELL_SIZE % sizeof(double) != 0 ? 1 : 0);
 const size_t CELL_SIZE = CELL_ARRAY_LENGTH * sizeof(double);
-const size_t CELLS_PER_BLOCK = ((BLOCK_SIZE * 8 - sizeof(uint32_t) * 8 - sizeof(void *) * 8) / (CELL_SIZE * 8));
-
+const size_t CELLS_PER_BLOCK = ((BLOCK_SIZE * 8 - sizeof(uint32_t) * 8 - sizeof(void*) * 8) / (CELL_SIZE * 8));
 
 
@@ -98 +104 @@
   size_t firstBlockWithPossibleSpace;
   
-  CollectorCell **oversizeCells;
-  size_t numOversizeCells;
-  size_t usedOversizeCells;
-
   size_t numLiveObjects;
   size_t numLiveObjectsAtLastCollect;
 };
 
-static CollectorHeap heap = {NULL, 0, 0, 0, NULL, 0, 0, 0, 0};
+static CollectorHeap heap = {NULL, 0, 0, 0, 0, 0};
 
 size_t Collector::mainThreadOnlyObjectCount = 0;
@@ -137 +139 @@
   ASSERT(JSLock::lockCount() > 0);
   ASSERT(JSLock::currentThreadIsHoldingLock());
+  ASSERT(s <= CELL_SIZE);
 
   // collect if needed
@@ -151 +154 @@
   GCLock lock;
 #endif
-  
-  if (s > CELL_SIZE) {
-    // oversize allocator
-    size_t usedOversizeCells = heap.usedOversizeCells;
-    size_t numOversizeCells = heap.numOversizeCells;
-
-    if (usedOversizeCells == numOversizeCells) {
-      numOversizeCells = max(MIN_ARRAY_SIZE, numOversizeCells * GROWTH_FACTOR);
-      heap.numOversizeCells = numOversizeCells;
-      heap.oversizeCells = static_cast<CollectorCell **>(fastRealloc(heap.oversizeCells, numOversizeCells * sizeof(CollectorCell *)));
-    }
-    
-    void *newCell = fastMalloc(s);
-    heap.oversizeCells[usedOversizeCells] = static_cast<CollectorCell *>(newCell);
-    heap.usedOversizeCells = usedOversizeCells + 1;
-    heap.numLiveObjects = numLiveObjects + 1;
-
-    return newCell;
-  }
   
   // slab allocator
@@ -385 +369 @@
   size_t usedBlocks = heap.usedBlocks;
   CollectorBlock **blocks = heap.blocks;
-  size_t usedOversizeCells = heap.usedOversizeCells;
-  CollectorCell **oversizeCells = heap.oversizeCells;
 
   const size_t lastCellOffset = sizeof(CollectorCell) * (CELLS_PER_BLOCK - 1);
@@ -395 +377 @@
       for (size_t block = 0; block < usedBlocks; block++) {
         size_t offset = x - reinterpret_cast<char *>(blocks[block]);
-        if (offset <= lastCellOffset && offset % sizeof(CollectorCell) == 0)
-          goto gotGoodPointer;
-      }
-      for (size_t i = 0; i != usedOversizeCells; i++)
-        if (x == reinterpret_cast<char *>(oversizeCells[i]))
-          goto gotGoodPointer;
-      continue;
-
-gotGoodPointer:
-      if (((CollectorCell *)x)->u.freeCell.zeroIfFree != 0) {
-        JSCell *imp = reinterpret_cast<JSCell *>(x);
-        if (!imp->marked())
-          imp->mark();
+        if (offset <= lastCellOffset && offset % sizeof(CollectorCell) == 0) {
+          if (((CollectorCell *)x)->u.freeCell.zeroIfFree != 0) {
+            JSCell *imp = reinterpret_cast<JSCell *>(x);
+            if (!imp->marked())
+              imp->mark();
+          }
+          break;
+        }
       }
     }
@@ -695 +672 @@
         }
     }
-
-    for (size_t cell = 0; cell < heap.usedOversizeCells; cell++) {
-        ASSERT(count < mainThreadOnlyObjectCount);
-
-        JSCell* imp = reinterpret_cast<JSCell*>(heap.oversizeCells[cell]);
-        if (imp->m_collectOnMainThreadOnly) {
-            if (!imp->marked())
-                imp->mark();
-            if (++count == mainThreadOnlyObjectCount)
-                return;
-        }
-    }
 }
 
@@ -842 +807 @@
     heap.firstBlockWithPossibleSpace = 0;
   
-  size_t cell = 0;
-  while (cell < heap.usedOversizeCells) {
-    JSCell *imp = (JSCell *)heap.oversizeCells[cell];
-    
-    if (imp->m_marked) {
-      imp->m_marked = false;
-      cell++;
-    } else {
-      ASSERT(currentThreadIsMainThread || !imp->m_collectOnMainThreadOnly);
-      if (imp->m_collectOnMainThreadOnly)
-        --mainThreadOnlyObjectCount;
-      imp->~JSCell();
-#if DEBUG_COLLECTOR
-      heap.oversizeCells[cell]->u.freeCell.zeroIfFree = 0;
-#else
-      fastFree(imp);
-#endif
-
-      // swap with the last oversize cell so we compact as we go
-      heap.oversizeCells[cell] = heap.oversizeCells[heap.usedOversizeCells - 1];
-
-      heap.usedOversizeCells--;
-      numLiveObjects--;
-
-      if (heap.numOversizeCells > MIN_ARRAY_SIZE && heap.usedOversizeCells < heap.numOversizeCells / LOW_WATER_FACTOR) {
-        heap.numOversizeCells = heap.numOversizeCells / GROWTH_FACTOR; 
-        heap.oversizeCells = (CollectorCell **)fastRealloc(heap.oversizeCells, heap.numOversizeCells * sizeof(CollectorCell *));
-      }
-    }
-  }
-  
   bool deleted = heap.numLiveObjects != numLiveObjects;