lua源码阅读7——内存管理

LUALIB_API lua_State *luaL_newstate (void) {
  lua_State *L = lua_newstate(l_alloc, NULL); //设置内存申请和释放函数
  if (L) lua_atpanic(L, &panic);
  return L;
}

//虚拟机内部用到的内存申请和释放的函数， 当nSize=0时，释放内存
static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
  (void)ud; (void)osize;  /* not used */
  if (nsize == 0) {
    free(ptr);
    return NULL;
  }
  else
    return realloc(ptr, nsize);
}

#define luaM_freemem(L, b, s)   luaM_realloc_(L, (b), (s), 0)
#define luaM_free(L, b)     luaM_realloc_(L, (b), sizeof(*(b)), 0)
#define luaM_freearray(L, b, n)   luaM_realloc_(L, (b), (n)*sizeof(*(b)), 0)

#define luaM_malloc(L,s)    luaM_realloc_(L, NULL, 0, (s))

/*
** generic allocation routine.
** 对realloc的封装，block: 老内存快，osize： 老大小，nsize：新大小，返回新内存块
*/
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
  void *newblock;
  global_State *g = G(L);

  //参数检查：block = null时， osize必须为0， block != null osize必须不为0
  size_t realosize = (block) ? osize : 0;
  lua_assert((realosize == 0) == (block == NULL));
#if defined(HARDMEMTESTS)
  if (nsize > realosize && g->gcrunning)
    luaC_fullgc(L, 1);  /* force a GC whenever possible */
#endif

  //nsize==0的时候才释放, l_alloc中实现
  newblock = (*g->frealloc)(g->ud, block, osize, nsize);

  //申请失败，gc一次，然后再申请一次
  if (newblock == NULL && nsize > 0) {
    lua_assert(nsize > realosize);  /* cannot fail when shrinking a block */
    if (g->version) {  /* is state fully built? */
      luaC_fullgc(L, 1);  /* try to free some memory... */
      newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
    }
    if (newblock == NULL)
      luaD_throw(L, LUA_ERRMEM);
  }
  lua_assert((nsize == 0) == (newblock == NULL));
  g->GCdebt = (g->GCdebt + nsize) - realosize; //记录当前使用的内存大小
  return newblock;
}

#define CommonHeader    GCObject *next; lu_byte tt; lu_byte marked

//...
/* Layout for bit use in 'marked' field: */
//第0位表示white
#define WHITE0BIT   0  /* object is white (type 0) */ 
//第1位表示 other white
#define WHITE1BIT   1  /* object is white (type 1) */
//第2位表示黑色
#define BLACKBIT    2  /* object is black */
#define FINALIZEDBIT    3  /* object has been marked for finalization */
/* bit 7 is currently used by tests (luaL_checkmemory) */

#define WHITEBITS   bit2mask(WHITE0BIT, WHITE1BIT)

//颜色判断
#define iswhite(x)      testbits((x)->marked, WHITEBITS)
#define isblack(x)      testbit((x)->marked, BLACKBIT)
//不是白的，不是黑的,就是灰的
#define isgray(x)  /* neither white nor black */  \
    (!testbits((x)->marked, WHITEBITS | bitmask(BLACKBIT)))

#define tofinalize(x)   testbit((x)->marked, FINALIZEDBIT)

//获得other white， 异或操作，很精巧
#define otherwhite(g)   ((g)->currentwhite ^ WHITEBITS)
#define isdeadm(ow,m)   (!(((m) ^ WHITEBITS) & (ow)))
#define isdead(g,v) isdeadm(otherwhite(g), (v)->marked)

//两种white间切换
#define changewhite(x)  ((x)->marked ^= WHITEBITS)
//...

/*
** 'global state', shared by all threads of this state
*/
typedef struct global_State {
  lua_Alloc frealloc;  /* function to reallocate memory */
  void *ud;         /* auxiliary data to 'frealloc' */
  //正在使用的内存大小， 总大小-需要gc的大小
  l_mem totalbytes;  /* number of bytes currently allocated - GCdebt */
  //需要gc的大小
  l_mem GCdebt;  /* bytes allocated not yet compensated by the collector */
  //本次遍历收集的内存大小，可以将一次gc收集分成几次完成，使一次收集不占用太多时间
  lu_mem GCmemtrav;  /* memory traversed by the GC */
  lu_mem GCestimate;  /* an estimate of the non-garbage memory in use */
  stringtable strt;  /* hash table for strings */
  TValue l_registry;
  unsigned int seed;  /* randomized seed for hashes */

  //当前用的白色种类
  lu_byte currentwhite;
  //当前gc阶段，值有GCSpropagate，GCSatomic等
  lu_byte gcstate;  /* state of garbage collector */
  lu_byte gckind;  /* kind of GC running */
  lu_byte gcrunning;  /* true if GC is running */
  //所有可回收对象的列表，新创建的会放到头部，参看luaC_newobj
  GCObject *allgc;  /* list of all collectable objects */
  //当前sweep的进度
  GCObject **sweepgc;  /* current position of sweep in list */
  GCObject *finobj;  /* list of collectable objects with finalizers */
  //灰色列表
  GCObject *gray;  /* list of gray objects */
  //gray again 列表
  GCObject *grayagain;  /* list of objects to be traversed atomically */
  GCObject *weak;  /* list of tables with weak values */
  GCObject *ephemeron;  /* list of ephemeron tables (weak keys) */
  GCObject *allweak;  /* list of all-weak tables */
  GCObject *tobefnz;  /* list of userdata to be GC */
  GCObject *fixedgc;  /* list of objects not to be collected */
  struct lua_State *twups;  /* list of threads with open upvalues */
  unsigned int gcfinnum;  /* number of finalizers to call in each GC step */
  int gcpause;  /* size of pause between successive GCs */
  //一次收集的最大内存，和GCmemtrav配合使用
  int gcstepmul;  /* GC 'granularity' */
  lua_CFunction panic;  /* to be called in unprotected errors */
  struct lua_State *mainthread;
  const lua_Number *version;  /* pointer to version number */
  TString *memerrmsg;  /* memory-error message */
  TString *tmname[TM_N];  /* array with tag-method names */
  struct Table *mt[LUA_NUMTAGS];  /* metatables for basic types */
  TString *strcache[STRCACHE_N][STRCACHE_M];  /* cache for strings in API */
} global_State;

#define GCSpropagate    0  //遍历阶段
#define GCSatomic   1
#define GCSswpallgc 2
#define GCSswpfinobj    3
#define GCSswptobefnz   4
#define GCSswpend   5
#define GCScallfin  6
#define GCSpause    7

//lvm.c
vmcase(OP_NEWTABLE) {
    int b = GETARG_B(i);
    int c = GETARG_C(i);
    Table *t = luaH_new(L);
    sethvalue(L, ra, t);
    if (b != 0 || c != 0)
        luaH_resize(L, t, luaO_fb2int(b), luaO_fb2int(c));
    checkGC(L, ra + 1); //检查并gc
    vmbreak;
}

#define luaC_condGC(L,pre,pos) \
    { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \
      condchangemem(L,pre,pos); }

/*
** performs a basic GC step when collector is running
*/
void luaC_step (lua_State *L) {
  global_State *g = G(L);
  //获取出来的debt是g->gcstepmul的倍数， debt >= 0
  l_mem debt = getdebt(g);  /* GC deficit (be paid now) */
  if (!g->gcrunning) {  /* not running? */
    //设置debt为10倍平常值，这样可以防止频繁的自动GC
    luaE_setdebt(g, -GCSTEPSIZE * 10);  /* avoid being called too often */
    return;
  }

  //如果要gc的内存小于debt+GCSTEPSIZE， 这个循环一次性处理完
  do {  /* repeat until pause or enough "credit" (negative debt) */
    lu_mem work = singlestep(L);  /* perform one single step */
    debt -= work;
  }
  //g->gcstate的初始状态是GCSpause，如果又等于GCSpause的话，表示gc又处理过一轮了
  while (debt > -GCSTEPSIZE && g->gcstate != GCSpause);

  //本轮处理完了，重新设置pause状态
  if (g->gcstate == GCSpause)
    setpause(g);  /* pause until next cycle */
  else {
    debt = (debt / g->gcstepmul) * STEPMULADJ;  /* convert 'work units' to Kb */
    luaE_setdebt(g, debt);
    runafewfinalizers(L);
  }
}