Lua 5.2.1-rc3

Lua Team committed 14 years ago

Commit daa74971 parent b19ccd47 files · +114 −85Browse files

Showing the changes to src (4 of 7 files). Show all

Unified · Split

4 files

src/lauxlib.c +3 −3
src/lgc.c +59 −28
src/loadlib.c +3 −3
src/lstate.c +2 −2

 /*
-** $Id: lauxlib.c,v 1.243 2012/04/20 17:05:17 roberto Exp $
+** $Id: lauxlib.c,v 1.244 2012/05/31 20:28:45 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 LUALIB_API int luaL_ref (lua_State *L, int t) {
   int ref;
-  t = lua_absindex(L, t);
   if (lua_isnil(L, -1)) {
     lua_pop(L, 1);  /* remove from stack */
     return LUA_REFNIL;  /* `nil' has a unique fixed reference */
   }
+  t = lua_absindex(L, t);
   lua_rawgeti(L, t, freelist);  /* get first free element */
   ref = (int)lua_tointeger(L, -1);  /* ref = t[freelist] */
   lua_pop(L, 1);  /* remove it from stack */
   lua_getfield(L, idx, fname);
   if (lua_istable(L, -1)) return 1;  /* table already there */
   else {
-    idx = lua_absindex(L, idx);
     lua_pop(L, 1);  /* remove previous result */
+    idx = lua_absindex(L, idx);
     lua_newtable(L);
     lua_pushvalue(L, -1);  /* copy to be left at top */
     lua_setfield(L, idx, fname);  /* assign new table to field */

src/lgc.c+59−28

 /*
-** $Id: lgc.c,v 2.129 2012/05/28 20:41:00 roberto Exp $
+** $Id: lgc.c,v 2.133 2012/05/31 21:28:59 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
   return (*p == NULL) ? NULL : p;
 }
+/*
+** sweep a list until a live object (or end of list)
+*/
+static GCObject **sweeptolive (lua_State *L, GCObject **p, int *n) {
+  GCObject ** old = p;
+  int i = 0;
+  do {
+    i++;
+    p = sweeplist(L, p, 1);
+  } while (p == old);
+  if (n) *n += i;
+  return p;
+}
 /* }====================================================== */
     L->allowhook = oldah;  /* restore hooks */
     g->gcrunning = running;  /* restore state */
     if (status != LUA_OK && propagateerrors) {  /* error while running __gc? */
-      if (status == LUA_ERRRUN) {  /* is there an error msg.? */
+      if (status == LUA_ERRRUN) {  /* is there an error object? */
-        luaO_pushfstring(L, "error in __gc metamethod (%s)",
+        const char *msg = (ttisstring(L->top - 1))
-                                        lua_tostring(L, -1));
+                            ? svalue(L->top - 1)
+                            : "no message";
+        luaO_pushfstring(L, "error in __gc metamethod (%s)", msg);
         status = LUA_ERRGCMM;  /* error in __gc metamethod */
       }
-      luaD_throw(L, status);  /* re-send error */
+      luaD_throw(L, status);  /* re-throw error */
     }
   }
 }
   else {  /* move 'o' to 'finobj' list */
     GCObject **p;
     GCheader *ho = gch(o);
-    /* avoid removing current sweep object */
+    if (g->sweepgc == &ho->next) {  /* avoid removing current sweep object */
-    if (g->sweepgc == &ho->next) {
+      lua_assert(issweepphase(g));
-      /* step to next object in the list */
+      g->sweepgc = sweeptolive(L, g->sweepgc, NULL);
-      g->sweepgc = (ho->next == NULL) ? NULL : &gch(ho->next)->next;
     }
     /* search for pointer pointing to 'o' */
     for (p = &g->allgc; *p != o; p = &gch(*p)->next) { /* empty */ }
     ho->next = g->finobj;  /* link it in list 'finobj' */
     g->finobj = o;
     l_setbit(ho->marked, SEPARATED);  /* mark it as such */
-    resetoldbit(o);  /* see MOVE OLD rule */
+    if (!keepinvariant(g))  /* not keeping invariant? */
+      makewhite(g, o);  /* "sweep" object */
+    else
+      resetoldbit(o);  /* see MOVE OLD rule */
   }
 }
 /*
 ** enter first sweep phase (strings) and prepare pointers for other
-** sweep phases.  The calls to 'sweeplist' attempt to make pointers
+** sweep phases.  The calls to 'sweeptolive' make pointers point to an
-** point to an object inside the list (instead of to the header), so
+** object inside the list (instead of to the header), so that the real
-** that the real sweep do not need to skip objects created between "now"
+** sweep do not need to skip objects created between "now" and the start
-** and the start of the real sweep.
+** of the real sweep.
+** Returns how many objects it sweeped.
 */
-static void entersweep (lua_State *L) {
+static int entersweep (lua_State *L) {
   global_State *g = G(L);
+  int n = 0;
   g->gcstate = GCSsweepstring;
   lua_assert(g->sweepgc == NULL && g->sweepfin == NULL);
-  g->sweepstrgc = 0;  /* prepare to sweep strings, ... */
+  /* prepare to sweep strings, finalizable objects, and regular objects */
-  g->sweepfin = sweeplist(L, &g->finobj, 1);  /* finalizable objects, ... */
+  g->sweepstrgc = 0;
-  g->sweepgc = sweeplist(L, &g->allgc, 1);  /* and regular objects */
+  g->sweepfin = sweeptolive(L, &g->finobj, &n);
+  g->sweepgc = sweeptolive(L, &g->allgc, &n);
+  return n;
 }
 static l_mem atomic (lua_State *L) {
   global_State *g = G(L);
-  l_mem trav = g->GCmemtrav;
+  l_mem work = -g->GCmemtrav;  /* start counting work */
   GCObject *origweak, *origall;
   lua_assert(!iswhite(obj2gco(g->mainthread)));
   markobject(g, L);  /* mark running thread */
   markmt(g);  /* mark basic metatables */
   /* remark occasional upvalues of (maybe) dead threads */
   remarkupvals(g);
+  propagateall(g);  /* propagate changes */
+  work += g->GCmemtrav;  /* stop counting (do not (re)count grays) */
   /* traverse objects caught by write barrier and by 'remarkupvals' */
   retraversegrays(g);
+  work -= g->GCmemtrav;  /* restart counting */
   convergeephemerons(g);
   /* at this point, all strongly accessible objects are marked. */
   /* clear values from weak tables, before checking finalizers */
   clearvalues(g, g->weak, NULL);
   clearvalues(g, g->allweak, NULL);
   origweak = g->weak; origall = g->allweak;
+  work += g->GCmemtrav;  /* stop counting (objects being finalized) */
   separatetobefnz(L, 0);  /* separate objects to be finalized */
-  markbeingfnz(g);  /* mark userdata that will be finalized */
+  markbeingfnz(g);  /* mark objects that will be finalized */
   propagateall(g);  /* remark, to propagate `preserveness' */
-  trav = g->GCmemtrav - trav;  /* avoid adding convergence twice */
+  work -= g->GCmemtrav;  /* restart counting */
   convergeephemerons(g);
   /* at this point, all resurrected objects are marked. */
   /* remove dead objects from weak tables */
   clearvalues(g, g->weak, origweak);
   clearvalues(g, g->allweak, origall);
   g->currentwhite = cast_byte(otherwhite(g));  /* flip current white */
-  entersweep(L);  /* prepare to sweep strings */
+  work += g->GCmemtrav;  /* complete counting */
-  /*lua_checkmemory(L);*/
+  return work;  /* estimate of memory marked by 'atomic' */
-  return trav;  /* reasonable estimate of the work done by 'atomic' */
 }
         return g->GCmemtrav - oldtrav;  /* memory traversed in this step */
       }
       else {  /* no more `gray' objects */
+        lu_mem work;
+        int sw;
         g->gcstate = GCSatomic;  /* finish mark phase */
-        g->GCestimate = g->GCmemtrav;  /* save what was counted */
+        g->GCestimate = g->GCmemtrav;  /* save what was counted */;
-        return atomic(L);
+        work = atomic(L);  /* add what was traversed by 'atomic' */
+        g->GCestimate += work;  /* estimate of total memory traversed */
+        sw = entersweep(L);
+        return work + sw * GCSWEEPCOST;
       }
     }
     case GCSsweepstring: {
 }
-static void step (lua_State *L) {
+static void incstep (lua_State *L) {
   global_State *g = G(L);
   l_mem debt = g->GCdebt;
   int stepmul = g->gcstepmul;
   global_State *g = G(L);
   int i;
   if (isgenerational(g)) generationalcollection(L);
-  else step(L);
+  else incstep(L);
   /* run a few finalizers (or all of them at the end of a collect cycle) */
   for (i = 0; g->tobefnz && (i < GCFINALIZENUM || g->gcstate == GCSpause); i++)
     GCTM(L, 1);  /* call one finalizer */

src/loadlib.c+3−3

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: loadlib.c,v 1.110 2012/04/26 19:38:52 roberto Exp $	2	** $Id: loadlib.c,v 1.111 2012/05/30 12:33:44 roberto Exp $
3	** Dynamic library loader for Lua	3	** Dynamic library loader for Lua
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	**	5	**
@@ -482,9 +482,9 @@ static void findloader (lua_State L, const char name) { · 476 unmodified lines
482	lua_getfield(L, lua_upvalueindex(1), "searchers"); /* will be at index 3 */	482	lua_getfield(L, lua_upvalueindex(1), "searchers"); /* will be at index 3 */
483	if (!lua_istable(L, 3))	483	if (!lua_istable(L, 3))
484	luaL_error(L, LUA_QL("package.searchers") " must be a table");	484	luaL_error(L, LUA_QL("package.searchers") " must be a table");
485	/* iterate over available seachers to find a loader */	485	/* iterate over available searchers to find a loader */
486	for (i = 1; ; i++) {	486	for (i = 1; ; i++) {
487	lua_rawgeti(L, 3, i); /* get a seacher */	487	lua_rawgeti(L, 3, i); /* get a searcher */
488	if (lua_isnil(L, -1)) { /* no more searchers? */	488	if (lua_isnil(L, -1)) { /* no more searchers? */
489	lua_pop(L, 1); /* remove nil */	489	lua_pop(L, 1); /* remove nil */
490	luaL_pushresult(&msg); /* create error message */	490	luaL_pushresult(&msg); /* create error message */

src/lstate.c+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lstate.c,v 2.97 2012/05/23 15:37:09 roberto Exp $	2	** $Id: lstate.c,v 2.98 2012/05/30 12:33:44 roberto Exp $
3	** Global State	3	** Global State
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -79,7 +79,7 @@ typedef struct LG { · 73 unmodified lines
79		79
80	/*	80	/*
81	** Compute an initial seed as random as possible. In ANSI, rely on	81	** Compute an initial seed as random as possible. In ANSI, rely on
82	** Address Space Layour Randomization (if present) to increase	82	** Address Space Layout Randomization (if present) to increase
83	** randomness..	83	** randomness..
84	*/	84	*/
85	#define addbuff(b,p,e) \	85	#define addbuff(b,p,e) \