lua 源码分析之线程对象lua_State

思路：

 lua_State 中放的是 lua 虚拟机中的环境表、注册表、运行堆栈、虚拟机的上下文等数据。

 从一个主线程（特指 lua 虚拟机中的线程，即 coroutine）中创建出来的新的 lua_State 会共享大部分数据，但会拥有一个独立的运行堆栈。所以一个线程对象拥有一个lua_State。

(ps：lua 的coroutine的使用参考： http://blog.csdn.net/wusheng520/article/details/7954666)

lua_State共享的数据部分是全局状态机（包含GC的数据）.lua_State 的运行堆栈为调用栈,lua_State 的数据栈包含当前调用栈信息。

目录：
1、虚拟机对象
(1)执行状态机
(2)全局状态机
2、执行状态机的数据栈和调用栈
(1) 数据栈
(2)调用栈
 
本文内容：
1、lua_state线程对象
（1）lua_state的上下文数据
从 C 层面看待 lua ，lua 的虚拟机对象就是一个lua_state 。 但实际上，真正的 lua虚拟机对象被隐藏起来了。那就是 lstate.h 中定义的结构体  global_State。同一 lua 虚拟机中的所有执行线程，共享了一块全局数据 global_state 。
lua_state 是暴露给用户的数据类型,既表示一个 lua 程序的执行状态，也指代 lua 的一个线程（在官方文档中）。每个线程拥有独立的数据栈以及函数调用栈，还有独立的调试钩子和错误处理设置。所以我们不应当简单的把lua_state 看成一个静态的数据集，它是一个lua 线程的执行状态。所有的lua C API 都是围绕这个状态机：
或把数据压入堆栈，或取出，或执行栈顶的函数，或继续上次被中断的执行过程。


源代码lua5.14版 lstate.h(100行)

struct lua_State {
  CommonHeader;
  lu_byte status;
  StkId top;  /* first free slot in the stack */
  StkId base;  /* base of current function */
  global_State *l_G;
  CallInfo *ci;  /* call info for current function */
  const Instruction *savedpc;  /* `savedpc' of current function */
  StkId stack_last;  /* last free slot in the stack */
  StkId stack;  /* stack base */
  CallInfo *end_ci;  /* points after end of ci array*/
  CallInfo *base_ci;  /* array of CallInfo's */
  int stacksize;
  int size_ci;  /* size of array `base_ci' */
  unsigned short nCcalls;  /* number of nested C calls */
  unsigned short baseCcalls;  /* nested C calls when resuming coroutine */
  lu_byte hookmask;
  lu_byte allowhook;
  int basehookcount;
  int hookcount;
  lua_Hook hook;
  TValue l_gt;  /* table of globals */
  TValue env;  /* temporary place for environments */
  GCObject *openupval;  /* list of open upvalues in this stack */
  GCObject *gclist;
  struct lua_longjmp *errorJmp;  /* current error recover point */
  ptrdiff_t errfunc;  /* current error handling function (stack index) */
};

lua_State是围绕程序如何执行来设计的，数据栈和调用栈都在其中。
其中：

/*
** Common Header for all collectable objects (in macro form, to be
** included in other objects)
*/
#define CommonHeader GCObject *next; lu_byte tt; lu_byte marked

所有可回收的对象都有这个结构

(2)全局状态机
共享的一块全局数据 global_state

/*
** `global state', shared by all threads of this state
*/
typedef struct global_State {
  stringtable strt;  /* hash table for strings */
  lua_Alloc frealloc;  /* function to reallocate memory */
  void *ud;         /* auxiliary data to `frealloc' */
  lu_byte currentwhite;
  lu_byte gcstate;  /* state of garbage collector */
  int sweepstrgc;  /* position of sweep in `strt' */
  GCObject *rootgc;  /* list of all collectable objects */
  GCObject **sweepgc;  /* position of sweep in `rootgc' */
  GCObject *gray;  /* list of gray objects */
  GCObject *grayagain;  /* list of objects to be traversed atomically */
  GCObject *weak;  /* list of weak tables (to be cleared) */
  GCObject *tmudata;  /* last element of list of userdata to be GC */
  Mbuffer buff;  /* temporary buffer for string concatentation */
  lu_mem GCthreshold;
  lu_mem totalbytes;  /* number of bytes currently allocated */
  lu_mem estimate;  /* an estimate of number of bytes actually in use */
  lu_mem gcdept;  /* how much GC is `behind schedule' */
  int gcpause;  /* size of pause between successive GCs */
  int gcstepmul;  /* GC `granularity' */
  lua_CFunction panic;  /* to be called in unprotected errors */
  TValue l_registry;
  struct lua_State *mainthread;
  UpVal uvhead;  /* head of double-linked list of all open upvalues */
  struct Table *mt[NUM_TAGS];  /* metatables for basic types */
  TString *tmname[TM_N];  /* array with tag-method names */
} global_State;

从 lua 的使用者的角度看，global_state 是不可见的。我们无法用公开的 api 取到它的指针，也不需要引用它。但分析lua 的实现就不能绕开这个部分。
global_state  里面有对主线程的引用，有注册表管理所有全局数据，有全局字符串表，有内存管理函数，有GC 需要的把所有对象串联起来的相关信息，以及一切 lua 在工作时需要的工作内存。
通过 lua_newstate 创建一个新的 lua 虚拟机时，第一块申请的内存将用来保存主线程和这个全局状态机。lua 的实现尽可能的避免内存碎片，同时也减少内存分配和释放的次数。它采用了一个小技巧，利用一个 LG 结构，把主线程 lua_state 和 global_state 分配在一起。
源代码lua5.1.4  lstate.c （35行）

/*
** Main thread combines a thread state and the global state
*/
typedef struct LG {
  lua_State l;
  global_State g;
} LG;

lua_newstate 这个公开 API  定义在 lstate.c中，它初始化了所有 global_state 中将引用的数据。


源代码lua5.1.4 lstate.c （143行）

LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
  int i;
  lua_State *L;
  global_State *g;
  void *l = (*f)(ud, NULL, 0, state_size(LG));
  if (l == NULL) return NULL;
  L = tostate(l);
  g = &((LG *)L)->g;
  L->next = NULL;
  L->tt = LUA_TTHREAD;
  g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
  L->marked = luaC_white(g);
  set2bits(L->marked, FIXEDBIT, SFIXEDBIT);
  preinit_state(L, g);
  g->frealloc = f;
  g->ud = ud;
  g->mainthread = L;
  g->uvhead.u.l.prev = &g->uvhead;
  g->uvhead.u.l.next = &g->uvhead;
  g->GCthreshold = 0;  /* mark it as unfinished state */
  g->strt.size = 0;
  g->strt.nuse = 0;
  g->strt.hash = NULL;
  setnilvalue(registry(L));
  luaZ_initbuffer(L, &g->buff);
  g->panic = NULL;
  g->gcstate = GCSpause;
  g->rootgc = obj2gco(L);
  g->sweepstrgc = 0;
  g->sweepgc = &g->rootgc;
  g->gray = NULL;
  g->grayagain = NULL;
  g->weak = NULL;
  g->tmudata = NULL;
  g->totalbytes = sizeof(LG);
  g->gcpause = LUAI_GCPAUSE;
  g->gcstepmul = LUAI_GCMUL;
  g->gcdept = 0;
  for (i=0; imt[i] = NULL;
  if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {
    /* memory allocation error: free partial state */
    close_state(L);
    L = NULL;
  }
  else
    luai_userstateopen(L);
  return L;
}

2、执行状态机的数据栈和调用栈
以下是分析 lua_state 中重要的两个数据结构：数据栈和调用栈。
(1) 数据栈
lua 中的数据可以这样分为两类：值类型和引用类型。值类型可以被任意复制，而引用类型共享一份数据，由 GC 负责维护生命期。lua 使用一个联合 union Value 来保存数据


lobject.h （59行）

/*
** Union of all Lua values
*/
typedef union {
  GCObject *gc;
  void *p;
  lua_Number n;
  int b;
} Value;

从这里我们可以看到，引用类型用一个指针 GCObject *gc 来间接引用，而其它值类型都直接保存在联
合中。为了区分联合中存放的数据类型，再额外绑定一个类型字段。

#define TValuefields Value value; int tt

typedef struct lua_TValue {
  TValuefields;
} TValue;

lua_state 的数据栈，就是一个 TValue 的数组。代码中用 StkId 类型来指代对 TValue 的引用。

typedef TValue *StkId; /* index to stack elements */

在 lstate.c 中，我们可以读到对堆栈的初始化及释放的代码。
源代码lua5.1.4  lstate.c(42行)

static void stack_init (lua_State *L1, lua_State *L) {
  /* initialize CallInfo array */
  L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);//lua的调用栈
  L1->ci = L1->base_ci;
  L1->size_ci = BASIC_CI_SIZE;
  L1->end_ci = L1->base_ci + L1->size_ci - 1;
  /* initialize stack array */
  L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue);//lua的数据栈
  L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK;
  L1->top = L1->stack;
  L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;
  /* initialize first ci */
  L1->ci->func = L1->top;//当前调用栈 的函数初始化为当前数据栈顶
  setnilvalue(L1->top++);  /* `function' entry for this `ci' */
  L1->base = L1->ci->base = L1->top;
  L1->ci->top = L1->top + LUA_MINSTACK;
}

static void freestack (lua_State *L, lua_State *L1) {
  luaM_freearray(L, L1->base_ci, L1->size_ci, CallInfo);
  luaM_freearray(L, L1->stack, L1->stacksize, TValue);
}

一开始，数据栈的空间很有限，只有 2 倍的 LUA_MINSTACK 的大小.

# define BASIC_STACK_SIZE (2*LUA_MINSTACK)
#define LUA_MINSTACK 20

数据栈不够用的时候，可以扩展。这种扩展是用 realloc 实现的，每次至少分配比原来大一倍的空间，并
把旧的数据复制到新空间。

void luaD_growstack (lua_State *L, int n) {
  if (n <= L->stacksize)  /* double size is enough? */
    luaD_reallocstack(L, 2*L->stacksize);
  else
    luaD_reallocstack(L, L->stacksize + n);
}
void luaD_reallocstack (lua_State *L, int newsize) {
  TValue *oldstack = L->stack;
  int realsize = newsize + 1 + EXTRA_STACK;
  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
  luaM_reallocvector(L, L->stack, L->stacksize, realsize, TValue);
  L->stacksize = realsize;
  L->stack_last = L->stack+newsize;
  correctstack(L, oldstack);
}

数据栈扩展的过程，伴随着数据拷贝。这些数据都是可以直接值复制的，所以不需要在扩展之后修正其中的指针。 

但，有些外部结构对数据栈的引用需要修正为正确的新地址。 这些需要修正的位置包括 upvalue以及调用栈对数据栈的引用。这个过程由 correctstack 函数实现。

源代码lua5.1.4   ldo.c（126行） 

static void correctstack (lua_State *L, TValue *oldstack) {
  CallInfo *ci;
  GCObject *up;
  L->top = (L->top - oldstack) + L->stack;
  for (up = L->openupval; up != NULL; up = up->gch.next)//修正upvalue
    gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;
  for (ci = L->base_ci; ci <= L->ci; ci++) {//拷贝当前调用栈(修正调用栈)
    ci->top = (ci->top - oldstack) + L->stack;
    ci->base = (ci->base - oldstack) + L->stack;
    ci->func = (ci->func - oldstack) + L->stack;
  }
  L->base = (L->base - oldstack) + L->stack;//拷贝当前函数（修正当前函数）
}

(2)调用栈
lua 把调用栈和数据栈分开保存。调用栈放在一个叫做 CallInfo 的结构中，以数组的形式储存在虚拟机对象（线程对象）里。
源代码lua 5.1.4 lstate.h (48行)

/*
** informations about a call
*/
typedef struct CallInfo {
  StkId base;  /* base for this function */
  StkId func;  /* function index in the stack */
  StkId top;  /* top for this function */
  const Instruction *savedpc;
  int nresults;  /* expected number of results from this function */
  int tailcalls;  /* number of tail calls lost under this entry */
} CallInfo;

正在调用的函数一定存在于数据栈上，在 CallInfo 结构中，func 指向正在执行的函数在数据栈上的位置。需要记录这个信息，是因为如果当前是一个 lua 函数，且传入的参数个数不定的时候，需要用这个位置和当前数据栈底的位置相减，获得不定参数的准确数量.。（参考 http://blog.csdn.net/chenjiayi_yun/article/details/8877235 lua虚拟机的体系结构）

同时，func 还可以帮助我们调试嵌入式 lua 代码。在用 gdb这样的调试器调试代码时，可以方便的查看 C 中的调用栈信息，但一旦嵌入 lua ，我们很难理解运行过程中的 lua 代码的调用栈。不理解 lua 的内部结构，就可能面对一个简单的lua_state L 变量束手无策。

通过访问 func 引用的函数对象来了解函数是 C 函数还是 Lua 函数。

实际上，遍历 L 中的 base_ci域指向的 CallInfo 数组可以获得完整的 lua 调用栈。而每一级的 CallInfo 中，都可以进一步的通过 func 域取得所在函数的更详细信息。当 func 为一个 lua 函数时，根据它的函数原型可以获得源文件名、行号等诸多调试信息。

CallInfo 是一个标准的数组结构（lua5.1.4）,压栈时需要重新分配栈数组的内存。这个数组表达的是一个逻辑上的栈。

#define inc_ci(L) \
  ((L->ci == L->end_ci) ? growCI(L) : \
   (condhardstacktests(luaD_reallocCI(L, L->size_ci)), ++L->ci))

特别的，lua5.2以后进行了优化，调用栈修改成 双向链表，不直接被GC 模块管理，在运行过程中，并不是每次调入更深层次的函数，就立刻构造出一个CallInfo 节点。整个调用栈 CallInfo链表会在运行中被反复复用。直到 GC 的时候才清理那些比当前调用层次更深的无用节点。