标签：
本文分析基于的Lua版本为：Lua 5.3.0
Lua允许用户自定义内存管理器，并在创建Lua虚拟机时传入。当然该内存管理器必须遵循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);
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 == 0) { free(ptr); return NULL; } else return realloc(ptr, nsize); }
ud ：默认内存管理器并未使用该参数，不过在用户自定义内存管理器中，可以让内存管理在不同的堆上进行。
ptr ：非空表示指向一个已分配的内存块指针，NULL表示将分配一块nsize大小的新内存块。
osize：原始内存块大小，默认内存管理器并未使用该参数。Lua强制在调用内存管理器时候需要给出原始内存块的大小，如果用户需要自定义一个高效的内存管理器，那么这个参数信息将十分重要。大多数的内存管理算法中都需要为内存块加上一个cookie，里面存储了内存块尺寸的信息，以便在释放内存的时候能够获取到内存块的尺寸信息(譬如多级内存池)。而Lua内存管理器刻意提供了这个信息，这样就不必额外存储这些cookie信息，在大量使用小内存块的环境中将可以节省不少的内存。另外在ptr传入NULL时，osize表示Lua对象类型(LUA_TNIL、LUA_TBOOLEAN、LUA_TTHREAD等等)，这样内存管理器就可以知道当前在分配的对象的类型，可以针对它做一些统计或优化的工作。
nsize：新内存块大小，特别地在nsize为0时需要提供内存释放的功能。
我们已经知道在创建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设计了一组宏来管理不同类别的内存：单个对象、数组、可变长数组等等。这一系列的宏使用了两个核心API：luaM_realloc_和luaM_growaux_，下面我们先就这两个核心API进行分析。
luaM_realloc_函数并不会被直接调用，它将调用保存在global_State中的内存分配器进行内存管理工作。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 : 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 newblock = (*g->frealloc)(g->ud, block, osize, nsize); if (newblock == NULL && nsize > 0) { 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 == 0) == (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/2) { /* 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_elem：单个元素大小；
limit：数组元素最大个数限制；
what：提示信息字符串；
/*
** 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)) + 1 > MAX_SIZET/(e)) ? luaM_toobig(L) : cast_void(0)) , luaM_realloc_(L, (b), (on)*(e), (n)*(e)))
luaM_reallocv将使数组b的长度（最大容纳元素个数）从on重新分配为n，其中每个数组元素大小为e。
b ：数组指针；
on ：数组重新分配前的长度（最大容纳元素个数）；
n ：数组重新分配后的长度（最大容纳元素个数）；
e ：数组元素大小；
/* ** 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 ：数组重新分配后的长度（最大容纳元素个数）；
#define luaM_freemem(L, b, s) luaM_realloc_(L, (b), (s), 0)
luaM_freemem将释放b指向的内存块空间。
b ：内存块指针；
s ：内存块大小；
#define luaM_free(L, b) luaM_realloc_(L, (b), sizeof(*(b)), 0)
luaM_free将释放b指向的内存块空间（b表示某种对象类型指针）。
b ：内存指针，同时表示某种对象类型指针；
#define luaM_freearray(L, b, n) luaM_realloc_(L, (b), (n)*sizeof(*(b)), 0)
luaM_freearray将释放b指向的内存块空间（b表示某种类型对象的数组指针）。
b ：内存指针，同时表示某种类型对象的数组指针；
n ：数组长度（最大容纳元素个数）；
#define luaM_malloc(L,s) luaM_realloc_(L, NULL, 0, (s))
luaM_malloc将分配一块大小为s的内存块空间。
s ：将要分配的内存块空间大小；
#define luaM_new(L,t) cast(t *, luaM_malloc(L, sizeof(t)))
luaM_new将分配一块内存块空间，空间大小为sizeof(t)。
t ：某种数据类型；
#define luaM_newvector(L,n,t) \ cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
luaM_newvector将分配一个长度为n的数组空间，数组元素为类型t。
n ：数组长度（最大容纳元素个数）；
t ：数组元素类型；
#define luaM_newobject(L,tag,s) luaM_realloc_(L, NULL, tag, (s))
luaM_newobject将分配一块大小为s的内存块空间，其将要容纳的Lua数据类型为tag表示的类型。
tag ：Lua数据类型；
s ：分配的内存块大小；
#define luaM_growvector(L,v,nelems,size,t,limit,e) if ((nelems)+1 > (size)) ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
luaM_growvector将在数组空间不足以容纳下一个元素的情况下增长空间大小（原空间大小 * 2）。
v ：数组指针；
nelems ：正在使用的元素个数；
size ：数组元素个数，传入表示原始数组大小，传出表示重新分配后数组大小；
t ：（数组元素的）数据类型；
limit ：数组元素最大个数限制；
e ：提示信息字符串；
#define luaM_reallocvector(L, v,oldn,n,t) \ ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
luaM_reallocvector将重新分配数组空间大小。
v ：数组指针；
oldn ：重新分配前数组大小；
n ：重新分配后数组大小；
标签：
原文地址：http://www.cnblogs.com/heartchord/p/4527494.html
