lua内存管理

本文内容基于版本：Lua 5.3.0

Lua内存管理器规则

---

Lua允许用户自定义内存管理器，并在创建Lua虚拟机（lua_State实例）时传入。当然自定义内存管理器必须遵循Lua已定义的一些行为规则。创建一个Lua虚拟机需要使用luaL_newstate函数：

lua_State *L = luaL_newstate();

luaL_newstate函数的实现主要是调用lua_newstate函数，lua_newstate函数将接受一个内存分配器函数作为参数，进而在内部分配内存：

// lauxlib.h
LUALIB_API lua_State *(luaL_newstate) (void);

// lauxlib.c
LUALIB_API lua_State *luaL_newstate (void) {
  lua_State *L = lua_newstate(l_alloc, NULL);
if (L) lua_atpanic(L, &panic);
  return L;
}

// lua.h
LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);

// lstate.c
LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
  int i;
  lua_State *L;
  global_State *g;
  LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));
  if (l == NULL) return NULL;
  ......
  return L;
}

可以看到，Lua内存分配器必须是一个lua_Alloc类型的函数，如果想自定义内存分配器，那么用户必须定义一个lua_Alloc类型的函数：

// lua.h
typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);

Lua默认内存管理器

---

luaL_newstate函数调用lua_newstate函数时，传入了一个lua_Alloc类型的函数：l_alloc。该函数就是Lua提供的默认内存管理函数，它主要使用C标准库中的realloc函数进行内存管理：

// lauxlib.c
static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
  (void)ud; (void)osize;  /* not used */
  if (nsize == ) {
    free(ptr);
    return NULL;
  }
  else
    return realloc(ptr, nsize);
}

       ud　 ：Lua默认内存管理器并未使用该参数。不过在用户自定义内存管理器中，可以让内存管理在不同的堆上进行。

       ptr　：非NULL表示指向一个已分配的内存块指针，NULL表示将分配一块nsize大小的新内存块。

       osize：原始内存块大小，默认内存管理器并未使用该参数。Lua的设计强制在调用内存管理器函数时候需要给出原始内存块的大小信息，如果用户需要自定义一个高效的内存管理器，那么这个参数信息将十分重要。这是因为大多数的内存管理算法都需要为所管理的内存块加上一个cookie，里面存储了内存块尺寸的信息，以便在释放内存的时候能够获取到尺寸信息(譬如多级内存池回收内存操作)。而Lua内存管理器刻意在调用内存管理器时提供了这个信息，这样就不必额外存储这些cookie信息，这样在大量使用小内存块的环境中将可以节省不少的内存。另外在ptr传入NULL时，osize表示Lua对象类型（LUA_TNIL、LUA_TBOOLEAN、LUA_TTHREAD等等），这样内存管理器就可以知道当前在分配的对象的类型，从而可以针对它做一些统计或优化的工作。

       nsize：新的内存块大小，特别地，在nsize为0时需要提供内存释放的功能。

global_State.frealloc

---

我们已经知道在创建Lua虚拟机时将传入一个内存管理器，然后使用该内存管理器分配相关的数据结构。Lua设计了一个global_State结构（全局状态机）来存储各种全局数据，其中就包含了内存管理器。也就是说我们使用内存管理器创建了一个Lua虚拟机，Lua虚拟机的全局状态机中保存了该内存管理器，以便Lua后续内部的工作能使用该内存管理器进行内存管理工作。

// lstate.c
LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
  int i;
  lua_State *L;
  global_State *g;
  LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));
  if (l == NULL) return NULL;
  L = &l->l.l;
  g = &l->g;
  L->next = NULL;
  L->tt = LUA_TTHREAD;
  g->currentwhite = bitmask(WHITE0BIT);
  L->marked = luaC_white(g);
  preinit_thread(L, g);
  g->frealloc = f;
  ......

  return L;
}

Lua内存管理的宏

---

Lua设计了一组宏来管理不同类别的内存：单个对象、数组、可变长数组等等。这一系列的宏使用了两个核心API：luaM_realloc_和luaM_growaux_，下面我们先就这两个核心API进行分析。

• luaM_realloc

luaM_realloc_函数并不会被直接调用，它将调用保存在global_State.frealloc中的内存分配器进行内存管理工作。luaM_realloc_会根据传入的osize和nsize调整内部感知的内存大小（设置GCdebt），并在内存不够用的时候会主动尝试做GC操作。

// lmem.h
/* not to be called directly */
LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
                                                          size_t size);

// lmem.c
/*
** generic allocation routine.
*/
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
  void *newblock;
  global_State *g = G(L);
  size_t realosize = (block) ? osize : ;
  lua_assert((realosize == ) == (block == NULL));
#if defined(HARDMEMTESTS)
  if (nsize > realosize && g->gcrunning)
    luaC_fullgc(L, );  /* force a GC whenever possible */
#endif
  newblock = (*g->frealloc)(g->ud, block, osize, nsize);
  if (newblock == NULL && nsize > ) {
    api_check( nsize > realosize,
                 "realloc cannot fail when shrinking a block");
    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 == ) == (newblock == NULL));
  g->GCdebt = (g->GCdebt + nsize) - realosize;
  return newblock;
}

• luaM_growaux_

       luaM_growaux_函数是用来管理可变长数组的，其主要策略是：当数组空间不够时，扩大为原来空间的两倍。其中管理内存部分使用了基于luaM_realloc_函数的宏luaM_reallocv，该宏针对数组操作，根据新的数组元素个数重新分配内存。

// lmem.h
/* not to be called directly */
LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,
                               size_t size_elem, int limit,
                               const char *what);

// lmem.c
#define MINSIZEARRAY    4

void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
                     int limit, const char *what) {
  void *newblock;
  int newsize;
  if (*size >= limit/) {  /* cannot double it? */
    if (*size >= limit)  /* cannot grow even a little? */
      luaG_runerror(L, "too many %s (limit is %d)", what, limit);
    newsize = limit;  /* still have at least one free place */
  }
  else {
    newsize = (*size)*2;
    if (newsize < MINSIZEARRAY)
      newsize = MINSIZEARRAY;  /* minimum size */
  }
  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
  *size = newsize;  /* update only when everything else is OK */
  return newblock;
}

       size　　     ：数组长度（最大容纳元素个数），传入表示原始数组长度，传出表示重新分配后数组长度；

       size_elems：单个数组元素大小；

       limit　　   ：数组元素最大容纳个数限制；

       what　　  ：提示信息字符串；

• luaM_reallocv

/*
** This macro reallocs a vector 'b' from 'on' to 'n' elements, where
** each element has size 'e'. In case of arithmetic overflow of the
** product 'n'*'e', it raises an error (calling 'luaM_toobig'). Because
** 'e' is always constant, it avoids the runtime division MAX_SIZET/(e).
**
** (The macro is somewhat complex to avoid warnings:  The 'sizeof'
** comparison avoids a runtime comparison when overflow cannot occur.
** The compiler should be able to optimize the real test by itself, but
** when it does it, it may give a warning about "comparison is always
** false due to limited range of data type"; the +1 tricks the compiler,
** avoiding this warning but also this optimization.)
*/
#define luaM_reallocv(L,b,on,n,e) \
  (((sizeof(n) >= sizeof(size_t) && cast(size_t, (n)) +  > MAX_SIZET/(e)) \
      ? luaM_toobig(L) : cast_void()) , \
   luaM_realloc_(L, (b), (on)*(e), (n)*(e)))

luaM_reallocv将使数组b的长度（最大容纳元素个数）从on重新分配为n，其中每个数组元素大小为e。
       b　　：数组指针；

       on　 ：数组重新分配前的长度（最大容纳元素个数）；

       n  　 ：数组重新分配后的长度（最大容纳元素个数）；

       e　　：数组元素大小；

• luaM_reallocvchar

/*
** Arrays of chars do not need any test
*/
#define luaM_reallocvchar(L,b,on,n)  \
    cast(char *, luaM_realloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char)))

luaM_reallocvchar将使字符数组b的长度（最大容纳元素个数）从on重新分配为n，其中每个数组元素大小为sizeof(char)。

       b　　：数组指针；

       on　 ：数组重新分配前的长度（最大容纳元素个数）；

       n　　：数组重新分配后的长度（最大容纳元素个数）；

• luaM_freemem

#define luaM_freemem(L, b, s)    luaM_realloc_(L, (b), (s), 0)

luaM_freemem将释放b指向的内存块空间。

       b　　：内存块指针；

       s　    ：内存块大小；

• luaM_free

#define luaM_free(L, b)        luaM_realloc_(L, (b), sizeof(*(b)), 0)

luaM_free将释放b指向的内存块空间（b表示某种对象类型指针）。

       b　　：内存指针，同时表示某种对象类型指针；

• luaM_freearray

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

luaM_freearray将释放b指向的内存块空间（b表示某种类型对象的数组指针）。

       b　　：内存指针，同时表示某种类型对象的数组指针；

       n　　：数组长度（最大容纳元素个数）；

• luaM_malloc

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

luaM_malloc将分配一块大小为s的内存块空间。

       s　　：将要分配的内存块空间大小；

• luaM_new

#define luaM_new(L,t)        cast(t *, luaM_malloc(L, sizeof(t)))

luaM_new将分配一块内存块空间，空间大小为sizeof(t)。

        t　　：某种数据类型；

• luaM_newvector

#define luaM_newvector(L,n,t) \
        cast(t *, luaM_reallocv(L, NULL, , n, sizeof(t)))

luaM_newvector将分配一个长度为n的数组空间，数组元素为类型t。

       n　　：数组长度（最大容纳元素个数）；

       t　　：数组元素类型；

• luaM_newobject

#define luaM_newobject(L,tag,s)    luaM_realloc_(L, NULL, tag, (s))

luaM_newobject将分配一块大小为s的内存块空间，其将要容纳的Lua数据类型为tag表示的类型。

       tag   ：Lua数据类型；

       s　　：分配的内存块大小；

• luaM_growvector

#define luaM_growvector(L,v,nelems,size,t,limit,e) \
          if ((nelems)+ > (size)) \
            ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))

luaM_growvector将在数组空间不足以容纳下一个元素的情况下增长空间大小（原空间大小 * 2）。

       v             ：数组指针；

       nelems   ：正在使用的元素个数；

       size  　　：数组元素个数，传入表示原始数组大小，传出表示重新分配后数组大小；

       t       　　：（数组元素的）数据类型；

       limit 　　：数组元素最大个数限制；

       e　　　　：提示信息字符串；

• luaM_reallocvector

#define luaM_reallocvector(L, v,oldn,n,t) \
   ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))

luaM_reallocvector将重新分配数组空间大小。

        v　　：数组指针；

        oldn ：重新分配前数组大小；

        n　　：重新分配后数组大小；