issue #139 merge gc related changes

include/lgc.h

@@ -119,10 +119,20 @@
 
 /* Default Values for GC parameters */
 #define LUAI_GENMAJORMUL         100
-#define LUAI_GENMINORMUL         5
+#define LUAI_GENMINORMUL         12
 
-#define LUAI_GCPAUSE    100     /* 100% */
-#define LUAI_GCMUL      10
+/* wait memory to double before starting new cycle */
+#define LUAI_GCPAUSE    200     /* 200% */
+
+/*
+** gc parameters ae stored divided by 4 to allow a maximum value larger
+** than 1000 in an 'lu_byte'.
+*/
+
+#define getgcparam(p)	((p) * 4)
+#define setgcparam(p,v)	((p) = (v) / 4)
+
+#define LUAI_GCMUL      100
 /* how much to allocate before next GC step (log2) */
 #define LUAI_GCSTEPSIZE 13      /* 8 KB */
 

src/lapi.c

@@ -1406,14 +1406,14 @@ LUA_API int lua_gc (lua_State *L, int what, ...) {
     }
     case LUA_GCSETPAUSE: {
       int data = va_arg(argp, int);
-      res = g->gcpause + 100;
-      g->gcpause = (data >= 100) ? data - 100 : 0;
+      res = getgcparam(g->gcpause);
+      setgcparam(g->gcpause, data);
       break;
     }
     case LUA_GCSETSTEPMUL: {
       int data = va_arg(argp, int);
-      res = g->gcstepmul * 10;
-      g->gcstepmul = data / 10;
+      res = getgcparam(g->gcstepmul);
+      setgcparam(g->gcstepmul, data);
       break;
     }
     case LUA_GCISRUNNING: {
@@ -1423,8 +1423,10 @@ LUA_API int lua_gc (lua_State *L, int what, ...) {
     case LUA_GCGEN: {
       int minormul = va_arg(argp, int);
       int majormul = va_arg(argp, int);
-      g->genminormul = (minormul == 0) ? LUAI_GENMINORMUL : minormul;
-      g->genmajormul = (majormul == 0) ? LUAI_GENMAJORMUL : majormul;
+      if (minormul != 0)
+        g->genminormul = minormul;
+      if (majormul != 0)
+        setgcparam(g->genmajormul, majormul);
       luaC_changemode(L, KGC_GEN);
       break;
     }
@@ -1432,9 +1434,12 @@ LUA_API int lua_gc (lua_State *L, int what, ...) {
       int pause = va_arg(argp, int);
       int stepmul = va_arg(argp, int);
       int stepsize = va_arg(argp, int);
-      g->gcpause = (pause == 0) ? LUAI_GCPAUSE : pause;
-      g->gcstepmul = (stepmul == 0) ? LUAI_GCMUL : stepmul;
-      g->gcstepsize = (stepsize == 0) ? LUAI_GCSTEPSIZE : stepsize;
+      if (pause != 0)
+        setgcparam(g->gcpause, pause);
+      if (stepmul != 0)
+        setgcparam(g->gcstepmul, stepmul);
+      if (stepsize != 0)
+        g->gcstepsize = stepsize;
       luaC_changemode(L, KGC_INC);
       break;
     }

src/lgc.c

@@ -1260,14 +1260,14 @@ static void fullgen (lua_State *L, global_State *g) {
 ** than last major collection (kept in 'g->GCestimate'), does a major
 ** collection. Otherwise, does a minor collection and set debt to make
 ** another collection when memory grows 'genminormul'% larger.
-** 'GCdebt <= 0' means an explicity call to GC step with "size" zero;
+** 'GCdebt <= 0' means an explicit call to GC step with "size" zero;
 ** in that case, always do a minor collection.
 */
 static void genstep (lua_State *L, global_State *g) {
   lu_mem majorbase = g->GCestimate;
-//lua_checkmemory(L);
+  int majormul = getgcparam(g->genmajormul);
   if (g->GCdebt > 0 &&
-      gettotalbytes(g) > (majorbase / 100) * (100 + g->genmajormul)) {
+      gettotalbytes(g) > (majorbase / 100) * (100 + majormul)) {
     fullgen(L, g);
   }
   else {
@@ -1277,7 +1277,6 @@ static void genstep (lua_State *L, global_State *g) {
     luaE_setdebt(g, -((mem / 100) * g->genminormul));
     g->GCestimate = majorbase;  /* preserve base value */
   }
-//lua_checkmemory(L);
 }
 
 /* }====================================================== */
@@ -1298,7 +1297,7 @@ static void genstep (lua_State *L, global_State *g) {
 */
 static void setpause (global_State *g) {
   l_mem threshold, debt;
-  int pause = g->gcpause + 100;
+  int pause = getgcparam(g->gcpause);
   l_mem estimate = g->GCestimate / PAUSEADJ;  /* adjust 'estimate' */
   lua_assert(estimate > 0);
   threshold = (pause < MAX_LMEM / estimate)  /* overflow? */
@@ -1486,16 +1485,16 @@ void luaC_runtilstate (lua_State *L, int statesmask) {
 ** controls when next step will be performed.
 */
 static void incstep (lua_State *L, global_State *g) {
-  int stepmul = (g->gcstepmul | 1);  /* avoid division by 0 */
+  int stepmul = (getgcparam(g->gcstepmul) | 1);  /* avoid division by 0 */
   l_mem debt = (g->GCdebt / WORK2MEM) * stepmul;
   l_mem stepsize = (g->gcstepsize <= log2maxs(l_mem))
-                   ? cast(l_mem, 1) << g->gcstepsize
-                   : MAX_LMEM;
+                   ? ((cast(l_mem, 1) << g->gcstepsize) / WORK2MEM) * stepmul
+                   : MAX_LMEM;  /* overflow; keep maximum value */
   stepsize = -((stepsize / WORK2MEM) * stepmul);
   do {  /* repeat until pause or enough "credit" (negative debt) */
     lu_mem work = singlestep(L);  /* perform one single step */
     debt -= work;
-  } while (debt > stepsize && g->gcstate != GCSpause);
+  } while (debt > -stepsize && g->gcstate != GCSpause);
   if (g->gcstate == GCSpause)
     setpause(g);  /* pause until next cycle */
   else {

src/lstate.c

@@ -369,9 +369,11 @@ LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
   g->twups = NULL;
   g->totalbytes = sizeof(LG);
   g->GCdebt = 0;
-  g->gcpause = LUAI_GCPAUSE;
-  g->gcstepmul = LUAI_GCMUL;
+  setgcparam(g->gcpause, LUAI_GCPAUSE);
+  setgcparam(g->gcstepmul, LUAI_GCMUL);
   g->gcstepsize = LUAI_GCSTEPSIZE;
+  setgcparam(g->genmajormul, LUAI_GENMAJORMUL);
+  g->genminormul = LUAI_GENMINORMUL;
   g->ravi_state = NULL;
   for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
   raviV_initjit(L);