Changeset 34360 in webkit for trunk/JavaScriptCore/kjs

Timestamp:

Jun 4, 2008, 9:29:49 AM (17 years ago)

Author:

[email protected]

Message:

Rubber-stamped by Darin.

Fix spacing in collector.{h,cpp}.

• kjs/collector.cpp:
• kjs/collector.h:

Location:

trunk/JavaScriptCore/kjs

Files:

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

trunk/JavaScriptCore/kjs/collector.cpp

@@ -1 @@
-// -*- mode: c++; c-basic-offset: 4 -*-
 /*
  *  Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
@@ -182 +181 @@
 template <Collector::HeapType heapType> void* Collector::heapAllocate(size_t s)
 {
-  typedef typename HeapConstants<heapType>::Block Block;
-  typedef typename HeapConstants<heapType>::Cell Cell;
-
-  CollectorHeap& heap = heapType == PrimaryHeap ? primaryHeap : numberHeap;
-  ASSERT(JSLock::lockCount() > 0);
-  ASSERT(JSLock::currentThreadIsHoldingLock());
-  ASSERT(s <= HeapConstants<heapType>::cellSize);
-  UNUSED_PARAM(s); // s is now only used for the above assert
-
-  ASSERT(heap.operationInProgress == NoOperation);
-  ASSERT(heapType == PrimaryHeap || heap.extraCost == 0);
-  // FIXME: If another global variable access here doesn't hurt performance
-  // too much, we could abort() in NDEBUG builds, which could help ensure we
-  // don't spend any time debugging cases where we allocate inside an object's
-  // deallocation code.
-
-  size_t numLiveObjects = heap.numLiveObjects;
-  size_t usedBlocks = heap.usedBlocks;
-  size_t i = heap.firstBlockWithPossibleSpace;
+    typedef typename HeapConstants<heapType>::Block Block;
+    typedef typename HeapConstants<heapType>::Cell Cell;
+
+    CollectorHeap& heap = heapType == PrimaryHeap ? primaryHeap : numberHeap;
+    ASSERT(JSLock::lockCount() > 0);
+    ASSERT(JSLock::currentThreadIsHoldingLock());
+    ASSERT(s <= HeapConstants<heapType>::cellSize);
+    UNUSED_PARAM(s); // s is now only used for the above assert
+
+    ASSERT(heap.operationInProgress == NoOperation);
+    ASSERT(heapType == PrimaryHeap || heap.extraCost == 0);
+    // FIXME: If another global variable access here doesn't hurt performance
+    // too much, we could abort() in NDEBUG builds, which could help ensure we
+    // don't spend any time debugging cases where we allocate inside an object's
+    // deallocation code.
+
+    size_t numLiveObjects = heap.numLiveObjects;
+    size_t usedBlocks = heap.usedBlocks;
+    size_t i = heap.firstBlockWithPossibleSpace;
 
 #if COLLECT_ON_EVERY_ALLOCATION
-  collect();
-#endif
-
-  // if we have a huge amount of extra cost, we'll try to collect even if we still have
-  // free cells left.
-  if (heapType == PrimaryHeap && heap.extraCost > ALLOCATIONS_PER_COLLECTION) {
-      size_t numLiveObjectsAtLastCollect = heap.numLiveObjectsAtLastCollect;
-      size_t numNewObjects = numLiveObjects - numLiveObjectsAtLastCollect;
-      const size_t newCost = numNewObjects + heap.extraCost;
-      if (newCost >= ALLOCATIONS_PER_COLLECTION && newCost >= numLiveObjectsAtLastCollect)
-          goto collect;
-  }
-
-  ASSERT(heap.operationInProgress == NoOperation);
+    collect();
+#endif
+
+    // if we have a huge amount of extra cost, we'll try to collect even if we still have
+    // free cells left.
+    if (heapType == PrimaryHeap && heap.extraCost > ALLOCATIONS_PER_COLLECTION) {
+        size_t numLiveObjectsAtLastCollect = heap.numLiveObjectsAtLastCollect;
+        size_t numNewObjects = numLiveObjects - numLiveObjectsAtLastCollect;
+        const size_t newCost = numNewObjects + heap.extraCost;
+        if (newCost >= ALLOCATIONS_PER_COLLECTION && newCost >= numLiveObjectsAtLastCollect)
+            goto collect;
+    }
+
+    ASSERT(heap.operationInProgress == NoOperation);
 #ifndef NDEBUG
-  // FIXME: Consider doing this in NDEBUG builds too (see comment above).
-  heap.operationInProgress = Allocation;
+    // FIXME: Consider doing this in NDEBUG builds too (see comment above).
+    heap.operationInProgress = Allocation;
 #endif
 
 scan:
-  Block* targetBlock;
-  size_t targetBlockUsedCells;
-  if (i != usedBlocks) {
-    targetBlock = (Block*)heap.blocks[i];
-    targetBlockUsedCells = targetBlock->usedCells;
-    ASSERT(targetBlockUsedCells <= HeapConstants<heapType>::cellsPerBlock);
-    while (targetBlockUsedCells == HeapConstants<heapType>::cellsPerBlock) {
-      if (++i == usedBlocks)
-        goto collect;
-      targetBlock = (Block*)heap.blocks[i];
-      targetBlockUsedCells = targetBlock->usedCells;
-      ASSERT(targetBlockUsedCells <= HeapConstants<heapType>::cellsPerBlock);
-    }
-    heap.firstBlockWithPossibleSpace = i;
-  } else {
+    Block* targetBlock;
+    size_t targetBlockUsedCells;
+    if (i != usedBlocks) {
+        targetBlock = (Block*)heap.blocks[i];
+        targetBlockUsedCells = targetBlock->usedCells;
+        ASSERT(targetBlockUsedCells <= HeapConstants<heapType>::cellsPerBlock);
+        while (targetBlockUsedCells == HeapConstants<heapType>::cellsPerBlock) {
+            if (++i == usedBlocks)
+                goto collect;
+            targetBlock = (Block*)heap.blocks[i];
+            targetBlockUsedCells = targetBlock->usedCells;
+            ASSERT(targetBlockUsedCells <= HeapConstants<heapType>::cellsPerBlock);
+        }
+        heap.firstBlockWithPossibleSpace = i;
+    } else {
 
 collect:
-    size_t numLiveObjectsAtLastCollect = heap.numLiveObjectsAtLastCollect;
-    size_t numNewObjects = numLiveObjects - numLiveObjectsAtLastCollect;
-    const size_t newCost = numNewObjects + heap.extraCost;
-
-    if (newCost >= ALLOCATIONS_PER_COLLECTION && newCost >= numLiveObjectsAtLastCollect) {
+        size_t numLiveObjectsAtLastCollect = heap.numLiveObjectsAtLastCollect;
+        size_t numNewObjects = numLiveObjects - numLiveObjectsAtLastCollect;
+        const size_t newCost = numNewObjects + heap.extraCost;
+
+        if (newCost >= ALLOCATIONS_PER_COLLECTION && newCost >= numLiveObjectsAtLastCollect) {
 #ifndef NDEBUG
-      heap.operationInProgress = NoOperation;
-#endif
-      bool collected = collect();
+            heap.operationInProgress = NoOperation;
+#endif
+            bool collected = collect();
 #ifndef NDEBUG
-      heap.operationInProgress = Allocation;
-#endif
-      if (collected) {
-        numLiveObjects = heap.numLiveObjects;
-        usedBlocks = heap.usedBlocks;
-        i = heap.firstBlockWithPossibleSpace;
-        goto scan;
-      }
-    }
+            heap.operationInProgress = Allocation;
+#endif
+            if (collected) {
+                numLiveObjects = heap.numLiveObjects;
+                usedBlocks = heap.usedBlocks;
+                i = heap.firstBlockWithPossibleSpace;
+                goto scan;
+            }
+        }
   
-    // didn't find a block, and GC didn't reclaim anything, need to allocate a new block
-    size_t numBlocks = heap.numBlocks;
-    if (usedBlocks == numBlocks) {
-      numBlocks = max(MIN_ARRAY_SIZE, numBlocks * GROWTH_FACTOR);
-      heap.numBlocks = numBlocks;
-      heap.blocks = static_cast<CollectorBlock **>(fastRealloc(heap.blocks, numBlocks * sizeof(CollectorBlock *)));
-    }
-
-    targetBlock = (Block*)allocateBlock();
-    targetBlock->freeList = targetBlock->cells;
-    targetBlockUsedCells = 0;
-    heap.blocks[usedBlocks] = (CollectorBlock*)targetBlock;
-    heap.usedBlocks = usedBlocks + 1;
-    heap.firstBlockWithPossibleSpace = usedBlocks;
-  }
+        // didn't find a block, and GC didn't reclaim anything, need to allocate a new block
+        size_t numBlocks = heap.numBlocks;
+        if (usedBlocks == numBlocks) {
+            numBlocks = max(MIN_ARRAY_SIZE, numBlocks * GROWTH_FACTOR);
+            heap.numBlocks = numBlocks;
+            heap.blocks = static_cast<CollectorBlock**>(fastRealloc(heap.blocks, numBlocks * sizeof(CollectorBlock*)));
+        }
+
+        targetBlock = (Block*)allocateBlock();
+        targetBlock->freeList = targetBlock->cells;
+        targetBlockUsedCells = 0;
+        heap.blocks[usedBlocks] = (CollectorBlock*)targetBlock;
+        heap.usedBlocks = usedBlocks + 1;
+        heap.firstBlockWithPossibleSpace = usedBlocks;
+    }
   
-  // find a free spot in the block and detach it from the free list
-  Cell *newCell = targetBlock->freeList;
-  
-  // "next" field is a cell offset -- 0 means next cell, so a zeroed block is already initialized
-  targetBlock->freeList = (newCell + 1) + newCell->u.freeCell.next;
-
-  targetBlock->usedCells = static_cast<uint32_t>(targetBlockUsedCells + 1);
-  heap.numLiveObjects = numLiveObjects + 1;
+    // find a free spot in the block and detach it from the free list
+    Cell* newCell = targetBlock->freeList;
+
+    // "next" field is a cell offset -- 0 means next cell, so a zeroed block is already initialized
+    targetBlock->freeList = (newCell + 1) + newCell->u.freeCell.next;
+
+    targetBlock->usedCells = static_cast<uint32_t>(targetBlockUsedCells + 1);
+    heap.numLiveObjects = numLiveObjects + 1;
 
 #ifndef NDEBUG
-  // FIXME: Consider doing this in NDEBUG builds too (see comment above).
-  heap.operationInProgress = NoOperation;
-#endif
-
-  return newCell;
+    // FIXME: Consider doing this in NDEBUG builds too (see comment above).
+    heap.operationInProgress = NoOperation;
+#endif
+
+    return newCell;
 }
 
@@ -409 +408 @@
 class Collector::Thread {
 public:
-  Thread(pthread_t pthread, const PlatformThread& platThread, void* base) 
-  : posixThread(pthread), platformThread(platThread), stackBase(base) {}
-  Thread* next;
-  pthread_t posixThread;
-  PlatformThread platformThread;
-  void* stackBase;
+    Thread(pthread_t pthread, const PlatformThread& platThread, void* base) 
+        : posixThread(pthread)
+        , platformThread(platThread)
+        , stackBase(base)
+        {
+        }
+
+    Thread* next;
+    pthread_t posixThread;
+    PlatformThread platformThread;
+    void* stackBase;
 };
 
@@ -423 +427 @@
 static void destroyRegisteredThread(void* data) 
 {
-  Collector::Thread* thread = (Collector::Thread*)data;
-
-  // Can't use JSLock convenience object here because we don't want to re-register
-  // an exiting thread.
-  JSLock::lock();
-  
-  if (registeredThreads == thread) {
-    registeredThreads = registeredThreads->next;
-  } else {
-    Collector::Thread *last = registeredThreads;
-    Collector::Thread *t;
-    for (t = registeredThreads->next; t != NULL; t = t->next) {
-      if (t == thread) {          
-          last->next = t->next;
-          break;
-      }
-      last = t;
-    }
-    ASSERT(t); // If t is NULL, we never found ourselves in the list.
-  }
-
-  JSLock::unlock();
-
-  delete thread;
+    Collector::Thread* thread = (Collector::Thread*)data;
+
+    // Can't use JSLock convenience object here because we don't want to re-register
+    // an exiting thread.
+    JSLock::lock();
+
+    if (registeredThreads == thread) {
+        registeredThreads = registeredThreads->next;
+    } else {
+        Collector::Thread* last = registeredThreads;
+        Collector::Thread* t;
+        for (t = registeredThreads->next; t != NULL; t = t->next) {
+            if (t == thread) {          
+                last->next = t->next;
+                break;
+            }
+            last = t;
+        }
+        ASSERT(t); // If t is NULL, we never found ourselves in the list.
+    }
+
+    JSLock::unlock();
+
+    delete thread;
 }
 
 static void initializeRegisteredThreadKey()
 {
-  pthread_key_create(&registeredThreadKey, destroyRegisteredThread);
+    pthread_key_create(&registeredThreadKey, destroyRegisteredThread);
 }
 
 void Collector::registerThread()
 {
-  ASSERT(JSLock::lockCount() > 0);
-  ASSERT(JSLock::currentThreadIsHoldingLock());
-  
-  pthread_once(&registeredThreadKeyOnce, initializeRegisteredThreadKey);
-
-  if (!pthread_getspecific(registeredThreadKey)) {
+    ASSERT(JSLock::lockCount() > 0);
+    ASSERT(JSLock::currentThreadIsHoldingLock());
+
+    pthread_once(&registeredThreadKeyOnce, initializeRegisteredThreadKey);
+
+    if (!pthread_getspecific(registeredThreadKey)) {
 #if PLATFORM(DARWIN)
-      if (onMainThread())
-          CollectorHeapIntrospector::init(&primaryHeap, &numberHeap);
-#endif
-
-    Collector::Thread *thread = new Collector::Thread(pthread_self(), getCurrentPlatformThread(), currentThreadStackBase());
-
-    thread->next = registeredThreads;
-    registeredThreads = thread;
-    pthread_setspecific(registeredThreadKey, thread);
-  }
-}
-
-#endif
-
-#define IS_POINTER_ALIGNED(p) (((intptr_t)(p) & (sizeof(char *) - 1)) == 0)
+        if (onMainThread())
+            CollectorHeapIntrospector::init(&primaryHeap, &numberHeap);
+#endif
+
+        Collector::Thread* thread = new Collector::Thread(pthread_self(), getCurrentPlatformThread(), currentThreadStackBase());
+
+        thread->next = registeredThreads;
+        registeredThreads = thread;
+        pthread_setspecific(registeredThreadKey, thread);
+    }
+}
+
+#endif
+
+#define IS_POINTER_ALIGNED(p) (((intptr_t)(p) & (sizeof(char*) - 1)) == 0)
 
 // cell size needs to be a power of two for this to be valid
 #define IS_HALF_CELL_ALIGNED(p) (((intptr_t)(p) & (CELL_MASK >> 1)) == 0)
 
-void Collector::markStackObjectsConservatively(void *start, void *end)
-{
-  if (start > end) {
-    void* tmp = start;
-    start = end;
-    end = tmp;
-  }
-
-  ASSERT(((char*)end - (char*)start) < 0x1000000);
-  ASSERT(IS_POINTER_ALIGNED(start));
-  ASSERT(IS_POINTER_ALIGNED(end));
-  
-  char** p = (char**)start;
-  char** e = (char**)end;
-    
-  size_t usedPrimaryBlocks = primaryHeap.usedBlocks;
-  size_t usedNumberBlocks = numberHeap.usedBlocks;
-  CollectorBlock **primaryBlocks = primaryHeap.blocks;
-  CollectorBlock **numberBlocks = numberHeap.blocks;
-
-  const size_t lastCellOffset = sizeof(CollectorCell) * (CELLS_PER_BLOCK - 1);
-
-  while (p != e) {
-      char* x = *p++;
-      if (IS_HALF_CELL_ALIGNED(x) && x) {
-          uintptr_t xAsBits = reinterpret_cast<uintptr_t>(x);
-          xAsBits &= CELL_ALIGN_MASK;
-          uintptr_t offset = xAsBits & BLOCK_OFFSET_MASK;
-          CollectorBlock* blockAddr = reinterpret_cast<CollectorBlock*>(xAsBits - offset);
-          // Mark the the number heap, we can mark these Cells directly to avoid the virtual call cost
-          for (size_t block = 0; block < usedNumberBlocks; block++) {
-              if ((numberBlocks[block] == blockAddr) & (offset <= lastCellOffset)) {
-                  Collector::markCell(reinterpret_cast<JSCell*>(xAsBits));
-                  goto endMarkLoop;
-              }
-          }
+void Collector::markStackObjectsConservatively(void* start, void* end)
+{
+    if (start > end) {
+        void* tmp = start;
+        start = end;
+        end = tmp;
+    }
+
+    ASSERT(((char*)end - (char*)start) < 0x1000000);
+    ASSERT(IS_POINTER_ALIGNED(start));
+    ASSERT(IS_POINTER_ALIGNED(end));
+
+    char** p = (char**)start;
+    char** e = (char**)end;
+
+    size_t usedPrimaryBlocks = primaryHeap.usedBlocks;
+    size_t usedNumberBlocks = numberHeap.usedBlocks;
+    CollectorBlock** primaryBlocks = primaryHeap.blocks;
+    CollectorBlock** numberBlocks = numberHeap.blocks;
+
+    const size_t lastCellOffset = sizeof(CollectorCell) * (CELLS_PER_BLOCK - 1);
+
+    while (p != e) {
+        char* x = *p++;
+        if (IS_HALF_CELL_ALIGNED(x) && x) {
+            uintptr_t xAsBits = reinterpret_cast<uintptr_t>(x);
+            xAsBits &= CELL_ALIGN_MASK;
+            uintptr_t offset = xAsBits & BLOCK_OFFSET_MASK;
+            CollectorBlock* blockAddr = reinterpret_cast<CollectorBlock*>(xAsBits - offset);
+            // Mark the the number heap, we can mark these Cells directly to avoid the virtual call cost
+            for (size_t block = 0; block < usedNumberBlocks; block++) {
+                if ((numberBlocks[block] == blockAddr) & (offset <= lastCellOffset)) {
+                    Collector::markCell(reinterpret_cast<JSCell*>(xAsBits));
+                    goto endMarkLoop;
+                }
+            }
           
-          // Mark the primary heap
-          for (size_t block = 0; block < usedPrimaryBlocks; block++) {
-              if ((primaryBlocks[block] == blockAddr) & (offset <= lastCellOffset)) {
-                  if (((CollectorCell*)xAsBits)->u.freeCell.zeroIfFree != 0) {
-                      JSCell* imp = reinterpret_cast<JSCell*>(xAsBits);
-                      if (!imp->marked())
-                          imp->mark();
-                  }
-                  break;
-              }
-          }
-      endMarkLoop:
-          ;
-      }
-  }
+            // Mark the primary heap
+            for (size_t block = 0; block < usedPrimaryBlocks; block++) {
+                if ((primaryBlocks[block] == blockAddr) & (offset <= lastCellOffset)) {
+                    if (((CollectorCell*)xAsBits)->u.freeCell.zeroIfFree != 0) {
+                        JSCell* imp = reinterpret_cast<JSCell*>(xAsBits);
+                        if (!imp->marked())
+                            imp->mark();
+                    }
+                    break;
+                }
+            }
+        endMarkLoop:
+            ;
+        }
+    }
 }
 
@@ -565 +569 @@
 {
 #if PLATFORM(DARWIN)
-  thread_suspend(platformThread);
+    thread_suspend(platformThread);
 #elif PLATFORM(WIN_OS)
-  SuspendThread(platformThread.handle);
+    SuspendThread(platformThread.handle);
 #else
 #error Need a way to suspend threads on this platform
@@ -576 +580 @@
 {
 #if PLATFORM(DARWIN)
-  thread_resume(platformThread);
+    thread_resume(platformThread);
 #elif PLATFORM(WIN_OS)
-  ResumeThread(platformThread.handle);
+    ResumeThread(platformThread.handle);
 #else
 #error Need a way to resume threads on this platform
@@ -611 +615 @@
 
 #if     PLATFORM(X86)
-  unsigned user_count = sizeof(regs)/sizeof(int);
-  thread_state_flavor_t flavor = i386_THREAD_STATE;
+    unsigned user_count = sizeof(regs)/sizeof(int);
+    thread_state_flavor_t flavor = i386_THREAD_STATE;
 #elif   PLATFORM(X86_64)
-  unsigned user_count = x86_THREAD_STATE64_COUNT;
-  thread_state_flavor_t flavor = x86_THREAD_STATE64;
+    unsigned user_count = x86_THREAD_STATE64_COUNT;
+    thread_state_flavor_t flavor = x86_THREAD_STATE64;
 #elif   PLATFORM(PPC) 
-  unsigned user_count = PPC_THREAD_STATE_COUNT;
-  thread_state_flavor_t flavor = PPC_THREAD_STATE;
+    unsigned user_count = PPC_THREAD_STATE_COUNT;
+    thread_state_flavor_t flavor = PPC_THREAD_STATE;
 #elif   PLATFORM(PPC64)
-  unsigned user_count = PPC_THREAD_STATE64_COUNT;
-  thread_state_flavor_t flavor = PPC_THREAD_STATE64;
+    unsigned user_count = PPC_THREAD_STATE64_COUNT;
+    thread_state_flavor_t flavor = PPC_THREAD_STATE64;
 #else
 #error Unknown Architecture
 #endif
 
-  kern_return_t result = thread_get_state(platformThread, flavor, (thread_state_t)&regs, &user_count);
-  if (result != KERN_SUCCESS) {
-    WTFReportFatalError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, 
-                        "JavaScript garbage collection failed because thread_get_state returned an error (%d). This is probably the result of running inside Rosetta, which is not supported.", result);
-    CRASH();
-  }
-  return user_count * sizeof(usword_t);
+    kern_return_t result = thread_get_state(platformThread, flavor, (thread_state_t)&regs, &user_count);
+    if (result != KERN_SUCCESS) {
+        WTFReportFatalError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, 
+                            "JavaScript garbage collection failed because thread_get_state returned an error (%d). This is probably the result of running inside Rosetta, which is not supported.", result);
+        CRASH();
+    }
+    return user_count * sizeof(usword_t);
 // end PLATFORM(DARWIN)
 
 #elif PLATFORM(WIN_OS) && PLATFORM(X86)
-  regs.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL | CONTEXT_SEGMENTS;
-  GetThreadContext(platformThread.handle, &regs);
-  return sizeof(CONTEXT);
+    regs.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL | CONTEXT_SEGMENTS;
+    GetThreadContext(platformThread.handle, &regs);
+    return sizeof(CONTEXT);
 #else
 #error Need a way to get thread registers on this platform
@@ -651 +655 @@
 
 #if PLATFORM(X86)
-  return (void*)regs.__esp;
+    return (void*)regs.__esp;
 #elif PLATFORM(X86_64)
-  return (void*)regs.__rsp;
+    return (void*)regs.__rsp;
 #elif PLATFORM(PPC) || PLATFORM(PPC64)
-  return (void*)regs.__r1;
+    return (void*)regs.__r1;
 #else
 #error Unknown Architecture
@@ -663 +667 @@
 
 #if PLATFORM(X86)
-  return (void*)regs.esp;
+    return (void*)regs.esp;
 #elif PLATFORM(X86_64)
-  return (void*)regs.rsp;
+    return (void*)regs.rsp;
 #elif (PLATFORM(PPC) || PLATFORM(PPC64))
-  return (void*)regs.r1;
+    return (void*)regs.r1;
 #else
 #error Unknown Architecture
@@ -676 +680 @@
 // end PLATFORM(DARWIN)
 #elif PLATFORM(X86) && PLATFORM(WIN_OS)
-  return (void*)(uintptr_t)regs.Esp;
+    return (void*)(uintptr_t)regs.Esp;
 #else
 #error Need a way to get the stack pointer for another thread on this platform
@@ -684 +688 @@
 void Collector::markOtherThreadConservatively(Thread* thread)
 {
-  suspendThread(thread->platformThread);
-
-  PlatformThreadRegisters regs;
-  size_t regSize = getPlatformThreadRegisters(thread->platformThread, regs);
-
-  // mark the thread's registers
-  markStackObjectsConservatively((void*)&regs, (void*)((char*)&regs + regSize));
- 
-  void* stackPointer = otherThreadStackPointer(regs);
-  markStackObjectsConservatively(stackPointer, thread->stackBase);
-
-  resumeThread(thread->platformThread);
+    suspendThread(thread->platformThread);
+
+    PlatformThreadRegisters regs;
+    size_t regSize = getPlatformThreadRegisters(thread->platformThread, regs);
+
+    // mark the thread's registers
+    markStackObjectsConservatively((void*)&regs, (void*)((char*)&regs + regSize));
+
+    void* stackPointer = otherThreadStackPointer(regs);
+    markStackObjectsConservatively(stackPointer, thread->stackBase);
+
+    resumeThread(thread->platformThread);
 }
 
@@ -702 +706 @@
 void Collector::markStackObjectsConservatively()
 {
-  markCurrentThreadConservatively();
+    markCurrentThreadConservatively();
 
 #if USE(MULTIPLE_THREADS)
-  for (Thread *thread = registeredThreads; thread != NULL; thread = thread->next) {
-    if (!pthread_equal(thread->posixThread, pthread_self())) {
-      markOtherThreadConservatively(thread);
-    }
-  }
+    for (Thread* thread = registeredThreads; thread != NULL; thread = thread->next) {
+        if (!pthread_equal(thread->posixThread, pthread_self())) {
+            markOtherThreadConservatively(thread);
+        }
+    }
 #endif
 }
@@ -721 +725 @@
 }
 
-void Collector::protect(JSValue *k)
+void Collector::protect(JSValue* k)
 {
     ASSERT(k);
@@ -728 +732 @@
 
     if (JSImmediate::isImmediate(k))
-      return;
+        return;
 
     protectedValues().add(k->asCell());
 }
 
-void Collector::unprotect(JSValue *k)
+void Collector::unprotect(JSValue* k)
 {
     ASSERT(k);
@@ -740 +744 @@
 
     if (JSImmediate::isImmediate(k))
-      return;
+        return;
 
     protectedValues().remove(k->asCell());
@@ -752 +756 @@
 
     if (JSImmediate::isImmediate(value))
-      return;
+        return;
 
     JSCell* cell = value->asCell();
@@ -761 +765 @@
 void Collector::markProtectedObjects()
 {
-  ProtectCountSet& protectedValues = KJS::protectedValues();
-  ProtectCountSet::iterator end = protectedValues.end();
-  for (ProtectCountSet::iterator it = protectedValues.begin(); it != end; ++it) {
-    JSCell *val = it->first;
-    if (!val->marked())
-      val->mark();
-  }
+    ProtectCountSet& protectedValues = KJS::protectedValues();
+    ProtectCountSet::iterator end = protectedValues.end();
+    for (ProtectCountSet::iterator it = protectedValues.begin(); it != end; ++it) {
+        JSCell* val = it->first;
+        if (!val->marked())
+            val->mark();
+    }
 }
 
@@ -864 +868 @@
             size_t minimumCellsToProcess = usedCells;
             for (size_t i = 0; (i < minimumCellsToProcess) & (i < HeapConstants<heapType>::cellsPerBlock); i++) {
-                Cell *cell = curBlock->cells + i;
+                Cell* cell = curBlock->cells + i;
                 if (cell->u.freeCell.zeroIfFree == 0) {
                     ++minimumCellsToProcess;
@@ -870 +874 @@
                     if (!curBlock->marked.get(i >> HeapConstants<heapType>::bitmapShift)) {
                         if (heapType != Collector::NumberHeap) {
-                            JSCell *imp = reinterpret_cast<JSCell*>(cell);
+                            JSCell* imp = reinterpret_cast<JSCell*>(cell);
                             ASSERT(currentThreadIsMainThread || !curBlock->collectOnMainThreadOnly.get(i));
                             if (curBlock->collectOnMainThreadOnly.get(i)) {
@@ -907 +911 @@
                 if (heap.numBlocks > MIN_ARRAY_SIZE && heap.usedBlocks < heap.numBlocks / LOW_WATER_FACTOR) {
                     heap.numBlocks = heap.numBlocks / GROWTH_FACTOR; 
-                    heap.blocks = (CollectorBlock**)fastRealloc(heap.blocks, heap.numBlocks * sizeof(CollectorBlock *));
+                    heap.blocks = (CollectorBlock**)fastRealloc(heap.blocks, heap.numBlocks * sizeof(CollectorBlock*));
                 }
             }
@@ -924 +928 @@
 bool Collector::collect()
 {
-  ASSERT(JSLock::lockCount() > 0);
-  ASSERT(JSLock::currentThreadIsHoldingLock());
-
-  ASSERT((primaryHeap.operationInProgress == NoOperation) | (numberHeap.operationInProgress == NoOperation));
-  if ((primaryHeap.operationInProgress != NoOperation) | (numberHeap.operationInProgress != NoOperation))
-    abort();
+    ASSERT(JSLock::lockCount() > 0);
+    ASSERT(JSLock::currentThreadIsHoldingLock());
+
+    ASSERT((primaryHeap.operationInProgress == NoOperation) | (numberHeap.operationInProgress == NoOperation));
+    if ((primaryHeap.operationInProgress != NoOperation) | (numberHeap.operationInProgress != NoOperation))
+        abort();
     
-  primaryHeap.operationInProgress = Collection;
-  numberHeap.operationInProgress = Collection;
-
-  bool currentThreadIsMainThread = onMainThread();
-
-  // MARK: first mark all referenced objects recursively starting out from the set of root objects
+    primaryHeap.operationInProgress = Collection;
+    numberHeap.operationInProgress = Collection;
+
+    bool currentThreadIsMainThread = onMainThread();
+
+    // MARK: first mark all referenced objects recursively starting out from the set of root objects
 
 #ifndef NDEBUG
-  // Forbid malloc during the mark phase. Marking a thread suspends it, so 
-  // a malloc inside mark() would risk a deadlock with a thread that had been 
-  // suspended while holding the malloc lock.
-  fastMallocForbid();
-#endif
-
-  markStackObjectsConservatively();
-  markProtectedObjects();
-  List::markProtectedLists();
+    // Forbid malloc during the mark phase. Marking a thread suspends it, so 
+    // a malloc inside mark() would risk a deadlock with a thread that had been 
+    // suspended while holding the malloc lock.
+    fastMallocForbid();
+#endif
+
+    markStackObjectsConservatively();
+    markProtectedObjects();
+    List::markProtectedLists();
 #if USE(MULTIPLE_THREADS)
-  if (!currentThreadIsMainThread)
-    markMainThreadOnlyObjects();
+    if (!currentThreadIsMainThread)
+        markMainThreadOnlyObjects();
 #endif
 
 #ifndef NDEBUG
-  fastMallocAllow();
-#endif
-    
-  size_t originalLiveObjects = primaryHeap.numLiveObjects + numberHeap.numLiveObjects;
-  size_t numLiveObjects = sweep<PrimaryHeap>(currentThreadIsMainThread);
-  numLiveObjects += sweep<NumberHeap>(currentThreadIsMainThread);
+    fastMallocAllow();
+#endif
+
+    size_t originalLiveObjects = primaryHeap.numLiveObjects + numberHeap.numLiveObjects;
+    size_t numLiveObjects = sweep<PrimaryHeap>(currentThreadIsMainThread);
+    numLiveObjects += sweep<NumberHeap>(currentThreadIsMainThread);
   
-  primaryHeap.operationInProgress = NoOperation;
-  numberHeap.operationInProgress = NoOperation;
-  
-  return numLiveObjects < originalLiveObjects;
+    primaryHeap.operationInProgress = NoOperation;
+    numberHeap.operationInProgress = NoOperation;
+
+    return numLiveObjects < originalLiveObjects;
 }
 
 size_t Collector::size() 
 {
-  return primaryHeap.numLiveObjects + numberHeap.numLiveObjects; 
+    return primaryHeap.numLiveObjects + numberHeap.numLiveObjects; 
 }
 
 size_t Collector::globalObjectCount()
 {
-  size_t count = 0;
-  if (JSGlobalObject::head()) {
-    JSGlobalObject* o = JSGlobalObject::head();
-    do {
-      ++count;
-      o = o->next();
-    } while (o != JSGlobalObject::head());
-  }
-  return count;
+    size_t count = 0;
+    if (JSGlobalObject::head()) {
+        JSGlobalObject* o = JSGlobalObject::head();
+        do {
+            ++count;
+            o = o->next();
+        } while (o != JSGlobalObject::head());
+    }
+    return count;
 }
 
 size_t Collector::protectedGlobalObjectCount()
 {
-  size_t count = 0;
-  if (JSGlobalObject::head()) {
-    JSGlobalObject* o = JSGlobalObject::head();
-    do {
-      if (protectedValues().contains(o))
-        ++count;
-      o = o->next();
-    } while (o != JSGlobalObject::head());
-  }
-  return count;
+    size_t count = 0;
+    if (JSGlobalObject::head()) {
+        JSGlobalObject* o = JSGlobalObject::head();
+        do {
+            if (protectedValues().contains(o))
+                ++count;
+            o = o->next();
+        } while (o != JSGlobalObject::head());
+    }
+    return count;
 }
 
 size_t Collector::protectedObjectCount()
 {
-  return protectedValues().size();
-}
-
-static const char *typeName(JSCell *val)
-{
-  const char *name = "???";
-  switch (val->type()) {
-    case UnspecifiedType:
-      break;
-    case UndefinedType:
-      name = "undefined";
-      break;
-    case NullType:
-      name = "null";
-      break;
-    case BooleanType:
-      name = "boolean";
-      break;
-    case StringType:
-      name = "string";
-      break;
-    case NumberType:
-      name = "number";
-      break;
-    case ObjectType: {
-      const ClassInfo *info = static_cast<JSObject *>(val)->classInfo();
-      name = info ? info->className : "Object";
-      break;
-    }
-    case GetterSetterType:
-      name = "gettersetter";
-      break;
-  }
-  return name;
+    return protectedValues().size();
+}
+
+static const char* typeName(JSCell* val)
+{
+    const char* name = "???";
+    switch (val->type()) {
+        case UnspecifiedType:
+            break;
+        case UndefinedType:
+            name = "undefined";
+            break;
+        case NullType:
+            name = "null";
+            break;
+        case BooleanType:
+            name = "boolean";
+            break;
+        case StringType:
+            name = "string";
+            break;
+        case NumberType:
+            name = "number";
+            break;
+        case ObjectType: {
+            const ClassInfo* info = static_cast<JSObject*>(val)->classInfo();
+            name = info ? info->className : "Object";
+            break;
+        }
+        case GetterSetterType:
+            name = "gettersetter";
+            break;
+    }
+    return name;
 }
 

trunk/JavaScriptCore/kjs/collector.h

@@ -1 @@
-// -*- c-basic-offset: 2 -*-
 /*
- *  This file is part of the KDE libraries
  *  Copyright (C) 1999-2000 Harri Porten ([email protected])
  *  Copyright (C) 2001 Peter Kelly ([email protected])
@@ -30 +28 @@
 namespace KJS {
 
-  class JSCell;
-  class JSValue;
-  class CollectorBlock;
-
-  class Collector {
-  public:
-    class Thread;
-    enum HeapType { PrimaryHeap, NumberHeap };
+    class JSCell;
+    class JSValue;
+    class CollectorBlock;
+
+    class Collector {
+    public:
+        class Thread;
+        enum HeapType { PrimaryHeap, NumberHeap };
 
 #ifdef JAVASCRIPTCORE_BUILDING_ALL_IN_ONE_FILE
-    // We can inline these functions because everything is compiled as
-    // one file, so the heapAllocate template definitions are available.
-    // However, allocateNumber is used via jsNumberCell outside JavaScriptCore.
-    // Thus allocateNumber needs to provide a non-inline version too.
-    static void* allocate(size_t s) { return heapAllocate<PrimaryHeap>(s); }
-    static void* inlineAllocateNumber(size_t s) { return heapAllocate<NumberHeap>(s); }
+        // We can inline these functions because everything is compiled as
+        // one file, so the heapAllocate template definitions are available.
+        // However, allocateNumber is used via jsNumberCell outside JavaScriptCore.
+        // Thus allocateNumber needs to provide a non-inline version too.
+        static void* allocate(size_t s) { return heapAllocate<PrimaryHeap>(s); }
+        static void* inlineAllocateNumber(size_t s) { return heapAllocate<NumberHeap>(s); }
 #else
-    static void* allocate(size_t);
+        static void* allocate(size_t);
 #endif
-    static void* allocateNumber(size_t s);
-
-    static bool collect();
-    static bool isBusy(); // true if an allocation or collection is in progress
-
-    static const size_t minExtraCostSize = 256;
-
-    static void reportExtraMemoryCost(size_t cost);
-
-    static size_t size();
-
-    static void protect(JSValue*);
-    static void unprotect(JSValue*);
-    
-    static void collectOnMainThreadOnly(JSValue*);
-
-    static size_t globalObjectCount();
-    static size_t protectedObjectCount();
-    static size_t protectedGlobalObjectCount();
-    static HashCountedSet<const char*>* protectedObjectTypeCounts();
-
-    static void registerThread();
-    
-    static void registerAsMainThread();
-
-    static bool isCellMarked(const JSCell*);
-    static void markCell(JSCell*);
-
-    static void markStackObjectsConservatively(void* start, void* end);
-
-  private:
-    template <Collector::HeapType heapType> static void* heapAllocate(size_t s);
-    template <Collector::HeapType heapType> static size_t sweep(bool);
-    static const CollectorBlock* cellBlock(const JSCell*);
-    static CollectorBlock* cellBlock(JSCell*);
-    static size_t cellOffset(const JSCell*);
-
-    Collector();
-
-    static void recordExtraCost(size_t);
-    static void markProtectedObjects();
-    static void markMainThreadOnlyObjects();
-    static void markCurrentThreadConservatively();
-    static void markCurrentThreadConservativelyInternal();
-    static void markOtherThreadConservatively(Thread*);
-    static void markStackObjectsConservatively();
-
-    static size_t mainThreadOnlyObjectCount;
-    static bool memoryFull;
-  };
-
-  // 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
+        static void* allocateNumber(size_t s);
+
+        static bool collect();
+        static bool isBusy(); // true if an allocation or collection is in progress
+
+        static const size_t minExtraCostSize = 256;
+
+        static void reportExtraMemoryCost(size_t cost);
+
+        static size_t size();
+
+        static void protect(JSValue*);
+        static void unprotect(JSValue*);
+        
+        static void collectOnMainThreadOnly(JSValue*);
+
+        static size_t globalObjectCount();
+        static size_t protectedObjectCount();
+        static size_t protectedGlobalObjectCount();
+        static HashCountedSet<const char*>* protectedObjectTypeCounts();
+
+        static void registerThread();
+        
+        static void registerAsMainThread();
+
+        static bool isCellMarked(const JSCell*);
+        static void markCell(JSCell*);
+
+        static void markStackObjectsConservatively(void* start, void* end);
+
+    private:
+        template <Collector::HeapType heapType> static void* heapAllocate(size_t s);
+        template <Collector::HeapType heapType> static size_t sweep(bool);
+        static const CollectorBlock* cellBlock(const JSCell*);
+        static CollectorBlock* cellBlock(JSCell*);
+        static size_t cellOffset(const JSCell*);
+
+        Collector();
+
+        static void recordExtraCost(size_t);
+        static void markProtectedObjects();
+        static void markMainThreadOnlyObjects();
+        static void markCurrentThreadConservatively();
+        static void markCurrentThreadConservativelyInternal();
+        static void markOtherThreadConservatively(Thread*);
+        static void markStackObjectsConservatively();
+
+        static size_t mainThreadOnlyObjectCount;
+        static bool memoryFull;
+    };
+
+    // 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 SMALL_CELL_SIZE = CELL_SIZE / 2;
+    const size_t CELL_MASK = CELL_SIZE - 1;
+    const size_t CELL_ALIGN_MASK = ~CELL_MASK;
+    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 SMALL_CELLS_PER_BLOCK = 2 * CELLS_PER_BLOCK;
+    const size_t BITMAP_SIZE = (CELLS_PER_BLOCK + 7) / 8;
+    const size_t BITMAP_WORDS = (BITMAP_SIZE + 3) / sizeof(uint32_t);
   
-  // 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 SMALL_CELL_SIZE = CELL_SIZE / 2;
-  const size_t CELL_MASK = CELL_SIZE - 1;
-  const size_t CELL_ALIGN_MASK = ~CELL_MASK;
-  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 SMALL_CELLS_PER_BLOCK = 2 * CELLS_PER_BLOCK;
-  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 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 SmallCollectorCell {
-    union {
-      double memory[CELL_ARRAY_LENGTH / 2];
-      struct {
-        void* zeroIfFree;
-        ptrdiff_t next;
-      } freeCell;
-    } u;
-  };
-
-  class CollectorBlock {
-  public:
-    CollectorCell cells[CELLS_PER_BLOCK];
-    uint32_t usedCells;
-    CollectorCell* freeList;
-    CollectorBitmap marked;
-    CollectorBitmap collectOnMainThreadOnly;
-  };
-
-  class SmallCellCollectorBlock {
-  public:
-    SmallCollectorCell cells[SMALL_CELLS_PER_BLOCK];
-    uint32_t usedCells;
-    SmallCollectorCell* freeList;
-    CollectorBitmap marked;
-    CollectorBitmap collectOnMainThreadOnly;
-  };
-
-  enum OperationInProgress { NoOperation, Allocation, Collection };
-
-  struct CollectorHeap {
-    CollectorBlock** blocks;
-    size_t numBlocks;
-    size_t usedBlocks;
-    size_t firstBlockWithPossibleSpace;
-
-    size_t numLiveObjects;
-    size_t numLiveObjectsAtLastCollect;
-    size_t extraCost;
-
-    OperationInProgress operationInProgress;
-  };
-
-  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));
-  }
-
-  inline void Collector::reportExtraMemoryCost(size_t cost)
-  { 
-    if (cost > minExtraCostSize) 
-      recordExtraCost(cost / (CELL_SIZE * 2)); 
-  }
+    struct CollectorCell {
+        union {
+            double memory[CELL_ARRAY_LENGTH];
+            struct {
+                void* zeroIfFree;
+                ptrdiff_t next;
+            } freeCell;
+        } u;
+    };
+
+    struct SmallCollectorCell {
+        union {
+            double memory[CELL_ARRAY_LENGTH / 2];
+            struct {
+                void* zeroIfFree;
+                ptrdiff_t next;
+            } freeCell;
+        } u;
+    };
+
+    class CollectorBlock {
+    public:
+        CollectorCell cells[CELLS_PER_BLOCK];
+        uint32_t usedCells;
+        CollectorCell* freeList;
+        CollectorBitmap marked;
+        CollectorBitmap collectOnMainThreadOnly;
+    };
+
+    class SmallCellCollectorBlock {
+    public:
+        SmallCollectorCell cells[SMALL_CELLS_PER_BLOCK];
+        uint32_t usedCells;
+        SmallCollectorCell* freeList;
+        CollectorBitmap marked;
+        CollectorBitmap collectOnMainThreadOnly;
+    };
+
+    enum OperationInProgress { NoOperation, Allocation, Collection };
+
+    struct CollectorHeap {
+        CollectorBlock** blocks;
+        size_t numBlocks;
+        size_t usedBlocks;
+        size_t firstBlockWithPossibleSpace;
+
+        size_t numLiveObjects;
+        size_t numLiveObjectsAtLastCollect;
+        size_t extraCost;
+
+        OperationInProgress operationInProgress;
+    };
+
+    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));
+    }
+
+    inline void Collector::reportExtraMemoryCost(size_t cost)
+    {
+        if (cost > minExtraCostSize) 
+            recordExtraCost(cost / (CELL_SIZE * 2)); 
+    }
 
 } // namespace KJS