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

Timestamp:

Mar 21, 2002, 4:31:57 PM (23 years ago)

Author:

mjs

Message:

Merged changes from LABYRINTH_KDE_3_MERGE branch.

File:

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

trunk/JavaScriptCore/kjs/collector.cpp

@@ +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])
  *
  *  This library is free software; you can redistribute it and/or
@@ -16 +18 @@
  *  License along with this library; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *  $Id$
  */
 
 #include "collector.h"
-#include "object.h"
 #include "internal.h"
 
@@ -25 +28 @@
 #include <string.h>
 #include <assert.h>
+#ifdef KJS_DEBUG_MEM
+#include <typeinfo>
+#endif
 
 namespace KJS {
@@ -62 +68 @@
 unsigned long Collector::filled = 0;
 unsigned long Collector::softLimit = KJS_MEM_INCREMENT;
+
+unsigned long Collector::timesFilled = 0;
+unsigned long Collector::increaseLimitAt = 1;
+
+bool Collector::memLimitReached = false;
+
 #ifdef KJS_DEBUG_MEM
 bool Collector::collecting = false;
@@ -71 +83 @@
     return 0L;
 
+  // Try and deal with memory requirements in a scalable way. Simple scripts
+  // should only require small amounts of memory, but for complex scripts we don't
+  // want to end up running the garbage collector hundreds of times a second.
   if (filled >= softLimit) {
+    timesFilled++;
     collect();
-    if (filled >= softLimit && softLimit < KJS_MEM_LIMIT) // we are actually using all this memory
+
+    if (filled >= softLimit && softLimit < KJS_MEM_LIMIT) {
+      // Even after collection we are still using more than the limit, so increase
+      // the limit
       softLimit *= 2;
+    }
+    else if (timesFilled == increaseLimitAt && increaseLimitAt < 128) {
+      // The allowed memory limit keeps getting reached (lots of objects created
+      // and deleted). Increase it a bit so GC gets run less often.
+      timesFilled = 0;
+      softLimit *= 2;
+      increaseLimitAt *= 2;
+    }
   }
 
   void *m = malloc(s);
-
-  // hack to ensure obj is protected from GC before any constructors are run
-  // (prev = marked, next = gcallowed)
-  static_cast<Imp*>(m)->prev = 0;
-  static_cast<Imp*>(m)->next = 0;
+#ifdef KJS_DEBUG_MEM
+  //fprintf( stderr, "allocate: size=%d valueimp=%p\n",s,m);
+#endif
+
+  // VI_CREATED and VI_GCALLOWED being unset ensure that value
+  // is protected from GC before any constructors are run
+  static_cast<ValueImp*>(m)->_flags = 0;
 
   if (!root) {
@@ -99 +128 @@
   if (block->filled >= block->size) {
 #ifdef KJS_DEBUG_MEM
-    printf("allocating new block of size %d\n", block->size);
+    //fprintf( stderr, "allocating new block of size %d\n", block->size);
 #endif
     CollectorBlock *tmp = new CollectorBlock(BlockSize);
@@ -116 +145 @@
 
   if (softLimit >= KJS_MEM_LIMIT) {
-      KJScriptImp::setException("Out of memory");
+    memLimitReached = true;
+    fprintf(stderr,"Out of memory");
   }
 
@@ -125 +155 @@
  * Mark-sweep garbage collection.
  */
-void Collector::collect()
-{
-#ifdef KJS_DEBUG_MEM
-  printf("collecting %d objects total\n", Imp::count);
-  collecting = true;
-#endif
-
-  // MARK: first set all ref counts to 0 ....
+bool Collector::collect()
+{
+#ifdef KJS_DEBUG_MEM
+  fprintf(stderr,"Collector::collect()\n");
+#endif
+  bool deleted = false;
+  // MARK: first unmark everything
   CollectorBlock *block = root;
   while (block) {
-#ifdef KJS_DEBUG_MEM
-    printf("cleaning block filled %d out of %d\n", block->filled, block->size);
-#endif
-    Imp **r = (Imp**)block->mem;
+    ValueImp **r = (ValueImp**)block->mem;
     assert(r);
     for (int i = 0; i < block->size; i++, r++)
       if (*r) {
-        (*r)->setMarked(false);
-      }
-    block = block->next;
-  }
-
-  // ... increase counter for all referenced objects recursively
+        (*r)->_flags &= ~ValueImp::VI_MARKED;
+      }
+    block = block->next;
+  }
+
+  // mark all referenced objects recursively
   // starting out from the set of root objects
-  if (KJScriptImp::hook) {
-    KJScriptImp *scr = KJScriptImp::hook;
+  if (InterpreterImp::s_hook) {
+    InterpreterImp *scr = InterpreterImp::s_hook;
     do {
+      //fprintf( stderr, "Collector marking interpreter %p\n",(void*)scr);
       scr->mark();
       scr = scr->next;
-    } while (scr != KJScriptImp::hook);
+    } while (scr != InterpreterImp::s_hook);
   }
 
@@ -160 +187 @@
   block = root;
   while (block) {
-    Imp **r = (Imp**)block->mem;
+    ValueImp **r = (ValueImp**)block->mem;
     assert(r);
     for (int i = 0; i < block->size; i++, r++)
-      if (*r && (*r)->created() && ((*r)->refcount || !(*r)->gcAllowed()) && !(*r)->marked())
-        (*r)->mark();
+    {
+      ValueImp *imp = (*r);
+      // Check for created=true, marked=false and (gcallowed=false or refcount>0)
+      if (imp &&
+          (imp->_flags & (ValueImp::VI_CREATED|ValueImp::VI_MARKED)) == ValueImp::VI_CREATED &&
+          ( (imp->_flags & ValueImp::VI_GCALLOWED) == 0 || imp->refcount ) ) {
+        //fprintf( stderr, "Collector marking imp=%p\n",(void*)imp);
+        imp->mark();
+      }
+    }
     block = block->next;
   }
@@ -171 +206 @@
   block = root;
   while (block) {
-    Imp **r = (Imp**)block->mem;
+    ValueImp **r = (ValueImp**)block->mem;
     int del = 0;
     for (int i = 0; i < block->size; i++, r++) {
-      if (*r && ((*r)->refcount == 0) && !(*r)->marked() && (*r)->gcAllowed()) {
-        // emulate destructing part of 'operator delete()'
-        (*r)->~Imp();
-        free(*r);
-        *r = 0L;
-        del++;
+      ValueImp *imp = (*r);
+      // Can delete if refcount==0, created==true, gcAllowed==true, and marked==false
+      // Make sure to update the test if you add more bits to _flags.
+      if (imp &&
+          !imp->refcount && imp->_flags == (ValueImp::VI_GCALLOWED | ValueImp::VI_CREATED)) {
+        // emulate destructing part of 'operator delete()'
+        //fprintf( stderr, "Collector::deleting ValueImp %p (%s)\n", (void*)imp, typeid(*imp).name());
+        imp->~ValueImp();
+        free(imp);
+        *r = 0L;
+        del++;
       }
     }
@@ -185 +225 @@
     block->filled -= del;
     block = block->next;
-  }
-
-  // delete the emtpy containers
+    if (del)
+      deleted = true;
+  }
+
+  // delete the empty containers
   block = root;
   while (block) {
@@ -193 +235 @@
     if (block->filled == 0) {
       if (block->prev)
-        block->prev->next = next;
+        block->prev->next = next;
       if (block == root)
-        root = next;
+        root = next;
       if (next)
-        next->prev = block->prev;
+        next->prev = block->prev;
       if (block == currentBlock) // we don't want a dangling pointer
-        currentBlock = 0L;
+        currentBlock = 0L;
       assert(block != root);
       delete block;
@@ -205 +247 @@
     block = next;
   }
-
-#ifdef KJS_DEBUG_MEM
-  collecting = false;
-#endif
-}
+#if 0
+  // This is useful to track down memory leaks
+  static int s_count = 0;
+  fprintf(stderr, "Collector done (was run %d)\n",s_count);
+  if (s_count++ % 50 == 2)
+    finalCheck();
+#endif
+  return deleted;
+}
+
+#ifdef KJS_DEBUG_MEM
+void Collector::finalCheck()
+{
+  CollectorBlock *block = root;
+  while (block) {
+    ValueImp **r = (ValueImp**)block->mem;
+    for (int i = 0; i < block->size; i++, r++) {
+      if (*r ) {
+        fprintf( stderr, "Collector::finalCheck() still having ValueImp %p (%s)  [marked:%d gcAllowed:%d created:%d refcount:%d]\n",
+                 (void*)(*r), typeid( **r ).name(),
+                 (bool)((*r)->_flags & ValueImp::VI_MARKED),
+                 (bool)((*r)->_flags & ValueImp::VI_GCALLOWED),
+                 (bool)((*r)->_flags & ValueImp::VI_CREATED),
+                 (*r)->refcount);
+      }
+    }
+    block = block->next;
+  }
+}
+#endif