Fix review comments from rb in <https://info.ravenbrook.com/mail/2013/05/23/18-17-17/0/>

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

10 files changed, 100 insertions, 56 deletions

diff --git a/mps/code/abq.c b/mps/code/abq.c
index cee37b32989..aa796057acc 100644
--- a/mps/code/abq.c
+++ b/mps/code/abq.c
@@ -253,10 +253,9 @@ static Bool ABQDispositionCheck(ABQDisposition disposition)
 
 
 /* ABQIterate -- call 'iterate' for each element in an ABQ */
-void ABQIterate(ABQ abq, ABQIterateMethod iterate, void *closureP)
+void ABQIterate(ABQ abq, ABQIterateMethod iterate, void *closureP, Size closureS)
 {
   Index copy, index, in;
-  Res res;
 
   AVERT(ABQ, abq);
   AVER(FUNCHECK(iterate));
@@ -268,7 +267,8 @@ void ABQIterate(ABQ abq, ABQIterateMethod iterate, void *closureP)
   while (index != in) {
     void *element = ABQElement(abq, index);
     ABQDisposition disposition = ABQDispositionNONE;
-    res = (*iterate)(&disposition, element, closureP);
+    Bool cont;
+    cont = (*iterate)(&disposition, element, closureP, closureS);
     AVERT(ABQDisposition, disposition);
     if (disposition == ABQDispositionKEEP) {
       if (copy != index)
@@ -276,7 +276,7 @@ void ABQIterate(ABQ abq, ABQIterateMethod iterate, void *closureP)
       copy = ABQNextIndex(abq, copy);
     }
     index = ABQNextIndex(abq, index);
-    if (res != ResOK)
+    if (!cont)
       break;
   }
 
diff --git a/mps/code/abq.h b/mps/code/abq.h
index b2eb7696923..08462c9192f 100644
--- a/mps/code/abq.h
+++ b/mps/code/abq.h
@@ -25,7 +25,7 @@
 typedef struct ABQStruct *ABQ;
 typedef Res (*ABQDescribeElement)(void *element, mps_lib_FILE *stream);
 typedef unsigned ABQDisposition;
-typedef Res (*ABQIterateMethod)(ABQDisposition *dispositionReturn, void *element, void *closureP);
+typedef Bool (*ABQIterateMethod)(ABQDisposition *dispositionReturn, void *element, void *closureP, Size closureS);
 
 extern Res ABQInit(Arena arena, ABQ abq, void *owner, Count elements, Size elementSize);
 extern Bool ABQCheck(ABQ abq);
@@ -37,7 +37,7 @@ extern Res ABQDescribe(ABQ abq, ABQDescribeElement describeElement, mps_lib_FILE
 extern Bool ABQIsEmpty(ABQ abq);
 extern Bool ABQIsFull(ABQ abq);
 extern Count ABQDepth(ABQ abq);
-extern void ABQIterate(ABQ abq, ABQIterateMethod iterate, void *closureP);
+extern void ABQIterate(ABQ abq, ABQIterateMethod iterate, void *closureP, Size closureS);
 
 
 /* Types */
@@ -60,6 +60,12 @@ typedef struct ABQStruct
 } ABQStruct;
 
 enum {
+  ABQIterationCONTINUE = 1, /* continue iterating */
+  ABQIterationSTOP,         /* stop iterating */
+  ABQIterationNONE          /* no iteration (error) */
+};
+
+enum {
   ABQDispositionKEEP = 1, /* keep item in queue */
   ABQDispositionDELETE,   /* delete element from queue */
   ABQDispositionNONE      /* no disposition (error) */
diff --git a/mps/code/abqtest.c b/mps/code/abqtest.c
index 8d35d99c691..4588af97954 100644
--- a/mps/code/abqtest.c
+++ b/mps/code/abqtest.c
@@ -95,19 +95,19 @@ typedef struct TestClosureStruct {
   Res res;
 } TestClosureStruct;
 
-static Res TestDeleteCallback(ABQDisposition *dispositionReturn, void *element,
-                              void *closureP)
+static Bool TestDeleteCallback(ABQDisposition *dispositionReturn,
+                               void *element, void *closureP, Size closureS)
 {
   TestBlock *a = (TestBlock *)element;
   TestClosure cl = (TestClosure)closureP;
+  UNUSED(closureS);
   if (*a == cl->b) {
     *dispositionReturn = ABQDispositionDELETE;
     cl->res = ResOK;
-    return ResFAIL;
   } else {
     *dispositionReturn = ABQDispositionKEEP;
-    return ResOK;
   }
+  return TRUE;
 }
 
 
@@ -151,7 +151,7 @@ static void step(void)
         cdie(b != NULL, "found to delete");
         cl.b = b;
         cl.res = ResFAIL;
-        ABQIterate(&abq, TestDeleteCallback, &cl);
+        ABQIterate(&abq, TestDeleteCallback, &cl, 0);
         cdie(cl.res == ResOK, "ABQIterate");
       }
   }
diff --git a/mps/code/cbs.c b/mps/code/cbs.c
index 1a1222e6ab0..890957ab871 100644
--- a/mps/code/cbs.c
+++ b/mps/code/cbs.c
@@ -31,9 +31,7 @@ typedef struct CBSBlockStruct {
 
 
 extern Bool CBSBlockCheck(CBSBlock block);
-/* CBSBlockBase -- See <design/cbs/#function.cbs.block.base> */
 #define CBSBlockBase(block) ((block)->base)
-/* CBSBlockLimit -- See <design/cbs/#function.cbs.block.limit> */
 #define CBSBlockLimit(block) ((block)->limit)
 #define CBSBlockSize(block) AddrOffset((block)->base, (block)->limit)
 extern Size (CBSBlockSize)(CBSBlock block);
@@ -89,8 +87,6 @@ Bool CBSCheck(CBS cbs)
 }
 
 
-/* CBSBlockCheck -- See <design/cbs/#function.cbs.block.check> */
-
 Bool CBSBlockCheck(CBSBlock block)
 {
   /* See .enter-leave.simple. */
@@ -106,8 +102,6 @@ Bool CBSBlockCheck(CBSBlock block)
 }
 
 
-/* CBSBlockSize -- see <design/cbs/#function.cbs.block.size> */
-
 Size (CBSBlockSize)(CBSBlock block)
 {
   /* See .enter-leave.simple. */
@@ -220,20 +214,28 @@ static void cbsUpdateNode(SplayTree tree, SplayNode node,
  * See <design/cbs/#function.cbs.init>.
  */
 
-Res CBSInit(Arena arena, CBS cbs, void *owner, Align alignment, Bool fastFind)
+ARG_DEFINE_KEY(cbs_extend_by, Size);
+
+Res CBSInit(Arena arena, CBS cbs, void *owner, Align alignment,
+            Bool fastFind, ArgList args)
 {
+  Size extendBy = CBS_EXTEND_BY_DEFAULT;
+  ArgStruct arg;
   Res res;
 
   AVERT(Arena, arena);
 
+  if (ArgPick(&arg, args, MPS_KEY_CBS_EXTEND_BY))
+    extendBy = arg.val.size;
+
   SplayTreeInit(splayTreeOfCBS(cbs), &cbsSplayCompare,
                 fastFind ? &cbsUpdateNode : NULL);
-  MPS_ARGS_BEGIN(args) {
-    MPS_ARGS_ADD(args, MPS_KEY_MFS_UNIT_SIZE, sizeof(CBSBlockStruct));
-    MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, sizeof(CBSBlockStruct) * 64);
-    MPS_ARGS_DONE(args);
-    res = PoolCreate(&(cbs->blockPool), arena, PoolClassMFS(), args);
-  } MPS_ARGS_END(args);
+  MPS_ARGS_BEGIN(pcArgs) {
+    MPS_ARGS_ADD(pcArgs, MPS_KEY_MFS_UNIT_SIZE, sizeof(CBSBlockStruct));
+    MPS_ARGS_ADD(pcArgs, MPS_KEY_EXTEND_BY, extendBy);
+    MPS_ARGS_DONE(pcArgs);
+    res = PoolCreate(&(cbs->blockPool), arena, PoolClassMFS(), pcArgs);
+  } MPS_ARGS_END(pcArgs);
   if (res != ResOK)
     return res;
   cbs->splayTreeSize = 0;
@@ -395,12 +397,21 @@ static Res cbsInsertIntoTree(Addr *baseReturn, Addr *limitReturn,
   if (res != ResOK)
     goto fail;
 
+  /* The two cases below are not quite symmetrical, because base was
+   * passed into the call to SplayTreeNeighbours(), but limit was not.
+   * So we know that if there is a left neighbour, then leftCBS->limit
+   * <= base (this is ensured by cbsSplayCompare, which is the
+   * comparison method on the splay tree). But if there is a right
+   * neighbour, all we know is that base < rightCBS->base. But for the
+   * range to fit, we need limit <= rightCBS->base too. Hence the extra
+   * check and the possibility of failure in the second case.
+   */
   if (leftSplay == NULL) {
     leftCBS = NULL;
     leftMerge = FALSE;
   } else {
     leftCBS = cbsBlockOfSplayNode(leftSplay);
-    AVER(leftCBS->limit <= base); /* by cbsSplayCompare */
+    AVER(leftCBS->limit <= base);
     leftMerge = leftCBS->limit == base;
   }
 
@@ -424,8 +435,7 @@ static Res cbsInsertIntoTree(Addr *baseReturn, Addr *limitReturn,
       Size oldLeftSize = CBSBlockSize(leftCBS);
       Size oldRightSize = CBSBlockSize(rightCBS);
 
-      /* must block larger neighbour and destroy smaller neighbour; */
-      /* see <design/cbs/#function.cbs.insert.callback> */
+      /* must block larger neighbour and destroy smaller neighbour */
       if (oldLeftSize >= oldRightSize) {
         Addr rightLimit = rightCBS->limit;
         cbsBlockDelete(cbs, rightCBS);
@@ -501,7 +511,7 @@ Res CBSInsert(Addr *baseReturn, Addr *limitReturn,
 }
 
 
-/* cbsDeleteFrom* -- delete blocks from different parts of the CBS */
+/* cbsDeleteFromTree -- delete blocks from the splay tree */
 
 static Res cbsDeleteFromTree(Addr *baseReturn, Addr *limitReturn,
                              CBS cbs, Addr base, Addr limit)
@@ -511,7 +521,13 @@ static Res cbsDeleteFromTree(Addr *baseReturn, Addr *limitReturn,
   SplayNode splayNode;
   Size oldSize;
 
-  /* parameters already checked */
+  AVER(baseReturn != NULL);
+  AVER(limitReturn != NULL);
+  AVERT(CBS, cbs);
+  AVER(base != NULL);
+  AVER(limit > base);
+  AVER(AddrIsAligned(base, cbs->alignment));
+  AVER(AddrIsAligned(limit, cbs->alignment));
 
   METER_ACC(cbs->splaySearch, cbs->splayTreeSize);
   res = SplayTreeSearch(&splayNode, splayTreeOfCBS(cbs), (void *)&base);
@@ -545,8 +561,7 @@ static Res cbsDeleteFromTree(Addr *baseReturn, Addr *limitReturn,
     } else { /* two remaining fragments */
       Size leftNewSize = AddrOffset(cbsBlock->base, base);
       Size rightNewSize = AddrOffset(limit, cbsBlock->limit);
-      /* must shrink larger fragment and create smaller; */
-      /* see <design/cbs/#function.cbs.delete.callback> */
+      /* must shrink larger fragment and create smaller */
       if (leftNewSize >= rightNewSize) {
         Addr oldLimit = cbsBlock->limit;
         AVER(limit < cbsBlock->limit);
@@ -642,7 +657,8 @@ static Res CBSSplayNodeDescribe(SplayNode splayNode, mps_lib_FILE *stream)
  */
 
 /* Internal version without enter/leave checking. */
-static void cbsIterateInternal(CBS cbs, CBSIterateMethod iterate, void *closureP)
+static void cbsIterateInternal(CBS cbs, CBSIterateMethod iterate,
+                               void *closureP, Size closureS)
 {
   SplayNode splayNode;
   SplayTree splayTree;
@@ -658,7 +674,7 @@ static void cbsIterateInternal(CBS cbs, CBSIterateMethod iterate, void *closureP
   splayNode = SplayTreeFirst(splayTree, NULL);
   while(splayNode != NULL) {
     cbsBlock = cbsBlockOfSplayNode(splayNode);
-    if (!(*iterate)(cbs, CBSBlockBase(cbsBlock), CBSBlockLimit(cbsBlock), closureP)) {
+    if (!(*iterate)(cbs, CBSBlockBase(cbsBlock), CBSBlockLimit(cbsBlock), closureP, closureS)) {
       break;
     }
     METER_ACC(cbs->splaySearch, cbs->splayTreeSize);
@@ -667,13 +683,14 @@ static void cbsIterateInternal(CBS cbs, CBSIterateMethod iterate, void *closureP
   return;
 }
 
-void CBSIterate(CBS cbs, CBSIterateMethod iterate, void *closureP)
+void CBSIterate(CBS cbs, CBSIterateMethod iterate,
+                void *closureP, Size closureS)
 {
   AVERT(CBS, cbs);
   AVER(FUNCHECK(iterate));
   CBSEnter(cbs);
 
-  cbsIterateInternal(cbs, iterate, closureP);
+  cbsIterateInternal(cbs, iterate, closureP, closureS);
 
   CBSLeave(cbs);
   return;
diff --git a/mps/code/cbs.h b/mps/code/cbs.h
index 7662c9978ed..4ac99ad8254 100644
--- a/mps/code/cbs.h
+++ b/mps/code/cbs.h
@@ -9,13 +9,15 @@
 #ifndef cbs_h
 #define cbs_h
 
+#include "arg.h"
 #include "meter.h"
 #include "splay.h"
 #include "mpmtypes.h"
 
 
 typedef struct CBSStruct *CBS;
-typedef Bool (*CBSIterateMethod)(CBS cbs, Addr base, Addr limit, void *closureP);
+typedef Bool (*CBSIterateMethod)(CBS cbs, Addr base, Addr limit,
+                                 void *closureP, Size closureS);
 
 
 #define CBSSig ((Sig)0x519CB599) /* SIGnature CBS */
@@ -35,14 +37,15 @@ typedef struct CBSStruct {
 extern Bool CBSCheck(CBS cbs);
 
 extern Res CBSInit(Arena arena, CBS cbs, void *owner,
-                   Align alignment, Bool fastFind);
+                   Align alignment, Bool fastFind, ArgList args);
 extern void CBSFinish(CBS cbs);
 
 extern Res CBSInsert(Addr *baseReturn, Addr *limitReturn,
                      CBS cbs, Addr base, Addr limit);
 extern Res CBSDelete(Addr *baseReturn, Addr *limitReturn,
                      CBS cbs, Addr base, Addr limit);
-extern void CBSIterate(CBS cbs, CBSIterateMethod iterate, void *closureP);
+extern void CBSIterate(CBS cbs, CBSIterateMethod iterate,
+                       void *closureP, Size closureS);
 
 extern Res CBSDescribe(CBS cbs, mps_lib_FILE *stream);
 
diff --git a/mps/code/cbstest.c b/mps/code/cbstest.c
index d4e20df41e8..9a3191530dc 100644
--- a/mps/code/cbstest.c
+++ b/mps/code/cbstest.c
@@ -47,12 +47,14 @@ static Index (indexOfAddr)(Addr block, Addr a)
 }
 
 
-static Bool checkCBSAction(CBS cbs, Addr base, Addr limit, void *p)
+static Bool checkCBSAction(CBS cbs, Addr base, Addr limit, void *closureP,
+                           Size closureS)
 {
-  CheckCBSClosure closure = (CheckCBSClosure)p;
+  CheckCBSClosure closure = (CheckCBSClosure)closureP;
 
   /* Don't need to check cbs every time */
   UNUSED(cbs);
+  UNUSED(closureS);
   Insist(closure != NULL);
 
   if (base > closure->oldLimit) {
@@ -84,7 +86,7 @@ static void checkCBS(CBS cbs, BT allocTable, Addr dummyBlock)
   closure.limit = addrOfIndex(closure.base, ArraySize);
   closure.oldLimit = closure.base;
 
-  CBSIterate(cbs, checkCBSAction, (void *)&closure);
+  CBSIterate(cbs, checkCBSAction, (void *)&closure, 0);
 
   if (closure.oldLimit == closure.base)
     Insist(BTIsSetRange(allocTable, 0,
@@ -409,7 +411,8 @@ extern int main(int argc, char *argv[])
   die((mps_res_t)BTCreate(&allocTable, arena, ArraySize),
       "failed to create alloc table");
 
-  die((mps_res_t)CBSInit(arena, &cbsStruct, NULL, Alignment, TRUE),
+  die((mps_res_t)CBSInit(arena, &cbsStruct, NULL, Alignment, TRUE,
+                         mps_args_none),
       "failed to initialise CBS");
   cbs = &cbsStruct;
 
diff --git a/mps/code/config.h b/mps/code/config.h
index fefd57ed266..70e50169c7d 100644
--- a/mps/code/config.h
+++ b/mps/code/config.h
@@ -238,6 +238,11 @@
 #define EPVMDefaultSubsequentSegSIZE ((Size)64 * 1024)
 
 
+/* CBS Configuration -- see <code/cbs.c> */
+
+#define CBS_EXTEND_BY_DEFAULT ((Size)4096)
+
+
 /* Pool MV Configuration -- see <code/poolmv.c> */
 
 #define MV_EXTEND_BY_DEFAULT  ((Size)65536)
@@ -260,7 +265,7 @@
 #define MVFF_FIRST_FIT_DEFAULT   TRUE
 
 
-/* Pool MVT Configuration -- see <code.poolmv2.c> */
+/* Pool MVT Configuration -- see <code/poolmv2.c> */
 /* FIXME: These numbers were lifted from mv2test and need thought. */
 
 #define MVT_MIN_SIZE_DEFAULT      MPS_PF_ALIGN
diff --git a/mps/code/mps.h b/mps/code/mps.h
index a83c0a9e953..3ea58a26f0f 100644
--- a/mps/code/mps.h
+++ b/mps/code/mps.h
@@ -151,6 +151,9 @@ extern const struct mps_key_s _mps_key_max_size;
 extern const struct mps_key_s _mps_key_align;
 #define MPS_KEY_ALIGN           (&_mps_key_align)
 #define MPS_KEY_ALIGN_FIELD     align
+extern const struct mps_key_s _mps_key_cbs_extend_by;
+#define MPS_KEY_CBS_EXTEND_BY   (&_mps_key_cbs_extend_by)
+#define MPS_KEY_CBS_EXTEND_BY_FIELD size
 
 extern const struct mps_key_s _mps_key_vmw3_top_down;
 #define MPS_KEY_VMW3_TOP_DOWN   (&_mps_key_vmw3_top_down)
diff --git a/mps/code/poolmv2.c b/mps/code/poolmv2.c
index 7333c83f010..f49880023b9 100644
--- a/mps/code/poolmv2.c
+++ b/mps/code/poolmv2.c
@@ -46,9 +46,11 @@ static Bool MVTReturnRangeSegs(MVT mvt, Range range, Arena arena);
 static Res MVTInsert(MVT mvt, Addr base, Addr limit);
 static Res MVTDelete(MVT mvt, Addr base, Addr limit);
 static void ABQRefillIfNecessary(MVT mvt, Size size);
-static Bool ABQRefillCallback(CBS cbs, Addr base, Addr limit, void *closureP);
+static Bool ABQRefillCallback(CBS cbs, Addr base, Addr limit,
+                              void *closureP, Size closureS);
 static Res MVTContingencySearch(Addr *baseReturn, Addr *limitReturn, CBS cbs, Size min);
-static Bool MVTContingencyCallback(CBS cbs, Addr base, Addr limit, void *closureP);
+static Bool MVTContingencyCallback(CBS cbs, Addr base, Addr limit,
+                                   void *closureP, Size closureS);
 static Bool MVTCheckFit(Addr base, Addr limit, Size min, Arena arena);
 static ABQ MVTABQ(MVT mvt);
 static CBS MVTCBS(MVT mvt);
@@ -272,7 +274,7 @@ static Res MVTInit(Pool pool, ArgList args)
   if (abqDepth < 3)
     abqDepth = 3;
 
-  res = CBSInit(arena, MVTCBS(mvt), (void *)mvt, MPS_PF_ALIGN, FALSE);
+  res = CBSInit(arena, MVTCBS(mvt), (void *)mvt, MPS_PF_ALIGN, FALSE, args);
   if (res != ResOK)
     goto failCBS;
  
@@ -590,14 +592,15 @@ done:
  * returns the DELETE disposition for ranges in the ABQ that overlap
  * with it, and the KEEP disposition for ranges that do not.
  */
-static Res MVTDeleteOverlapping(ABQDisposition *dispositionReturn,
-                                void *element, void *closureP)
+static Bool MVTDeleteOverlapping(ABQDisposition *dispositionReturn,
+                                 void *element, void *closureP, Size closureS)
 {
   Range oldRange, newRange;
 
   AVER(dispositionReturn != NULL);
   AVER(element != NULL);
   AVER(closureP != NULL);
+  UNUSED(closureS);
 
   oldRange = element;
   newRange = closureP;
@@ -608,7 +611,7 @@ static Res MVTDeleteOverlapping(ABQDisposition *dispositionReturn,
     *dispositionReturn = ABQDispositionKEEP;
   }
 
-  return ResOK;
+  return TRUE;
 }
 
 
@@ -670,7 +673,7 @@ static Res MVTInsert(MVT mvt, Addr base, Addr limit)
      * with ranges on the ABQ, so ensure that they are removed before
      * reserving the new range.
      */
-    ABQIterate(MVTABQ(mvt), MVTDeleteOverlapping, &range);
+    ABQIterate(MVTABQ(mvt), MVTDeleteOverlapping, &range, 0);
     MVTReserve(mvt, &range);
   }
 
@@ -699,7 +702,7 @@ static Res MVTDelete(MVT mvt, Addr base, Addr limit)
    */
   RangeInit(&range, oldBase, oldLimit);
   if (RangeSize(&range) >= mvt->reuseSize)
-    ABQIterate(MVTABQ(mvt), MVTDeleteOverlapping, &range);
+    ABQIterate(MVTABQ(mvt), MVTDeleteOverlapping, &range, 0);
 
   /* There might be fragments at the left or the right of the deleted
    * range, and either might be big enough to go back on the ABQ.
@@ -1103,7 +1106,7 @@ static void ABQRefillIfNecessary(MVT mvt, Size size)
   if (mvt->abqOverflow && ABQIsEmpty(MVTABQ(mvt))) {
     mvt->abqOverflow = FALSE;
     METER_ACC(mvt->refills, size);
-    CBSIterate(MVTCBS(mvt), &ABQRefillCallback, NULL);
+    CBSIterate(MVTCBS(mvt), &ABQRefillCallback, NULL, 0);
   }
 }
 
@@ -1111,7 +1114,8 @@ static void ABQRefillIfNecessary(MVT mvt, Size size)
 /* ABQRefillCallback -- called from CBSIterate at the behest of
  * ABQRefillIfNecessary
  */
-static Bool ABQRefillCallback(CBS cbs, Addr base, Addr limit, void *closureP)
+static Bool ABQRefillCallback(CBS cbs, Addr base, Addr limit,
+                              void *closureP, Size closureS)
 {
   Res res;
   MVT mvt;
@@ -1124,6 +1128,7 @@ static Bool ABQRefillCallback(CBS cbs, Addr base, Addr limit, void *closureP)
   AVERT(ABQ, MVTABQ(mvt));
   AVER(base < limit);
   UNUSED(closureP);
+  UNUSED(closureS);
 
   size = AddrOffset(base, limit);
   if (size < mvt->reuseSize)
@@ -1167,7 +1172,7 @@ static Res MVTContingencySearch(Addr *baseReturn, Addr *limitReturn, CBS cbs, Si
   cls.steps = 0;
   cls.hardSteps = 0;
  
-  CBSIterate(cbs, MVTContingencyCallback, (void *)&cls);
+  CBSIterate(cbs, MVTContingencyCallback, (void *)&cls, 0);
   if (cls.found) {
     AVER(AddrOffset(cls.base, cls.limit) >= min);
     METER_ACC(CBSMVT(cbs)->contingencySearches, cls.steps);
@@ -1186,7 +1191,8 @@ static Res MVTContingencySearch(Addr *baseReturn, Addr *limitReturn, CBS cbs, Si
 /* MVTContingencyCallback -- called from CBSIterate at the behest of
  * MVTContingencySearch
  */
-static Bool MVTContingencyCallback(CBS cbs, Addr base, Addr limit, void *closureP)
+static Bool MVTContingencyCallback(CBS cbs, Addr base, Addr limit,
+                                   void *closureP, Size closureS)
 {
   MVTContigency cl;
   Size size;
@@ -1194,6 +1200,7 @@ static Bool MVTContingencyCallback(CBS cbs, Addr base, Addr limit, void *closure
   AVERT(CBS, cbs);
   AVER(base < limit);
   AVER(closureP != NULL);
+  UNUSED(closureS);
 
   cl = (MVTContigency)closureP;
   size = AddrOffset(base, limit);
diff --git a/mps/code/poolmvff.c b/mps/code/poolmvff.c
index 0c5ba896887..f557a4e4da7 100644
--- a/mps/code/poolmvff.c
+++ b/mps/code/poolmvff.c
@@ -521,7 +521,7 @@ static Res MVFFInit(Pool pool, ArgList args)
   mvff->total = 0;
   mvff->free = 0;
 
-  res = CBSInit(arena, CBSOfMVFF(mvff), (void *)mvff, align, TRUE);
+  res = CBSInit(arena, CBSOfMVFF(mvff), (void *)mvff, align, TRUE, args);
   if (res != ResOK)
     goto failInit;