Changeset 21047 in webkit for trunk/JavaScriptCore/kjs/collector.h

Timestamp:

Apr 23, 2007, 2:54:33 PM (18 years ago)

Author:

mjs

Message:

Reviewed by Darin and Geoff.

• move mark and collectOnMainThreadOnly bits into separate bitmaps

This saves 4 bytes per cell, allowing shrink of cell size to 32,
which leads to a .8% speed improvement on iBench.

This is only feasible because of all the previous changes on the branch.

• kjs/collector.cpp: (KJS::allocateBlock): Adjust for some renames of constants. (KJS::Collector::markStackObjectsConservatively): Now that cells are 32 bytes (64 bytes on 64-bit) the cell alignment check can be made much more strict, and also obsoletes the need for a % sizeof(CollectorCell) check. Also, we can mask off the low bits of the pointer to have a potential block pointer to look for. (KJS::Collector::collectOnMainThreadOnly): Use bitmap. (KJS::Collector::markMainThreadOnlyObjects): Use bitmap. (KJS::Collector::collect): When sweeping, use bitmaps directly to find mark bits.
• kjs/collector.h: (KJS::): Move needed constants and type declarations here. (KJS::CollectorBitmap::get): Bit twiddling to get a bitmap value. (KJS::CollectorBitmap::set): Bit twiddling to set a bitmap bit to true. (KJS::CollectorBitmap::clear): Bit twiddling to set a bitmap bit to false. (KJS::CollectorBitmap::clearAll): Clear whole bitmap at one go. (KJS::Collector::cellBlock): New operation, compute the block pointer for a cell by masking off low bits. (KJS::Collector::cellOffset): New operation, compute the cell offset for a cell by masking off high bits and dividing (actually a shift). (KJS::Collector::isCellMarked): Check mark bit in bitmap (KJS::Collector::markCell): Set mark bit in bitmap.
• kjs/value.h: (KJS::JSCell::JSCell): No more bits. (KJS::JSCell::marked): Let collector handle it. (KJS::JSCell::mark): Let collector handle it.

File:

• trunk/JavaScriptCore/kjs/collector.h (modified) (4 diffs)

trunk/JavaScriptCore/kjs/collector.h

@@ -25 +25 @@
 #define KJSCOLLECTOR_H_
 
-#include "value.h"
 #include <wtf/HashCountedSet.h>
 
@@ -31 +30 @@
 
 namespace KJS {
+
+  class JSCell;
+  class JSValue;
+  class CollectorBlock;
 
   class Collector {
@@ -61 +64 @@
     static void registerAsMainThread();
 
+    static bool isCellMarked(const JSCell*);
+    static void markCell(JSCell*);
+
   private:
+    static const CollectorBlock* cellBlock(const JSCell*);
+    static CollectorBlock* cellBlock(JSCell*);
+    static size_t cellOffset(const JSCell* cell);
+
     Collector();
 
@@ -75 +85 @@
   };
 
+  // tunable parameters
+  template<size_t bytesPerWord> struct CellSize;
+
+  // cell size needs to be a power of two for certain optimizations in collector.cpp
+  template<> struct CellSize<sizeof(uint32_t)> { static const size_t m_value = 32; }; // 32-bit
+  template<> struct CellSize<sizeof(uint64_t)> { static const size_t m_value = 64; }; // 64-bit
+  const size_t BLOCK_SIZE = 16 * 4096; // 64k
+  
+  // derived constants
+  const size_t BLOCK_OFFSET_MASK = BLOCK_SIZE - 1;
+  const size_t BLOCK_MASK = ~BLOCK_OFFSET_MASK;
+  const size_t MINIMUM_CELL_SIZE = CellSize<sizeof(void*)>::m_value;
+  const size_t CELL_ARRAY_LENGTH = (MINIMUM_CELL_SIZE / sizeof(double)) + (MINIMUM_CELL_SIZE % sizeof(double) != 0 ? sizeof(double) : 0);
+  const size_t CELL_SIZE = CELL_ARRAY_LENGTH * sizeof(double);
+  const size_t CELL_MASK = CELL_SIZE - 1;
+  const size_t CELLS_PER_BLOCK = (BLOCK_SIZE * 8 - sizeof(uint32_t) * 8 - sizeof(void *) * 8 - 2 * (7 + 3 * 8)) / (CELL_SIZE * 8 + 2);
+  const size_t BITMAP_SIZE = (CELLS_PER_BLOCK + 7) / 8;
+  const size_t BITMAP_WORDS = (BITMAP_SIZE + 3) / sizeof(uint32_t);
+  
+  struct CollectorBitmap {
+    uint32_t bits[BITMAP_WORDS];
+    bool get(size_t n) const { return !!(bits[n >> 5] & (1 << (n & 0x1F))); } 
+    void set(size_t n) { bits[n >> 5] |= (1 << (n & 0x1F)); } 
+    void clear(size_t n) { bits[n >> 5] &= ~(1 << (n & 0x1F)); } 
+    void clearAll() { memset(bits, 0, sizeof(bits)); }
+  };
+  
+  struct CollectorCell {
+    union {
+      double memory[CELL_ARRAY_LENGTH];
+      struct {
+        void* zeroIfFree;
+        ptrdiff_t next;
+      } freeCell;
+    } u;
+  };
+
+  struct CollectorBlock {
+    CollectorCell cells[CELLS_PER_BLOCK];
+    uint32_t usedCells;
+    CollectorCell* freeList;
+    CollectorBitmap marked;
+    CollectorBitmap collectOnMainThreadOnly;
+  };
+
+  inline const CollectorBlock* Collector::cellBlock(const JSCell* cell)
+  {
+    return reinterpret_cast<const CollectorBlock*>(reinterpret_cast<uintptr_t>(cell) & BLOCK_MASK);
+  }
+
+  inline CollectorBlock* Collector::cellBlock(JSCell* cell)
+  {
+    return const_cast<CollectorBlock*>(cellBlock(const_cast<const JSCell*>(cell)));
+  }
+
+  inline size_t Collector::cellOffset(const JSCell* cell)
+  {
+    return (reinterpret_cast<uintptr_t>(cell) & BLOCK_OFFSET_MASK) / CELL_SIZE;
+  }
+
+  inline bool Collector::isCellMarked(const JSCell* cell)
+  {
+    return cellBlock(cell)->marked.get(cellOffset(cell));
+  }
+
+  inline void Collector::markCell(JSCell* cell)
+  {
+    cellBlock(cell)->marked.set(cellOffset(cell));
+  }
+
 } // namespace KJS