C++博客-右席的搬砖日记-随笔分类-Luajit

自撸web小框架 dodolu(基于nginx lua) + lua debugger

右席 — Mon, 22 Dec 2014 10:22:00 GMT

背景

前段时间项目需要一个点击服务，大致是要根据用户请求的url及数据库中的规则，匹配出一个结果并记录日志。最开始是一个很小的需求，结果业务越来越复杂，业务逻辑中经常要处理header头和一些其他的信息，导致代码越来越混乱。在一期结束之后，抽时间把这段时间的工作抽象出了一个轻量级框架，只做了适量的封装，加入了代码生成的模块，可以帮助开发者迅速做出一个可用的web服务。

介绍

dodolu框架地址(Github)。

该框架只做了最小化的封装，几乎没有性能损失，并提供了根据配置文件(meta.lua)，自动生成route模块，nginx.conf配置，logger模块的功能，减轻了开发工作量，避免重复手写大量易错的配置或字符串变量，有助于多人开发统一风格。

详情Github的README

功能

包括三个部分，一个是web框架，一个是代码自动生成模块，一个是魔改出的lua远程调试器。

web框架部分

只有1k行以下的代码，集成了resty.template、resty.cookie、UUID生成等第三方模块。提供request、response、context、util等库方便开发人员使用。

代码自动生成部分

可自动生成:

路由配置
日志记录模块
nginx.conf

主要目的在于解决nginx配置与lua代码的分离问题(在日志记录中尤为严重)。

开发人员新建应用步骤：在App文件夹下，新建lua文件，然后填入do_get()方法即可处理相应的get请求，所有配置在meta/meta.lua里面。

一个记录日志并返回1x1gif的例子：

-- 这个文件下面存放你的业务逻辑

-- 这个文件下面存放你的业务逻辑

local app = {}
function app.do_get(ctx) 
    local response = ctx.response
    local request = ctx.request
    local cookie = ctx.cookie

    response:set_content_type("text/html")
    local url = request.uri
    -- do some process

    ------------- write log ---------------
    -- my_log 日志模块是根据meta.lua自动生成的
    local logger = ctx.get_logger('my_log')  
    local log_data = { a = "xxx"}
    logger.write(log_data, other_params)

    ------------- return empty gif -------
    response:empty_gif()
    response:close()
end

function app.do_post(ctx) end
function app.do_put(ctx) end
function app.do_delete(ctx) end

return app

lua远程调试器

文档详细见这里，这里只演示下用法：
sh debug.sh，然后运行用户程序，成功后

Lua Remote Debugger
Run the program you wish to debug
Paused at file a.lua
Type 'help' for commands
>

下一步 n

n
Paused at file a.lua line 8
8: print("Start")
>

查看源码 l

> l
source file: a.lua
2:
3:   local tab = {
4:       foo = 1,
5:       bar = 2
6:   }
7:
8:>> print("Start")
9:
10:  local bb = require "b"
11:  bb.foo()
12:
13:  for i = 1, 10 do
14:      print("Loop")

设置断点 b : 查看 listb

> b a.lua:11
> listb
a.lua: 11

查看局部变量 local

> local
{
        ["tab"] = {
                {
                        ["bar"] = 2,
                        ["foo"] = 1,
                },
                "table: 0x2589ee0",
        },
}

查看变量 p tab

> p tab
{
["bar"] = 2,
["foo"] = 1,
}

继续执行，直到断点  r

> r
Paused at file a.lua line 11

右席 2014-12-22 18:22 发表评论

（二）Luajit中的好轮子DynASM

右席 — Sat, 30 Nov 2013 04:49:00 GMT

本人博客地址：http://www.cppblog.com/pwq1989/

上一篇对Luajit的代码结构和编译过程做了简单的描述，这一篇就讲一下buildvm在第一步预处理dasc文件的过程和DynASM这个轮子。

官方连接：http://luajit.org/dynasm.html

是为了让你更优雅的C里面撸汇编的一个工具，我记得以前看过一个老外的blog对比过同样功能的jit code generator的语法，Luajit的作者显然品位还是很高的。

我们先来看看如果不用工具硬生生撸代码的话会发生什么。
1、你往一段内存里面写0xB8,0x00,0x01....
2、你在文件里定义好多label，写个copy section的宏往内存里面复制，你还不能确定里面到底是什么。（哦。。这个的术语叫Threaded。。。）

然后再对比下AsmJit或者Xbyak的例子看看（他们的功能差不多），DynASM还提供了.marco实现，就会发现语法真是sweeeet~

这是我写着玩的一个草泥马语jit解释器（https://github.com/pwq1989/GMHjit）语法真是清新自然啊，如果你想看工业级的应用，可以看看Google的Haberman写的protobuf的upb库，里面用DynASM进行了jit，号称快了多少多少（不去考证了），或者是agentzh写的sregex正则库，也是用它做了jit。一般来说DSL配上jit的话一定会快很多就错不了了。

下面给一个DynASM的Demo程序（摘抄自这个blog）

1 // DynASM directives.
2 |.arch x64
3 |.actionlist actions
4
5 // This define affects "|" DynASM lines.  "Dst" must
6 // resolve to a dasm_State** that points to a dasm_State*.
7 #define Dst &state
8
9 int main(int argc, char *argv[]) {
10   if (argc < 2) {
11     fprintf(stderr, "Usage: jit1 \n");
12     return 1;
13   }
14
15   int num = atoi(argv[1]);
16   dasm_State *state;
17   initjit(&state, actions);
18
19   // Generate the code.  Each line appends to a buffer in
20   // "state", but the code in this buffer is not fully linked
21   // yet because labels can be referenced before they are
22   // defined.
23   //
24   // The run-time value of C variable "num" is substituted
25   // into the immediate value of the instruction.
26   |  mov eax, num
27   |  ret
28
29   // Link the code and write it to executable memory.
30   int (*fptr)() = jitcode(&state);
31
32   // Call the JIT-ted function.
33   int ret = fptr();
34   assert(num == ret);
35
36   // Free the machine code.
37   free_jitcode(fptr);
38
39   return ret;
40 }

预处理之后那就会变成这样子：

1 //|.arch x64
2 //|.actionlist actions
3 static const unsigned char actions[4] = {
4   184,237,195,255
5 };
6
7 // []
8
9 //|  mov eax, num
10 //|  ret
11 dasm_put(Dst, 0, num);

dasm_put就是把num参数和actions[]一起放入了Dst（#define Dst &state）的制定的内存中，这时候已经是机器码的形式了。
下面是对于acitons[]数组内容的解释：
184(B8)-- mov eax, [immediate] 指令的第一个字节
237 -- 内置的标志DASM_IMM_D, 指明应该放入一个4字节宽度的参数，与上一条指令完成一个MOV
195(C3)-- 对应ret指令
255 -- 内置的标志DASM_STOP

以上就是最简单的例子，dasm_growpc()是内置的函数，用来增长maxpc, 这样在程序里面就可以方便写出jmp => label 这样的指令了。

由于DynASM的文档很少，幸亏还有几个例子，除了例子唯一能看的就是源码了，所以在用的时候出现问题是很痛苦的。。当时写GMHjit就发现了蛋疼的pre-process period bug，后来绕过去了。

源码文件有这么几个
-- dynasm.lua
-- dynasm_proto.h
-- dynasm_*.lua
-- dynasm_*.h // * x64 x86 ppc mips arm 等target

用起来就是lua dynasm.lua a.dasm > a.h

下面就从dynasm.lua开始分析下他的源码

入口是parseargs函数，里面给的g_opt参数赋默认的值，一个repeat 中调用parseopt解析参数，opt_map就是option对args的函数映射。

函数wline，wcomment，wsync，wdumplines都是对输出的目标文件的操作。

真正的主函数是 translate，把input file变成 output file，在readfile中的doline函数是真正的处理过程，里面判断是否是Assembler line之后Emit C code，调用dostmt(aline)。里面继续有map_coreop[*]来处理section macro arch nop_ error_1 include if endif elseif 等关键字，想深入研究的可以自己去看，其中在loadarch中根据arch加载不同的lua库

如果arch是x64的话，本质还是require x86
来看dasm_x86.lua文件

_M.mergemaps这是关键的方法，设置了2个Map的元方法，然后返回，相当于是把方法绑定在table里面传递了出去。处理后文件中关键的actionlist[]数组和Dasm_put(Dst, ...)的输出就是这个lua文件的方法。

里面提供了很多dump方法，可以供我们遇到问题时候调试处理过程。

action_names就是以后生成的action_list中的内置标志定义，必须与dasm_x86.h中的enum定义一致。

表明了代表的参数和长度等信息。
这个文件里面所有的函数就是做了一件事，把你的 |... 这样子的代码处理成数组输出到目标文件中（我是汇编渣渣，里面貌似支持SSE2、3、4+，看不懂，等到以后看到traced jit的时候再去翻手册把）

预处理完成之后，就是#include "dasm_x86.h"，里面有最关键的dasm_State结构体的定义，几乎里面所有的函数都是对外的API，有init,setup,free等等，除去初始化与free之外，有三个步骤是需要出现在你都代码中：
1、dasm_put(Dst,...) 这个是自动生成的，不用我们操心，根据actionlist[]和运行时的参数写入到Dst指定的内存（Dst->section）中.
2、dasm_link() 第二个参数是返回的代码长度大小，这个函数把section合并到一起，处理偏移等等。
3、dasm_encode() 第二个参数是一个接受encode输出的buffer指针。

然后就可以用一个函数指针，比如声明一个 int (*f)(*int), int ret = f(param) 直接运行刚刚生成的机器码了。

右席 2013-11-30 12:49 发表评论

（一）初识Luajit

右席 — Thu, 28 Nov 2013 11:23:00 GMT

本人博客地址：http://www.cppblog.com/pwq1989/

第一篇对Luajit做一个大概的介绍，我目前也正在慢慢的读通源码中，以后发现了新东西就补充在这里。

大家可以从官网下载到源码（http://luajit.org/），也可以从Github（https://github.com/LuaDist/luajit）down下来，顺便还可以看下commit记录。

大家对着luajit的wiki结合源码看的话会更好些，因为。。文档太特么少了！！

目录结构：
-- src
-- host
-- jit
*.c
*.h
*.dasc
等等，别的不是很重要

最开始我是从main函数开始看的，然后。。碰了一鼻子灰，后来研究下他的makefile，发现他是这样子的编译的，贴一下关键的msvcbuild.bat的代码（这个更容易看懂）

1 :X64
2 minilua %DASM% -LN %DASMFLAGS% -o host\buildvm_arch.h vm_x86.dasc
3 @if errorlevel 1 goto :BAD
4
5 %LJCOMPILE% /I "." /I %DASMDIR% host\buildvm*.c
6 @if errorlevel 1 goto :BAD
7 %LJLINK% /out:buildvm.exe buildvm*.obj
8 @if errorlevel 1 goto :BAD
9 if exist buildvm.exe.manifest^
10 %LJMT% -manifest buildvm.exe.manifest -outputresource:buildvm.exe
11
12 buildvm -m peobj -o lj_vm.obj
13 @if errorlevel 1 goto :BAD
14 buildvm -m bcdef -o lj_bcdef.h %ALL_LIB%
15 @if errorlevel 1 goto :BAD
16 buildvm -m ffdef -o lj_ffdef.h %ALL_LIB%
17 @if errorlevel 1 goto :BAD
18 buildvm -m libdef -o lj_libdef.h %ALL_LIB%
19 @if errorlevel 1 goto :BAD
20 buildvm -m recdef -o lj_recdef.h %ALL_LIB%
21 @if errorlevel 1 goto :BAD
22 buildvm -m vmdef -o jit\vmdef.lua %ALL_LIB%
23 @if errorlevel 1 goto :BAD
24 buildvm -m folddef -o lj_folddef.h lj_opt_fold.c
25 @if errorlevel 1 goto :BAD

先创建了一个buildvm.exe的中间工具，来自动生成代码，分别生成了lj_vm.obj，lj_bcdef.h，lj_ffdef.h ，lj_recdef.h ，jit\vmdef.lua，lj_folddef.h， lj_libdef.h

其中lv_vm.obj是依赖于host\buildvm_arch.h的，这个是用DynASM预处理vm_x86.dasc生成的，这个工具的具体分析会在下一篇博客提及。

先来看下上面自动生成的代码：
lj_bcdef.h:

1 LJ_DATADEF const uint16_t lj_bc_ofs[] = {
2 0,
3 71,
4 142,
5 213,
6 284,
7
8 };
9
10 LJ_DATADEF const uint16_t lj_bc_mode[] = {
11 BCDEF(BCMODE)
12 BCMODE_FF,
13 BCMODE_FF,
14 BCMODE_FF,
15 BCMODE_FF,
16 BCMODE_FF,
17
18 };

lj_bc_ofs[]可能是bc在vm代码段中的偏移量（这个我还没深入进去调试一下），vm的一部分是用DynASM直接撸汇编撸出来的，wiki中也有提到下一步jit化的opcode等等。

lj_bc_mode[]的用来根据压缩后的bytecode构造，分离出操作数，第一行的两个宏的定义是

#define BCMODE(name, ma, mb, mc, mm) \

(BCM##ma|(BCM##mb<<3)|(BCM##mc<<7)|(MM_##mm<<11)),

#define BCMODE_FF 0

#define BCDEF(_) \

/* Comparison ops. ORDER OPR. */ \

_(ISLT, var, ___, var, lt) \

_(ISGE, var, ___, var, lt) \

_(ISLE, var, ___, var, le) \

_(ISGT, var, ___, var, le) \
...
总之就是充斥着各种拼接起来的宏

lj_ffdef.h:

1 FFDEF(assert)
2 FFDEF(type)
3 FFDEF(next)
4 FFDEF(pairs)
5 FFDEF(ipairs_aux)
6

FFDEF的定义是在

1 /* Fast function ID. */
2 typedef enum {
3   FF_LUA_ = FF_LUA,    /* Lua function (must be 0). */
4   FF_C_ = FF_C,        /* Regular C function (must be 1). */
5 #define FFDEF(name)    FF_##name,
6 #include "lj_ffdef.h"
7   FF__MAX
8 } FastFunc;

差不多就是用FF_##name把上面的名字拼接起来，然后生成在enum里面，这样就能当成是数字，在数组中迅速找到入口了

vmdef.lua:
这个里面内容就不贴了，包括bcname,irname,irfpm,irfield,ircall 的定义，在jit文件夹下面，用于调试等，比如在dump.lua中就有用到

local jit = require("jit")
assert(jit.version_num == 20002, "LuaJIT core/library version mismatch")
local jutil = require("jit.util")
local vmdef = require("jit.vmdef") // ← ← ← ←

当你用luajit -jdump的时候，就是调用的lua的jit库里面的lua函数

lj_recdef.h:

1 static const uint16_t recff_idmap[] = {
2 0,
3 0x0100,
4 0x0200,
5 0x0300,
6 0,
7 0,
8 0x0400,
9
10 };
11
12 static const RecordFunc recff_func[] = {
13 recff_nyi,
14 recff_c,
15 recff_assert,
16 recff_type,
17 recff_ipairs_aux,
18
19 };

其中recff_func[]是被注册的被traced jit 跟踪的函数，具体可是在lj_ffrecord.c里面看到
recff_idmap[]被用在lj_ffrecord_func这个函数中，有一个关键的数据结构RecordFFData，用来记录在trace过程中被调用函数的参数和返回值个数，和一些辅助数据，opcode，literal等等。通过recff_idmap[]保存的值来区分函数（待仔细研究）

lj_folddef.h:

1 static const FoldFunc fold_func[] = {
2   fold_kfold_numarith,
3   fold_kfold_ldexp,
4   fold_kfold_fpmath,
5   fold_kfold_numpow,
6
7 };
8
9 static const uint32_t fold_hash[916] = {
10 0xffffffff,
11 0xffffffff,
12 0x5b4c8016,
13
14 };

用在FOLD optimization中，见lj_opt_fold.c，主要在

1 if ((fh & 0xffffff) == k || (fh = fold_hash[h+1], (fh & 0xffffff) == k)) {
2       ref = (IRRef)tref_ref(fold_func[fh >> 24](J));
3       if (ref != NEXTFOLD)
4     break;
5     }

是根据数组偏移获取函数，直接执行。
（这个Optimation略复杂，以后的博文中再说）

----------------------------------------分割线-------------------------------------------

以上就是buildvm生成代码，在很多.c的文件中，他加入了一些无意义的MARCO，目的是为了能被buildvm识别出

下面说说src根目录下面的文件：

lauxlib.h：
用户开发扩展和与C交互的时候的头文件

lib_*.h /.c:
顾名思义，就是利用LuaAPI写的内部标准库，会在方法上表明是否会被trace ( LJLIB_REC(.) )。

ljamalg.c:
文件的合并

lj_alloc.h /.c:
定制的Memory Allocator

lj_api.c:

Public Lua/C API.

lj_arch.h:

Target architecture selection

lj_jit.h:
jit编译器里面数据结构的定义

lj_asm.h/ .c lj_asm_*.c lj_emit_*.h lj_target_*.h/.c :
将IR编译成Machine Code，关键的数据结构ASMState，线性扫描的O(n2)分配算法

lj_bc.h/ .c：
Luajit字节码的定义和内存布局

lj_bcdump.c lj_bcread.c lj_bcwrite.c:
围绕着字节码的操作

lj_carith.c:

C实现的一些数字运算

lj_ccall.h/ .c lj_ccallback.h / .c :
FFI C语言函数调用和回调绑定

lj_debug.h/.c :
调试与自省用

lj_def.h:
这个很重要，重要的类型和一些宏定义在这里

lj_c*.h/ .c:
和C语言先关的，比如类型转化，char管理，数据管理

lj_frame.h:
Luajit的栈帧管理

lj_func.h/.c:
Function handle和闭包有关的upvalue数据结构

lj_gc.h/.c:
GC相关，GC可以看下luajit的wiki，里面涉及不少增量式GC的paper和作者的看法

lj_gdbjit.h/.c :
对gdb的支持

lj_ir*.h/.c:
SSA，IR相关（这个和bytecode还是不一样的）操作和优化

lj_lex.h/.c lj_parse.h/.c:
lexer和parser

lj_mcode.h/.c:
Machine Code管理

lj_opt_*.h:
各种bytecode层面上的优化

lj_snap.h/.c:
快照支持

lj_state.h/.c:
LuaState和Stack的操作

lj_str*.h/.c lj_tab.h/.c:
原生类型string和table操作

lj_udata.h/.c:
类型user data的操作

lj_vm.h/.c lj_vmevent.h/.c:
vm的API和事件注册（lj_vmevent_send）

lj_vmmath.h/.c：
对vm支持的math库

lua.h:
luaState等基本的Lua结构

lualib.h:
和Lua一样，标准库的API

luajit.h:
luajit 的public API

vm_*.dasc:
编译期被DynASM预处理的源文件，下一篇讲DynASM时候介绍dasc文件

wmain.c:
windows下面的main入口

和Trace相关的：
lj_crecord.h/.c ： C操作的trace record
lj_dispatch.h/.c : 指令分发，调用ASMFuction，处理指令前的hook和记录trace用的hot count，有一个重要的数据结构 GG_State
lj_ff*.h/.c: 上面讲lj_ffdef.h的时候提过，trace的时候记录Fast Function的调用记数
lj_trace.h/.c: trace的具体过程
lj_traceerr.h : trace error

右席 2013-11-28 19:23 发表评论