lua协程实现及field访问的一个细节

intro

由于C不支持协程，C++只有在最近的C++标准(C++20)中才支持协程，如果希望在C++中支持协程通常需要使用第三方库。针对这种问题，可能有些实现在C++中嵌入lua脚本，利用lua的原生协程机制来达到协程效果；或者干脆使用go这种内置包含了协程的语言。

协程

问题

• 私有堆栈

协程的一个关键特性就是当“异步”，当执行某个流程的时候，在某个位置切出去，之后再切回来。由于一个执行流执行的时候，很多信息是在堆栈中保存的(包括调用关系)，切换前后需要有相同的堆栈，所以协程必须有自己的单独堆栈。

• 切换

当每个协程有了自己的私有堆栈之后，剩余的问题就是yield的时候，控制流转到哪里？这个问题其实相对比较简单，以内核的进程切换为例：当切换的时候其实就是跳转到schedule函数。go的运行时应该也是类似，yield就是执行流切换到调度器来选择下一个可以运行的协程。

实现

• 私有堆栈

为了让实现能够感知到需要创建一个协程，必须通过某种方法声明一个协程。这个在lua中通过coroutine.create；在go中通过go关键字；C++20使用的貌似是无栈协程，这种实现由于没有堆栈，不太容易实现复杂的逻辑，使用也不太友好。

这里关键的意思是：lua/go使用协程的时候都要先声明，这个声明让语言可以为这个协程准备私有堆栈。

static int luaB_cocreate (lua_State *L) {
  lua_State *NL;
  luaL_checktype(L, 1, LUA_TFUNCTION);
  NL = lua_newthread(L);
  lua_pushvalue(L, 1);  /* move function to top */
  lua_xmove(L, NL, 1);  /* move function from L to NL */
  return 1;
}

• 协程入口

和私有堆栈对应的，有一个单独协程入口函数的概念：用来决定从哪个函数开始，函数的堆栈放在这些私有堆栈上。

• 切换

lua线程创建之后并不会立即运行，而是需要通过resume开始运行，当执行resume函数时，运行时会通过setjmp设置一个跳转点，coroutine执行到yield的时候直接longjmp到resume即可恢复resume的执行。

也就是说，lua的yield并不是返回到某个调度器，而是返回到了resume位置，因为协程创建/yield之后必须通过resume恢复执行。

对应的跳转结构为

/* ISO C handling with long jumps */
#define LUAI_THROW(L,c)		longjmp((c)->b, 1)
#define LUAI_TRY(L,c,a)		if (setjmp((c)->b) == 0) { a }
#define luai_jmpbuf		jmp_buf

#endif							/* } */

当resume时，通过LUAI_TRY保存当前位置。

int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
  l_uint32 oldnCcalls = L->nCcalls;
  struct lua_longjmp lj;
  lj.status = LUA_OK;
  lj.previous = L->errorJmp;  /* chain new error handler */
  L->errorJmp = &lj;
  LUAI_TRY(L, &lj,
    (*f)(L, ud);
  );
  L->errorJmp = lj.previous;  /* restore old error handler */
  L->nCcalls = oldnCcalls;
  return lj.status;
}

当yield时，会通过longjmp跳转到resume(LUAI_THROW)设置的位置。也就是说，协程主要是被resume驱动的，执行流执行resume来调用协程逻辑，协程yield之后返回到resume。

l_noret luaD_throw (lua_State *L, int errcode) {
  if (L->errorJmp) {  /* thread has an error handler? */
    L->errorJmp->status = errcode;  /* set status */
    LUAI_THROW(L, L->errorJmp);  /* jump to it */
  }
  else {  /* thread has no error handler */
    global_State *g = G(L);
    errcode = luaE_resetthread(L, errcode);  /* close all upvalues */
    if (g->mainthread->errorJmp) {  /* main thread has a handler? */
      setobjs2s(L, g->mainthread->top.p++, L->top.p - 1);  /* copy error obj. */
      luaD_throw(g->mainthread, errcode);  /* re-throw in main thread */
    }
    else {  /* no handler at all; abort */
      if (g->panic) {  /* panic function? */
        lua_unlock(L);
        g->panic(L);  /* call panic function (last chance to jump out) */
      }
      abort();
    }
  }
}

栗子

在lua中，创建一个协程并不会立即执行，需要使用resume启动第一次运行。

lua

tsecer@harry: cat no_resume.lua 
co = coroutine.create(function ()
   print("hello world")
end)

tsecer@harry: lua no_resume.lua
tsecer@harry: 

go

golang中当通过go启动一个协程的时候，协程立即开始执行。

tsecer@harry: cat gofunc.go 
package main

import (
    "fmt"
    "sync"
)

func hi(wg* sync.WaitGroup) {
    defer wg.Done()
    fmt.Println("hello world")
}

func main() {
    var wg sync.WaitGroup

    wg.Add(1)
    go hi(&wg)
    wg.Wait()
}

tsecer@harry: go run gofunc.go      
hello world
tsecer@harry: 

python

python的coroutine也明确说明了创建一些协程之后并不会立即执行：

Note that simply calling a coroutine will not schedule it to be executed:

>>>  
main()  
<coroutine object main at 0x1053bb7c8>  

To actually run a coroutine, asyncio provides the following mechanisms:

• The asyncio.run() function to run the top-level entry point “main()” function (see the above example.)

• Awaiting on a coroutine. The following snippet of code will print “hello” after waiting for 1 second, and then print “world” after waiting for another 2 seconds:

在python的源代码中，大致可以看到，await的实现思路和lua大致相同：也是转换为了设置跳转点，然后执行RESUME的模式

static int
compiler_add_yield_from(struct compiler *c, location loc, int await)
{
    NEW_JUMP_TARGET_LABEL(c, send);
    NEW_JUMP_TARGET_LABEL(c, fail);
    NEW_JUMP_TARGET_LABEL(c, exit);

    USE_LABEL(c, send);
    ADDOP_JUMP(c, loc, SEND, exit);
    // Set up a virtual try/except to handle when StopIteration is raised during
    // a close or throw call. The only way YIELD_VALUE raises if they do!
    ADDOP_JUMP(c, loc, SETUP_FINALLY, fail);
    ADDOP_I(c, loc, YIELD_VALUE, 1);
    ADDOP(c, NO_LOCATION, POP_BLOCK);
    ADDOP_I(c, loc, RESUME, await ? RESUME_AFTER_AWAIT : RESUME_AFTER_YIELD_FROM);
    ADDOP_JUMP(c, loc, JUMP_NO_INTERRUPT, send);

    USE_LABEL(c, fail);
    ADDOP(c, loc, CLEANUP_THROW);

    USE_LABEL(c, exit);
    ADDOP(c, loc, END_SEND);
    return SUCCESS;
}

反编译验证

tsecer@harry: cat await_disas.py 
import time
import asyncio
async def foo():
    await asyncio.sleep(1234)

tsecer@harry: ../python -m dis await_disas.py 
  0           RESUME                   0

  1           LOAD_CONST               0 (0)
              LOAD_CONST               1 (None)
              IMPORT_NAME              0 (time)
              STORE_NAME               0 (time)

  2           LOAD_CONST               0 (0)
              LOAD_CONST               1 (None)
              IMPORT_NAME              1 (asyncio)
              STORE_NAME               1 (asyncio)

  3           LOAD_CONST               2 (<code object foo at 0x7f2563275a60, file "await_disas.py", line 3>)
              MAKE_FUNCTION
              STORE_NAME               2 (foo)
              RETURN_CONST             1 (None)

Disassembly of <code object foo at 0x7f2563275a60, file "await_disas.py", line 3>:
   3           RETURN_GENERATOR
               POP_TOP
       L1:     RESUME                   0

   4           LOAD_GLOBAL              0 (asyncio)
               LOAD_ATTR                2 (sleep)
               PUSH_NULL
               LOAD_CONST               1 (1234)
               CALL                     1
               GET_AWAITABLE            0
               LOAD_CONST               0 (None)
       L2:     SEND                     3 (to L5)
       L3:     YIELD_VALUE              1
       L4:     RESUME                   3
               JUMP_BACKWARD_NO_INTERRUPT 5 (to L2)
       L5:     END_SEND
               POP_TOP
               RETURN_CONST             0 (None)
       L6:     CLEANUP_THROW
       L7:     JUMP_BACKWARD_NO_INTERRUPT 5 (to L5)

  --   L8:     CALL_INTRINSIC_1         3 (INTRINSIC_STOPITERATION_ERROR)
               RERAISE                  1
ExceptionTable:
  L1 to L3 -> L8 [0] lasti
  L3 to L4 -> L6 [2]
  L4 to L7 -> L8 [0] lasti
tsecer@harry: 

unix

如果把操作系统的fork看做协程所模拟的原始语义，那么fork也是类似于go的予以，在创建协程/进程的同时启动执行；而反观lua/go两种脚本语言，它们协程的实现都是先创建但是不执行，而是需要使用专门的指令(Resume)等来启动协程运行。

这或许是go和Linux的作者都是Ken Thompson，所以go继承了unix操作系统的实现思想？或者有其它更深层的原因？

field访问

在lua中，obj[xxx]和obj.xxx具有相同的效果，都是访问obj的xxx字段，但是在使用的时候有一个微妙的差别：

通过dot访问的时候field名字是编译时确定的，而[]则会运行时求值。如果一个field是在运行时计算出来的，必须使用[]这种方式。

在解析时，如果是dot访问，只是作为一个字符串来处理，如果是[]格式，则会作为表达式解析。

static void suffixedexp (LexState *ls, expdesc *v) {
  /* suffixedexp ->
       primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */
  FuncState *fs = ls->fs;
  primaryexp(ls, v);
  for (;;) {
    switch (ls->t.token) {
      case '.': {  /* fieldsel */
        fieldsel(ls, v);
        break;
      }
      case '[': {  /* '[' exp ']' */
        expdesc key;
        luaK_exp2anyregup(fs, v);
        yindex(ls, &key);
        luaK_indexed(fs, v, &key);
        break;
      }
      case ':': {  /* ':' NAME funcargs */
        expdesc key;
        luaX_next(ls);
        codename(ls, &key);
        luaK_self(fs, v, &key);
        funcargs(ls, v);
        break;
      }
      case '(': case TK_STRING: case '{': {  /* funcargs */
        luaK_exp2nextreg(fs, v);
        funcargs(ls, v);
        break;
      }
      default: return;
    }
  }
}

两种方式的区别在于是否运行时求值

static void fieldsel (LexState *ls, expdesc *v) {
  /* fieldsel -> ['.' | ':'] NAME */
  FuncState *fs = ls->fs;
  expdesc key;
  luaK_exp2anyregup(fs, v);
  luaX_next(ls);  /* skip the dot or colon */
  codename(ls, &key);
  luaK_indexed(fs, v, &key);
}


static void yindex (LexState *ls, expdesc *v) {
  /* index -> '[' expr ']' */
  luaX_next(ls);  /* skip the '[' */
  expr(ls, v);
  luaK_exp2val(ls->fs, v);
  checknext(ls, ']');
}

outro

lua虽小，五脏俱全，体现了很多大型语言的核心实现方法。