Mps: attempt to account for condemned in the poolgen

Copied from Perforce
 Change: 162966
 ServerID: perforce.ravenbrook.com

3 files changed, 97 insertions, 16 deletions

diff --git a/mps/code/chain.h b/mps/code/chain.h
index 785c25e2349..b0dc016212b 100644
--- a/mps/code/chain.h
+++ b/mps/code/chain.h
@@ -1,7 +1,7 @@
 /* chain.h: GENERATION CHAINS
  *
  * $Id$
- * Copyright (c) 2001 Ravenbrook Limited.  See end of file for license.
+ * Copyright (c) 2001-2007 Ravenbrook Limited.  See end of file for license.
  */
 
 #ifndef chain_h
@@ -44,19 +44,22 @@ typedef struct PoolGenStruct *PoolGen;
 
 typedef struct PoolGenStruct {
   Sig sig;
-  Serial nr;          /* generation number */
-  Pool pool;          /* pool this belongs to */
-  Chain chain;        /* chain this belongs to */
+  Serial nr;            /* generation number */
+  Pool pool;            /* pool this belongs to */
+  Chain chain;          /* chain this belongs to */
   /* link in ring of all PoolGen's in this GenDesc (locus) */
   RingStruct genRing;
-  Size totalSize;     /* total size of segs in gen in this pool */
-  Size newSize;       /* size allocated since last GC */
+  Size totalSize;       /* total size of segs in gen in this pool */
+  /* Size of new objects in this gen.  That is objects that have */
+  /* never been condemned (whilst they were in this generation). */
+  Size newSize;
   /* newSize when TraceCreate is called.  This is for diagnostic */
   /* purposes only.  It's used in a DIAG message emitted in TraceStart; */
   /* at that time, newSize has already been diminished by Whiten so we */
   /* can't use that value.  This will not work well with multiple */
   /* traces. */
   Size newSizeAtCreate;
+  Size condemned;       /* total size of condemned objects */
 } PoolGenStruct;
 
 
@@ -90,6 +93,8 @@ extern size_t ChainGens(Chain chain);
 extern Bool PoolGenCheck(PoolGen gen);
 extern Res PoolGenInit(PoolGen gen, Chain chain, Serial nr, Pool pool);
 extern void PoolGenFinish(PoolGen gen);
+extern void PoolGenNoteCondemned(PoolGen, Size, Size, Size, Size);
+extern void PoolGenNoteReclaimed(PoolGen, Size, Size, Size, Size);
 extern void PoolGenFlip(PoolGen gen);
 #define PoolGenNr(gen) ((gen)->nr)
 extern void PoolGenUpdateZones(PoolGen gen, Seg seg);
@@ -100,7 +105,7 @@ extern void PoolGenUpdateZones(PoolGen gen, Seg seg);
 
 /* C. COPYRIGHT AND LICENSE
  *
- * Copyright (C) 2001-2002 Ravenbrook Limited <http://www.ravenbrook.com/>.
+ * Copyright (C) 2001-2007 Ravenbrook Limited <http://www.ravenbrook.com/>.
  * All rights reserved.  This is an open source license.  Contact
  * Ravenbrook for commercial licensing options.
  * 
diff --git a/mps/code/locus.c b/mps/code/locus.c
index 4f3be3d6f30..943903baff4 100644
--- a/mps/code/locus.c
+++ b/mps/code/locus.c
@@ -377,6 +377,7 @@ Res PoolGenInit(PoolGen gen, Chain chain, Serial nr, Pool pool)
   RingInit(&gen->genRing);
   gen->totalSize = (Size)0;
   gen->newSize = (Size)0;
+  gen->condemned = (Size)0;
   gen->sig = PoolGenSig;
 
   if(nr != chain->genCount) {
@@ -411,9 +412,71 @@ Bool PoolGenCheck(PoolGen gen)
   CHECKU(Chain, gen->chain);
   CHECKL(RingCheck(&gen->genRing));
   CHECKL(gen->newSize <= gen->totalSize);
+  CHECKL(gen->condemned <= gen->totalSize);
+  CHECKL(gen->newSize + gen->condemned <= gen->totalSize);
   return TRUE;
 }
 
+/* PoolGenNoteCondemned -- maintain accounting of condemned stuff.
+ *
+ * Arguments:
+ *   newlyCondemned - number of bytes of objects that are condemned and
+ *     have never been condemned before (in this location).
+ *   againCondemned - number of bytes of objects that are condemned that
+ *     have been condemned before.
+ *  notCondemned - number of bytes of objects that are not condemned.
+ *  free - number of bytes that are free (that is, not objects, and
+ *     available for future allocation).
+ *
+ *  It is expected that some pools may not be able to maintain accurate
+ *  accounting information and that they therefore will record stuff in
+ *  the "againCondemned" category that should have gone in
+ *  newlyCondemned or free (and will report those categories as free).
+ */
+
+void PoolGenNoteCondemned(PoolGen gen,
+  Size newlyCondemned,
+  Size againCondemned, 
+  Size notCondemned,
+  Size free)
+{
+  AVERT(PoolGen, gen);
+  /* In fact, no current pool uses free.  So it's always 0. */
+  AVER(free == 0);
+
+  gen->newSize -= newlyCondemned;
+  gen->condemned += newlyCondemned + againCondemned;
+  return;
+}
+
+/* PoolGenNoteReclaimed -- maintain accounting of reclaimed stuff.
+ *
+ * Arguments:
+ *   free - number of bytes that were free already, prior to the call to
+ *     reclaim. (should be be "and not reported as free in Whiten with a
+ *     call to PoolGenNoteCondemned).
+ *   reclaimed - number of bytes that become free as part of reclaim
+ *     (previously not free, but now are).  Note: do not count unmapped
+ *     bytes here.
+ *   retained - number of bytes of objects that are still considered
+ *     reachable after the reclaim.
+ *   unmapped - number of bytes that have been unmapped.
+ */
+
+void PoolGenNoteReclaimed(PoolGen gen,
+  Size free, Size reclaimed, Size retained, Size unmapped)
+{
+  Size sum;
+
+  AVER(gen->totalSize >= unmapped);
+  gen->totalSize -= unmapped;
+
+  sum = free + reclaimed + retained + unmapped;
+  AVER(gen->condemned >= sum);
+  gen->condemned -= sum;
+  return;
+}
+
 
 /* PoolGenUpdateZones -- update the zone of the generation
  *
diff --git a/mps/code/poolamc.c b/mps/code/poolamc.c
index 1a2d2019509..fd3db0a78f1 100644
--- a/mps/code/poolamc.c
+++ b/mps/code/poolamc.c
@@ -1188,11 +1188,17 @@ static Res AMCWhiten(Pool pool, Trace trace, Seg seg)
   AMC amc;
   Buffer buffer;
   Res res;
+  /* Sizes, in bytes, of stuff that is condemned and not-condemned */
+  /* (normally everything is condemned, but not for buffers). */
+  Size condemned, notcondemned;
 
   AVERT(Pool, pool);
   AVERT(Trace, trace);
   AVERT(Seg, seg);
 
+  condemned = SegSize(seg);
+  notcondemned = 0;
+
   buffer = SegBuffer(seg);
   if(buffer != NULL) {
     AVERT(Buffer, buffer);
@@ -1242,23 +1248,28 @@ static Res AMCWhiten(Pool pool, Trace trace, Seg seg)
           SegSetNailed(seg, TraceSetAdd(SegNailed(seg), trace));
         }
         /* We didn't condemn the buffer, subtract it from the count. */
+#if 0
+        notcondemned = AddrOffset(BufferScanLimit(buffer),
+                                  BufferLimit(buffer));
+        condemned -= notcondemned;
+#endif
         /* @@@@ We could subtract all the nailed grains. */
-        /* Relies on unsigned arithmetic wrapping round */
-        /* on under- and overflow (which it does). */
-        trace->condemned -= AddrOffset(BufferScanLimit(buffer),
-                                       BufferLimit(buffer));
       }
     }
   }
 
   SegSetWhite(seg, TraceSetAdd(SegWhite(seg), trace));
-  trace->condemned += SegSize(seg);
+  trace->condemned += condemned;
 
   gen = amcSegGen(seg);
   AVERT(amcGen, gen);
+
+  /* Report accounting to PoolGen. */
   if(Seg2amcSeg(seg)->new) {
-    gen->pgen.newSize -= SegSize(seg);
+    PoolGenNoteCondemned(&gen->pgen, condemned, 0, notcondemned, 0);
     Seg2amcSeg(seg)->new = FALSE;
+  } else {
+    PoolGenNoteCondemned(&gen->pgen, 0, condemned, notcondemned, 0);
   }
 
   /* Ensure we are forwarding into the right generation. */
@@ -1896,7 +1907,7 @@ returnRes:
 
 /* amcReclaimNailed -- reclaim what you can from a nailed segment */
 
-static void amcReclaimNailed(Pool pool, Trace trace, Seg seg)
+static void amcReclaimNailed(Pool pool, Trace trace, Seg seg, amcGen gen)
 {
   Addr p, limit;
   Arena arena;
@@ -1961,6 +1972,8 @@ static void amcReclaimNailed(Pool pool, Trace trace, Seg seg)
   trace->reclaimSize += bytesReclaimed;
   trace->preservedInPlaceCount += preservedInPlaceCount;
   trace->preservedInPlaceSize += preservedInPlaceSize;
+  PoolGenNoteReclaimed(&gen->pgen, 0, 0, SegSize(seg), 0);
+  return;
 }
 
 
@@ -1997,13 +2010,13 @@ static void AMCReclaim(Pool pool, Trace trace, Seg seg)
   }
 
   if(SegNailed(seg) != TraceSetEMPTY) {
-    amcReclaimNailed(pool, trace, seg);
+    amcReclaimNailed(pool, trace, seg, gen);
     return;
   }
 
   --gen->segs;
   size = SegSize(seg);
-  gen->pgen.totalSize -= size;
+  PoolGenNoteReclaimed(&gen->pgen, 0, 0, 0, size);
 
   trace->reclaimSize += size;