History

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
  1. src/lauxlib.c +3 −3
  2. src/lgc.c +59 −28
  3. src/loadlib.c +3 −3
  4. src/lstate.c +2 −2
src/lauxlib.c+3−3
@@ -1,5 +1,5 @@
11 /*
2−** $Id: lauxlib.c,v 1.243 2012/04/20 17:05:17 roberto Exp $
2+** $Id: lauxlib.c,v 1.244 2012/05/31 20:28:45 roberto Exp $
33 ** Auxiliary functions for building Lua libraries
44 ** See Copyright Notice in lua.h
55 */
@@ -520,11 +520,11 @@ LUALIB_API char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz) { · 514 unmodified lines
520520
521521 LUALIB_API int luaL_ref (lua_State *L, int t) {
522522 int ref;
523− t = lua_absindex(L, t);
524523 if (lua_isnil(L, -1)) {
525524 lua_pop(L, 1); /* remove from stack */
526525 return LUA_REFNIL; /* `nil' has a unique fixed reference */
527526 }
527+ t = lua_absindex(L, t);
528528 lua_rawgeti(L, t, freelist); /* get first free element */
529529 ref = (int)lua_tointeger(L, -1); /* ref = t[freelist] */
530530 lua_pop(L, 1); /* remove it from stack */
@@ -866,8 +866,8 @@ LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) { · 335 unmodified lines
866866 lua_getfield(L, idx, fname);
867867 if (lua_istable(L, -1)) return 1; /* table already there */
868868 else {
869− idx = lua_absindex(L, idx);
870869 lua_pop(L, 1); /* remove previous result */
870+ idx = lua_absindex(L, idx);
871871 lua_newtable(L);
872872 lua_pushvalue(L, -1); /* copy to be left at top */
873873 lua_setfield(L, idx, fname); /* assign new table to field */
src/lgc.c+59−28
@@ -1,5 +1,5 @@
11 /*
2−** $Id: lgc.c,v 2.129 2012/05/28 20:41:00 roberto Exp $
2+** $Id: lgc.c,v 2.133 2012/05/31 21:28:59 roberto Exp $
33 ** Garbage Collector
44 ** See Copyright Notice in lua.h
55 */
@@ -753,6 +753,21 @@ static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) { · 747 unmodified lines
753753 return (*p == NULL) ? NULL : p;
754754 }
755755
756+
757+/*
758+** sweep a list until a live object (or end of list)
759+*/
760+static GCObject **sweeptolive (lua_State *L, GCObject **p, int *n) {
761+ GCObject ** old = p;
762+ int i = 0;
763+ do {
764+ i++;
765+ p = sweeplist(L, p, 1);
766+ } while (p == old);
767+ if (n) *n += i;
768+ return p;
769+}
770+
756771 /* }====================================================== */
757772
758773
@@ -812,12 +827,14 @@ static void GCTM (lua_State *L, int propagateerrors) { · 53 unmodified lines
812827 L->allowhook = oldah; /* restore hooks */
813828 g->gcrunning = running; /* restore state */
814829 if (status != LUA_OK && propagateerrors) { /* error while running __gc? */
815− if (status == LUA_ERRRUN) { /* is there an error msg.? */
816− luaO_pushfstring(L, "error in __gc metamethod (%s)",
817− lua_tostring(L, -1));
830+ if (status == LUA_ERRRUN) { /* is there an error object? */
831+ const char *msg = (ttisstring(L->top - 1))
832+ ? svalue(L->top - 1)
833+ : "no message";
834+ luaO_pushfstring(L, "error in __gc metamethod (%s)", msg);
818835 status = LUA_ERRGCMM; /* error in __gc metamethod */
819836 }
820− luaD_throw(L, status); /* re-send error */
837+ luaD_throw(L, status); /* re-throw error */
821838 }
822839 }
823840 }
@@ -864,10 +881,9 @@ void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) { · 40 unmodified lines
864881 else { /* move 'o' to 'finobj' list */
865882 GCObject **p;
866883 GCheader *ho = gch(o);
867− /* avoid removing current sweep object */
868− if (g->sweepgc == &ho->next) {
869− /* step to next object in the list */
870− g->sweepgc = (ho->next == NULL) ? NULL : &gch(ho->next)->next;
884+ if (g->sweepgc == &ho->next) { /* avoid removing current sweep object */
885+ lua_assert(issweepphase(g));
886+ g->sweepgc = sweeptolive(L, g->sweepgc, NULL);
871887 }
872888 /* search for pointer pointing to 'o' */
873889 for (p = &g->allgc; *p != o; p = &gch(*p)->next) { /* empty */ }
@@ -875,7 +891,10 @@ void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) { · 1 unmodified line
875891 ho->next = g->finobj; /* link it in list 'finobj' */
876892 g->finobj = o;
877893 l_setbit(ho->marked, SEPARATED); /* mark it as such */
878− resetoldbit(o); /* see MOVE OLD rule */
894+ if (!keepinvariant(g)) /* not keeping invariant? */
895+ makewhite(g, o); /* "sweep" object */
896+ else
897+ resetoldbit(o); /* see MOVE OLD rule */
879898 }
880899 }
881900
@@ -895,18 +914,22 @@ void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) { · 13 unmodified lines
895914
896915 /*
897916 ** enter first sweep phase (strings) and prepare pointers for other
898−** sweep phases. The calls to 'sweeplist' attempt to make pointers
899−** point to an object inside the list (instead of to the header), so
900−** that the real sweep do not need to skip objects created between "now"
901−** and the start of the real sweep.
917+** sweep phases. The calls to 'sweeptolive' make pointers point to an
918+** object inside the list (instead of to the header), so that the real
919+** sweep do not need to skip objects created between "now" and the start
920+** of the real sweep.
921+** Returns how many objects it sweeped.
902922 */
903−static void entersweep (lua_State *L) {
923+static int entersweep (lua_State *L) {
904924 global_State *g = G(L);
925+ int n = 0;
905926 g->gcstate = GCSsweepstring;
906927 lua_assert(g->sweepgc == NULL && g->sweepfin == NULL);
907− g->sweepstrgc = 0; /* prepare to sweep strings, ... */
908− g->sweepfin = sweeplist(L, &g->finobj, 1); /* finalizable objects, ... */
909− g->sweepgc = sweeplist(L, &g->allgc, 1); /* and regular objects */
928+ /* prepare to sweep strings, finalizable objects, and regular objects */
929+ g->sweepstrgc = 0;
930+ g->sweepfin = sweeptolive(L, &g->finobj, &n);
931+ g->sweepgc = sweeptolive(L, &g->allgc, &n);
932+ return n;
910933 }
911934
912935
@@ -962,7 +985,7 @@ void luaC_freeallobjects (lua_State *L) { · 49 unmodified lines
962985
963986 static l_mem atomic (lua_State *L) {
964987 global_State *g = G(L);
965− l_mem trav = g->GCmemtrav;
988+ l_mem work = -g->GCmemtrav; /* start counting work */
966989 GCObject *origweak, *origall;
967990 lua_assert(!iswhite(obj2gco(g->mainthread)));
968991 markobject(g, L); /* mark running thread */
@@ -971,18 +994,22 @@ static l_mem atomic (lua_State *L) { · 2 unmodified lines
971994 markmt(g); /* mark basic metatables */
972995 /* remark occasional upvalues of (maybe) dead threads */
973996 remarkupvals(g);
997+ propagateall(g); /* propagate changes */
998+ work += g->GCmemtrav; /* stop counting (do not (re)count grays) */
974999 /* traverse objects caught by write barrier and by 'remarkupvals' */
9751000 retraversegrays(g);
1001+ work -= g->GCmemtrav; /* restart counting */
9761002 convergeephemerons(g);
9771003 /* at this point, all strongly accessible objects are marked. */
9781004 /* clear values from weak tables, before checking finalizers */
9791005 clearvalues(g, g->weak, NULL);
9801006 clearvalues(g, g->allweak, NULL);
9811007 origweak = g->weak; origall = g->allweak;
1008+ work += g->GCmemtrav; /* stop counting (objects being finalized) */
9821009 separatetobefnz(L, 0); /* separate objects to be finalized */
983− markbeingfnz(g); /* mark userdata that will be finalized */
1010+ markbeingfnz(g); /* mark objects that will be finalized */
9841011 propagateall(g); /* remark, to propagate `preserveness' */
985− trav = g->GCmemtrav - trav; /* avoid adding convergence twice */
1012+ work -= g->GCmemtrav; /* restart counting */
9861013 convergeephemerons(g);
9871014 /* at this point, all resurrected objects are marked. */
9881015 /* remove dead objects from weak tables */
@@ -992,9 +1019,8 @@ static l_mem atomic (lua_State *L) { · 3 unmodified lines
9921019 clearvalues(g, g->weak, origweak);
9931020 clearvalues(g, g->allweak, origall);
9941021 g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */
995− entersweep(L); /* prepare to sweep strings */
996− /*lua_checkmemory(L);*/
997− return trav; /* reasonable estimate of the work done by 'atomic' */
1022+ work += g->GCmemtrav; /* complete counting */
1023+ return work; /* estimate of memory marked by 'atomic' */
9981024 }
9991025
10001026
@@ -1018,9 +1044,14 @@ static lu_mem singlestep (lua_State *L) { · 17 unmodified lines
10181044 return g->GCmemtrav - oldtrav; /* memory traversed in this step */
10191045 }
10201046 else { /* no more `gray' objects */
1047+ lu_mem work;
1048+ int sw;
10211049 g->gcstate = GCSatomic; /* finish mark phase */
1022− g->GCestimate = g->GCmemtrav; /* save what was counted */
1023− return atomic(L);
1050+ g->GCestimate = g->GCmemtrav; /* save what was counted */;
1051+ work = atomic(L); /* add what was traversed by 'atomic' */
1052+ g->GCestimate += work; /* estimate of total memory traversed */
1053+ sw = entersweep(L);
1054+ return work + sw * GCSWEEPCOST;
10241055 }
10251056 }
10261057 case GCSsweepstring: {
@@ -1089,7 +1120,7 @@ static void generationalcollection (lua_State *L) { · 62 unmodified lines
10891120 }
10901121
10911122
1092−static void step (lua_State *L) {
1123+static void incstep (lua_State *L) {
10931124 global_State *g = G(L);
10941125 l_mem debt = g->GCdebt;
10951126 int stepmul = g->gcstepmul;
@@ -1116,7 +1147,7 @@ void luaC_forcestep (lua_State *L) { · 20 unmodified lines
11161147 global_State *g = G(L);
11171148 int i;
11181149 if (isgenerational(g)) generationalcollection(L);
1119− else step(L);
1150+ else incstep(L);
11201151 /* run a few finalizers (or all of them at the end of a collect cycle) */
11211152 for (i = 0; g->tobefnz && (i < GCFINALIZENUM || g->gcstate == GCSpause); i++)
11221153 GCTM(L, 1); /* call one finalizer */
src/loadlib.c+3−3
@@ -1,5 +1,5 @@
11 /*
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 $
33 ** Dynamic library loader for Lua
44 ** See Copyright Notice in lua.h
55 **
@@ -482,9 +482,9 @@ static void findloader (lua_State *L, const char *name) { · 476 unmodified lines
482482 lua_getfield(L, lua_upvalueindex(1), "searchers"); /* will be at index 3 */
483483 if (!lua_istable(L, 3))
484484 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 */
486486 for (i = 1; ; i++) {
487− lua_rawgeti(L, 3, i); /* get a seacher */
487+ lua_rawgeti(L, 3, i); /* get a searcher */
488488 if (lua_isnil(L, -1)) { /* no more searchers? */
489489 lua_pop(L, 1); /* remove nil */
490490 luaL_pushresult(&msg); /* create error message */
src/lstate.c+2−2
@@ -1,5 +1,5 @@
11 /*
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 $
33 ** Global State
44 ** See Copyright Notice in lua.h
55 */
@@ -79,7 +79,7 @@ typedef struct LG { · 73 unmodified lines
7979
8080 /*
8181 ** 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
8383 ** randomness..
8484 */
8585 #define addbuff(b,p,e) \