Changeset 28110 in webkit for trunk/JavaScriptCore/kjs/collector.cpp

Timestamp:

Nov 28, 2007, 5:12:03 AM (18 years ago)

Author:

[email protected]

Message:

Roll out r28106 and r28108. These introduced a frequent assertion failure on page load and broke all non-Mac builds.

File:

• trunk/JavaScriptCore/kjs/collector.cpp (modified) (14 diffs)

trunk/JavaScriptCore/kjs/collector.cpp

@@ -27 +27 @@
 #include "internal.h"
 #include "list.h"
-#include "MarkStack.h"
 #include "value.h"
 #include <algorithm>
@@ -279 +278 @@
     targetBlock = (Block*)allocateBlock();
     targetBlock->freeList = targetBlock->cells;
-    if (heapType == PrimaryHeap)
-        targetBlock->mayHaveRefs = 1;
     targetBlockUsedCells = 0;
     heap.blocks[usedBlocks] = (CollectorBlock*)targetBlock;
@@ -483 +480 @@
 #define IS_HALF_CELL_ALIGNED(p) (((intptr_t)(p) & (CELL_MASK >> 1)) == 0)
 
-static inline void drainMarkStack(MarkStack& stack)
-{
-    while (!stack.isEmpty())
-        stack.pop()->markChildren(stack);
-}
-
-
-void Collector::markStackObjectsConservatively(MarkStack& stack, void *start, void *end)
+void Collector::markStackObjectsConservatively(void *start, void *end)
 {
   if (start > end) {
@@ -532 +522 @@
                   if (((CollectorCell*)xAsBits)->u.freeCell.zeroIfFree != 0) {
                       JSCell* imp = reinterpret_cast<JSCell*>(xAsBits);
-                      stack.push(imp);
-                      drainMarkStack(stack);
+                      if (!imp->marked())
+                          imp->mark();
                   }
                   break;
@@ -544 +534 @@
 }
 
-void Collector::markCurrentThreadConservatively(MarkStack& stack)
+void Collector::markCurrentThreadConservatively()
 {
     // setjmp forces volatile registers onto the stack
@@ -561 +551 @@
     void* stackBase = currentThreadStackBase();
 
-    markStackObjectsConservatively(stack, stackPointer, stackBase);
+    markStackObjectsConservatively(stackPointer, stackBase);
 }
 
@@ -704 +694 @@
 }
 
-void Collector::markOtherThreadConservatively(MarkStack& stack, Thread* thread)
+void Collector::markOtherThreadConservatively(Thread* thread)
 {
   suspendThread(thread->platformThread);
@@ -712 +702 @@
 
   // mark the thread's registers
-  markStackObjectsConservatively(stack, (void*)&regs, (void*)((char*)&regs + regSize));
+  markStackObjectsConservatively((void*)&regs, (void*)((char*)&regs + regSize));
  
   void* stackPointer = otherThreadStackPointer(regs);
   void* stackBase = otherThreadStackBase(regs, thread);
-  markStackObjectsConservatively(stack, stackPointer, stackBase);
+  markStackObjectsConservatively(stackPointer, stackBase);
 
   resumeThread(thread->platformThread);
@@ -723 +713 @@
 #endif
 
-void Collector::markStackObjectsConservatively(MarkStack& stack)
-{
-  markCurrentThreadConservatively(stack);
+void Collector::markStackObjectsConservatively()
+{
+  markCurrentThreadConservatively();
 
 #if USE(MULTIPLE_THREADS)
   for (Thread *thread = registeredThreads; thread != NULL; thread = thread->next) {
     if (!pthread_equal(thread->posixThread, pthread_self())) {
-        markOtherThreadConservatively(stack, thread);
+      markOtherThreadConservatively(thread);
     }
   }
@@ -782 +772 @@
 }
 
-void Collector::markProtectedObjects(MarkStack& stack)
+void Collector::markProtectedObjects()
 {
   ProtectCountSet& protectedValues = KJS::protectedValues();
   ProtectCountSet::iterator end = protectedValues.end();
   for (ProtectCountSet::iterator it = protectedValues.begin(); it != end; ++it) {
-    stack.push(it->first);
-    drainMarkStack(stack);
-  }
-}
-
-void Collector::markMainThreadOnlyObjects(MarkStack& stack)
+    JSCell *val = it->first;
+    if (!val->marked())
+      val->mark();
+  }
+}
+
+void Collector::markMainThreadOnlyObjects()
 {
 #if USE(MULTIPLE_THREADS)
@@ -824 +815 @@
                     if (!curBlock->marked.get(i)) {
                         JSCell* imp = reinterpret_cast<JSCell*>(cell);
-                        stack.push(imp);
-                        drainMarkStack(stack);
+                        imp->mark();
                     }
                     if (++count == mainThreadOnlyObjectCount)
@@ -961 +951 @@
   // MARK: first mark all referenced objects recursively starting out from the set of root objects
 
-  size_t originalLiveObjects = primaryHeap.numLiveObjects + numberHeap.numLiveObjects;
-
-  MarkStack stack;
-  stack.reserveCapacity(primaryHeap.numLiveObjects);
-
 #ifndef NDEBUG
   // Forbid malloc during the mark phase. Marking a thread suspends it, so 
-  // a malloc inside markChildren() would risk a deadlock with a thread that had been 
+  // a malloc inside mark() would risk a deadlock with a thread that had been 
   // suspended while holding the malloc lock.
   fastMallocForbid();
@@ -976 +961 @@
     Interpreter* scr = Interpreter::s_hook;
     do {
-      scr->markRoots(stack);
-      drainMarkStack(stack);
+      scr->mark();
       scr = scr->next;
     } while (scr != Interpreter::s_hook);
   }
 
-  markStackObjectsConservatively(stack);
-  markProtectedObjects(stack);
-  List::markProtectedLists(stack);
-  drainMarkStack(stack);
+  markStackObjectsConservatively();
+  markProtectedObjects();
+  List::markProtectedLists();
 #if USE(MULTIPLE_THREADS)
   if (!currentThreadIsMainThread)
-    markMainThreadOnlyObjects(stack);
+    markMainThreadOnlyObjects();
 #endif
 
@@ -995 +978 @@
 #endif
     
+  size_t originalLiveObjects = primaryHeap.numLiveObjects + numberHeap.numLiveObjects;
   size_t numLiveObjects = sweep<PrimaryHeap>(currentThreadIsMainThread);
   numLiveObjects += sweep<NumberHeap>(currentThreadIsMainThread);