Changeset 10641 in webkit for trunk/JavaScriptCore/kjs

Timestamp:

Sep 27, 2005, 7:25:58 PM (20 years ago)

Author:

adele

Message:

JavaScriptCore:

Reviewed by Maciej.

Changed ints to size_t where appropriate.

• kjs/collector.cpp: (KJS::Collector::allocate): (KJS::Collector::markStackObjectsConservatively): (KJS::Collector::collect): (KJS::Collector::size): (KJS::Collector::numInterpreters): (KJS::Collector::numGCNotAllowedObjects): (KJS::Collector::numReferencedObjects):
• kjs/collector.h:

WebCore:

Reviewed by Maciej.

Changing ints to size_t where appropriate.

• kwq/WebCoreJavaScript.h:
• kwq/WebCoreJavaScript.mm: (+[WebCoreJavaScript objectCount]): (+[WebCoreJavaScript interpreterCount]): (+[WebCoreJavaScript noGCAllowedObjectCount]): (+[WebCoreJavaScript referencedObjectCount]):

WebKit:

Reviewed by Maciej.

Changed ints to size_t where appropriate.

• Misc.subproj/WebCoreStatistics.h:
• Misc.subproj/WebCoreStatistics.m: (+[WebCoreStatistics javaScriptObjectsCount]): (+[WebCoreStatistics javaScriptInterpretersCount]): (+[WebCoreStatistics javaScriptNoGCAllowedObjectsCount]): (+[WebCoreStatistics javaScriptReferencedObjectsCount]):
• WebView.subproj/WebPreferences.m: (-[WebPreferences _pageCacheSize]): (-[WebPreferences _objectCacheSize]):
• WebView.subproj/WebPreferencesPrivate.h:

Location:

trunk/JavaScriptCore/kjs

Files:

• collector.cpp (modified) (16 diffs)
• collector.h (modified) (2 diffs)

trunk/JavaScriptCore/kjs/collector.cpp

@@ -49 +49 @@
 
 // tunable parameters
-const int MINIMUM_CELL_SIZE = 56;
-const int BLOCK_SIZE = (8 * 4096);
-const int SPARE_EMPTY_BLOCKS = 2;
-const int MIN_ARRAY_SIZE = 14;
-const int GROWTH_FACTOR = 2;
-const int LOW_WATER_FACTOR = 4;
-const int ALLOCATIONS_PER_COLLECTION = 1000;
+const size_t MINIMUM_CELL_SIZE = 56;
+const size_t BLOCK_SIZE = (8 * 4096);
+const size_t SPARE_EMPTY_BLOCKS = 2;
+const size_t MIN_ARRAY_SIZE = 14;
+const size_t GROWTH_FACTOR = 2;
+const size_t LOW_WATER_FACTOR = 4;
+const size_t ALLOCATIONS_PER_COLLECTION = 1000;
 
 // derived constants
-const int CELL_ARRAY_LENGTH = (MINIMUM_CELL_SIZE / sizeof(double)) + (MINIMUM_CELL_SIZE % sizeof(double) != 0 ? sizeof(double) : 0);
-const int CELL_SIZE = CELL_ARRAY_LENGTH * sizeof(double);
-const int CELLS_PER_BLOCK = ((BLOCK_SIZE * 8 - sizeof(int32_t) * 8 - sizeof(void *) * 8) / (CELL_SIZE * 8));
+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 CELLS_PER_BLOCK = ((BLOCK_SIZE * 8 - sizeof(uint32_t) * 8 - sizeof(void *) * 8) / (CELL_SIZE * 8));
 
 
@@ -77 +77 @@
 struct CollectorBlock {
   CollectorCell cells[CELLS_PER_BLOCK];
-  int32_t usedCells;
+  uint32_t usedCells;
   CollectorCell *freeList;
 };
@@ -83 +83 @@
 struct CollectorHeap {
   CollectorBlock **blocks;
-  int numBlocks;
-  int usedBlocks;
-  int firstBlockWithPossibleSpace;
+  size_t numBlocks;
+  size_t usedBlocks;
+  size_t firstBlockWithPossibleSpace;
   
   CollectorCell **oversizeCells;
-  int numOversizeCells;
-  int usedOversizeCells;
-
-  int numLiveObjects;
-  int numLiveObjectsAtLastCollect;
+  size_t numOversizeCells;
+  size_t usedOversizeCells;
+
+  size_t numLiveObjects;
+  size_t numLiveObjectsAtLastCollect;
 };
 
@@ -104 +104 @@
 
   // collect if needed
-  int numLiveObjects = heap.numLiveObjects;
+  size_t numLiveObjects = heap.numLiveObjects;
   if (numLiveObjects - heap.numLiveObjectsAtLastCollect >= ALLOCATIONS_PER_COLLECTION) {
     collect();
@@ -110 +110 @@
   }
   
-  if (s > static_cast<size_t>(CELL_SIZE)) {
+  if (s > CELL_SIZE) {
     // oversize allocator
 
-    int usedOversizeCells = heap.usedOversizeCells;
-    int numOversizeCells = heap.numOversizeCells;
+    size_t usedOversizeCells = heap.usedOversizeCells;
+    size_t numOversizeCells = heap.numOversizeCells;
 
     if (usedOversizeCells == numOversizeCells) {
@@ -132 +132 @@
   // slab allocator
   
-  int usedBlocks = heap.usedBlocks;
-
-  int i = heap.firstBlockWithPossibleSpace;
+  size_t usedBlocks = heap.usedBlocks;
+
+  size_t i = heap.firstBlockWithPossibleSpace;
   CollectorBlock *targetBlock;
-  int targetBlockUsedCells;
+  size_t targetBlockUsedCells;
   if (i != usedBlocks) {
     targetBlock = heap.blocks[i];
@@ -153 +153 @@
     // didn't find one, need to allocate a new block
 
-    int numBlocks = heap.numBlocks;
+    size_t numBlocks = heap.numBlocks;
     if (usedBlocks == numBlocks) {
       numBlocks = max(MIN_ARRAY_SIZE, numBlocks * GROWTH_FACTOR);
@@ -234 +234 @@
 #endif
 
-#define IS_POINTER_ALIGNED(p) (((int)(p) & (sizeof(char *) - 1)) == 0)
+#define IS_POINTER_ALIGNED(p) (((intptr_t)(p) & (sizeof(char *) - 1)) == 0)
 
 // cells are 8-byte aligned
-#define IS_CELL_ALIGNED(p) (((int)(p) & 7) == 0)
+#define IS_CELL_ALIGNED(p) (((intptr_t)(p) & 7) == 0)
 
 void Collector::markStackObjectsConservatively(void *start, void *end)
@@ -254 +254 @@
   char **e = (char **)end;
   
-  int usedBlocks = heap.usedBlocks;
+  size_t usedBlocks = heap.usedBlocks;
   CollectorBlock **blocks = heap.blocks;
-  int usedOversizeCells = heap.usedOversizeCells;
+  size_t usedOversizeCells = heap.usedOversizeCells;
   CollectorCell **oversizeCells = heap.oversizeCells;
 
@@ -264 +264 @@
     char *x = *p++;
     if (IS_CELL_ALIGNED(x) && x) {
-      for (int block = 0; block < usedBlocks; block++) {
+      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 (int i = 0; i != usedOversizeCells; i++)
+      for (size_t i = 0; i != usedOversizeCells; i++)
         if (x == reinterpret_cast<char *>(oversizeCells[i]))
           goto gotGoodPointer;
@@ -397 +397 @@
   // SWEEP: delete everything with a zero refcount (garbage) and unmark everything else
   
-  int emptyBlocks = 0;
-  int numLiveObjects = heap.numLiveObjects;
-
-  for (int block = 0; block < heap.usedBlocks; block++) {
+  size_t emptyBlocks = 0;
+  size_t numLiveObjects = heap.numLiveObjects;
+
+  for (size_t block = 0; block < heap.usedBlocks; block++) {
     CollectorBlock *curBlock = heap.blocks[block];
 
-    int usedCells = curBlock->usedCells;
+    size_t usedCells = curBlock->usedCells;
     CollectorCell *freeList = curBlock->freeList;
 
     if (usedCells == CELLS_PER_BLOCK) {
       // special case with a block where all cells are used -- testing indicates this happens often
-      for (int i = 0; i < CELLS_PER_BLOCK; i++) {
+      for (size_t i = 0; i < CELLS_PER_BLOCK; i++) {
         CollectorCell *cell = curBlock->cells + i;
         AllocatedValueImp *imp = reinterpret_cast<AllocatedValueImp *>(cell);
@@ -425 +425 @@
       }
     } else {
-      int minimumCellsToProcess = usedCells;
-      for (int i = 0; i < minimumCellsToProcess; i++) {
+      size_t minimumCellsToProcess = usedCells;
+      for (size_t i = 0; i < minimumCellsToProcess; i++) {
         CollectorCell *cell = curBlock->cells + i;
         if (cell->u.freeCell.zeroIfFree == 0) {
@@ -473 +473 @@
     heap.firstBlockWithPossibleSpace = 0;
   
-  int cell = 0;
+  size_t cell = 0;
   while (cell < heap.usedOversizeCells) {
     AllocatedValueImp *imp = (AllocatedValueImp *)heap.oversizeCells[cell];
@@ -511 +511 @@
 }
 
-int Collector::size() 
+size_t Collector::size() 
 {
   return heap.numLiveObjects; 
@@ -522 +522 @@
 #endif
 
-int Collector::numInterpreters()
-{
-  int count = 0;
+size_t Collector::numInterpreters()
+{
+  size_t count = 0;
   if (InterpreterImp::s_hook) {
     InterpreterImp *scr = InterpreterImp::s_hook;
@@ -535 +535 @@
 }
 
-int Collector::numGCNotAllowedObjects()
+size_t Collector::numGCNotAllowedObjects()
 {
   return 0;
 }
 
-int Collector::numReferencedObjects()
-{
-  int count = 0;
-
-  int size = ProtectedValues::_tableSize;
+size_t Collector::numReferencedObjects()
+{
+  size_t count = 0;
+
+  size_t size = ProtectedValues::_tableSize;
   ProtectedValues::KeyValue *table = ProtectedValues::_table;
-  for (int i = 0; i < size; i++) {
+  for (size_t i = 0; i < size; i++) {
     AllocatedValueImp *val = table[i].key;
     if (val) {

trunk/JavaScriptCore/kjs/collector.h

@@ -54 +54 @@
      */
     static bool collect();
-    static int size();
+    static size_t size();
     static bool outOfMemory() { return memoryFull; }
 
@@ -64 +64 @@
 #endif
 
-    static int numInterpreters();
-    static int numGCNotAllowedObjects();
-    static int numReferencedObjects();
+    static size_t numInterpreters();
+    static size_t numGCNotAllowedObjects();
+    static size_t numReferencedObjects();
 #if APPLE_CHANGES
     static const void *rootObjectClasses(); // actually returns CFSetRef