redis源码学习之lua执行原理

聊聊redis执行lua原理

 

 

从一次面试场景提及

 

“看你简历上写的精通redis”

“额，还能够啦”

“那你说说redis执行lua脚本的原理”

“这个，这个，不就是那么执行的吗，eval 一段lua脚本就好了”

“好的，了解了，今天面试先到这个吧，后续有消息会通知你”

“好的，祝您生活愉快”

 

 

 

面试场景纯属娱乐，但这个面试题确实是笔者真实遇到过的，今天咱们就来看看redis执行lua脚本的原理，但愿经过本篇学习能够解决心中的困惑，更深层次的讲能够了解到两种不一样语言沟通的一点思想，我以为这个是最宝贵的。

 

名词解释

redis：一个高性能的k，v数据库，基于C语言编写；

lua：一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放， 其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。

 

需求缘起

首先说说什么场景下须要用到lua脚本，当你想一次执行一批redis指令并且又不但愿中途被其余指令打断的时候，也许有人说pipeline不香吗？是的，pipeline也是一种提升性能的方法，可是它自身有两个特色在某些场景下是没法替代lua脚本的，其一：pipeline的执行是没法保证原子性的；其二：pipeline多条指令之间是没法共享上下文的，这个怎么理解呢，好比pipeline中包括A，B两条指令，若是B指令须要依赖A指令的执行结果，这时是没法获取到的，举个简单例子以下：

判断key1是否等于value1，若是等于就删除key1，不然什么都不作。

按正常思惟这个代码很简单，两行代码搞定

if "value1".equals(jedis.get("key1") { //@1
  jedis.del("key1")                  //@2
}

　　

可是老司机一看就会说这个是有问题的，由于@1和@2之间有可能会插入其余指令，好比jedis.set("key1","value2")，那怎么解决呢，很简单，直接一段lua脚本完事，以下：

if redis.call("get",KEYS[1]) == ARGV[1]
then
    return redis.call("del",KEYS[1])
else
    return 0
end

　　

初识eval api

EVAL script numkeys key [key ...] arg [arg ...]

从 Redis 2.6.0 版本开始，经过内置的 Lua 解释器，可使用 EVAL 命令对 Lua 脚本进行求值。

script 参数是一段 Lua  脚本程序，它会被运行在 Redis 服务器上下文中，这段脚本没必要(也不该该)定义为一个 Lua 函数。

numkeys 参数用于指定键名参数的个数。

键名参数 key [key ...] 从 EVAL 的第三个参数开始算起，表示在脚本中所用到的那些 Redis 键(key)，这些键名参数能够在 Lua 中经过全局变量 KEYS 数组，用 1 为基址的形式访问( KEYS[1] ， KEYS[2] ，以此类推)。

在命令的最后，那些不是键名参数的附加参数 arg [arg ...] ，能够在 Lua 中经过全局变量 ARGV 数组访问，访问的形式和 KEYS 变量相似( ARGV[1] 、 ARGV[2] ，诸如此类)。

上面这几段长长的说明能够用一个简单的例子来归纳：

eval "return redis.call('set',KEYS[1],'bar')" 1 foo

　　

执行流程初探

上面提到经过eval 指令来执行一段lua脚本，如今就来看看具体的执行流程是什么样的，先放一张redis执行指令的总体流程，对执行过程感兴趣的能够参考我另外一篇文章redis工做流程初探。

 

 

如今从上图中6.1开始看起，redis根据命令执行相应的函数，eval对应的函数是evalCommand，看下evalCommand的大致流程。

 

 

 

这里先放一个最简化的流程图，随着过程深刻慢慢丰富这个流程。

 

看完这个简化流程，我这里先抛几个问题出来，后面一一解答。

1. 为何要根据script生成functionName？

2. 如何动态生成function？

3. 具体是如何执行function的？

剖析

上一节抛了三个问题出来，这节将一一解答。

问题1：为何要根据script生成functionName？

lua虽然能够直接执行语句，可是Lua开放给C调用的接口是以函数为单位，因此这里须要为script生成一个函数名称，具体生成逻辑能够简单理解为对script采用sha1算法生成的哈希串。

 

问题2：如何动态生成function？

首先看下lua中的函数定义格式以下：

function 方法名(参数1，参数2)
  return 结果
end

　　

假设执行eval "redis.call('get','aaaa')" 0

那么会根据如下规则生成function的字符串定义：

1. 根据script生成functionName，值为f_c1e0a03d7d32d0ade6850909efd61f92337847a8；

2. 将script内容做为函数体；

 最终获得的结果是：

function f_7c6f28e03fe1da50a15a7396fd66d0927ee4f350() redis.call('get','aaa') end

　　

以上只是生成了function的字符串定义，真正要生成lua的函数还须要借助Lua供的函数lua_load

int lua_load (lua_State *L,
              lua_Reader reader,
              void *data,
              const char *chunkname);
Loads a Lua chunk. If there are no errors, lua_load pushes the compiled chunk as a Lua function on top of the stack. Otherwise, it pushes an error message. The return values of lua_load are:

lua_load automatically detects whether the chunk is text or binary, and loads it accordingly (see program luac).

The lua_load function uses a user-supplied reader function to read the chunk (see lua_Reader). The data argument is an opaque value passed to the reader function.

The chunkname argument gives a name to the chunk, which is used for error messages and in debug information (see §3.8).

　　

问题3：具体是如何执行function的？

经过前面的部分redis根据script已经动态生成了function，接下来就能够调用function了，这块是最核心的部分了。

 

整体来讲C语言调用Lua函数时须要借助Lua提供的lua_call接口

void lua_call (lua_State *L, int nargs, int nresults);

　　

这个接口一共须要三个参数，各自的含义以下：

L：lua_State类型变量，用来保存执行过程当中的状态，包括函数，参数，返回值等；

nargs：本次函数调用所须要的参数个数；

nresults：本地调用结束之后期待的返回值个数；

 

看到这儿仍是有一些懵逼，C究竟是怎么调用Lua函数的呢？对于两个异构系统的相互调用通常须要两个条件：

1. 存在一层适配层，这一层负责作相关的转换，对于C和Lua互调来讲，这一层由Lua底层实现，好比上面的luc_call，lua_load等等；

2. 须要某种通讯协议来达成共识，这样才能顺畅的交流；

而刚才提到的某种通讯协议在lua_call的接口说明中也提到了，具体以下：

首先，要调用的函数被压入栈；而后，该函数的参数按直接顺序入栈；也就是说，第一个参数先入栈。最后调用lua_call实现函数调用; nargs是您压入堆的参数数量。调用函数时，将从栈中弹出全部参数和函数。函数返回时，函数结果将被压入栈，函数结果以直接顺序被推入堆栈（第一个结果被首先推入），所以在调用以后，最后一个结果在堆栈顶部。

 

经过一组图描述下调用过程

 

 

 阶段1-加载函数

lua_load

　　

阶段2-函数入栈

lua_getglobal(luaState, funcname);

 

阶段3-参数入栈

lua_pushnil、lua_pushnumber、lua_pushstring等

　　

阶段4-函数调用

lua_call(luaState, 2, 1);//调用函数，该函数接收两个参数，最终一个返回值  

　

阶段5-获取返回值

lua_tostring(luaState, -1)//以字符串形式返回栈顶元素，也就是返回值

综上所述，C调用lua函数以前须要将要调用的函数，函数须要的参数入栈，最终使用lua_call来实现函数调用，调用时须要明确的指出本地调用的参数个数，返回值个数，看到这儿你可能会问，为何还须要指出参数个数、返回值个数呢？其实这就是所谓的通讯协议，通讯载体是一个栈，栈里面即放了函数，也放了函数参数，适配层（其实就是lua底层）如何知道函数在什么位置呢？执行完之后该返回几个结果呢（lua函数能够返回多个结果，但调用者可能不须要这么多）？这些都须要调用者明确的告诉适配层。　　

　

 

 这里放个C语言调用Lua的例子来帮助理解，代码以下：

#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>



int main(void){
  //定义一段lua函数
  char lua_func[] = "function hello(v) return v end";
  //建立luaState
  lua_State* L = luaL_newstate();
  
  //加载lua_func中内容为一个lua函数
  if (luaL_loadbuffer(L, lua_func, strlen(lua_func), "@user_script")){
    printf(lua_tostring(L, -1));
    return -1;
  }
  lua_pcall(L, 0, LUA_MULTRET, 0);

  //hello函数入栈
  lua_getglobal(L, "hello");
  //hello函数所需参数入栈
  lua_pushstring(L, "world");
  //使用lua_pcall调用hello函数，告诉它须要一个参数一个返回值
  if (lua_pcall(L, 1, 1, 0)){
    //若是调用失败输出错误信息，错误信息在栈的顶部，因此用lua_tostring(L,-1)
    printf(lua_tostring(L, -1));
    getchar();
    return -1;
  }

  //没有错误，输出hello函数返回值，返回值在栈的顶部
  printf(lua_tostring(L, -1));
  
  //这个是为了让命令行不要退出
  getchar();
  return 0;
}

　　

能够看到输出了hello函数返回的参数值“world”

 

 

更进一步

前面的章节仅仅能算一个铺垫，只是聊了聊C语言调用Lua函数的知识，离“redis中Lua执行原理”真相还差一截，为何这么说呢？

 

咱们依然之前面的那段lua脚本

eval "return redis.call('set',KEYS[1],'bar')" 1 foo

　　

来展开，redis.call从字面理解对应着一次redis操做，这个操做难道是lua完成的？

 

 

redis.call('set',KEYS[1],'bar')能够理解为调用了redis对象（Lua语言中应该叫table）的call方法，参数分别为'set',KEYS[1],'bar'，当执行redis.call时，其最终会映射到redis源码中的luaRedisCallCommand方法，这个映射操做是在redis启动时scriptingInit函数完成的，跟着源码看下这块逻辑：

 

void scriptingInit(void) {
    //1.初始化luaState
    lua_State *lua = lua_open();

    //2.加载一些lua库
    luaLoadLibraries(lua);
    luaRemoveUnsupportedFunctions(lua);

    //3.初始化一个空的lua table，并入栈s，这时table在栈顶，对应的index=-1
    lua_newtable(lua);

    //4.压字符串"call"入栈，这时"call"在栈顶，index=-1，前一步的table在栈底
    //对应的index=-2
    lua_pushstring(lua,"call");

    //5.压c函数luaRedisCallCommand入栈，这时"luaRedisCallCommand"在栈顶，index=-1，
    //前两步压入栈的table和"call"在栈中的index分别为-3，-2
    lua_pushcfunction(lua,luaRedisCallCommand);

    //6.为table赋值，table处在-3位置，依次从栈中弹出两个元素做为table的
    //value和key，执行table[key] = value，赋值之后的table相似于这样的结构
    //{"call":luaRedisCallCommand}
    //lua_settable之后栈中只剩table
    lua_settable(lua,-3);

    //7.从栈顶弹出一个元素设置为全局变量，并命名为redis，由于目前栈中只剩
    //table，因此redis就是table
    lua_setglobal(lua,"redis");
  }

　　

上面这段代码的主要做用是将redis.call这个Lua调用映射为luaRedisCallCommand这个C调用，那接下来应该还有两个点值得咱们关注：

1. 参数如何传递给C函数的；

2. C函数调用完成之后如何返回结果给Lua。

前面在说C调用Lua时说过，对于两个异构系统的相互调用通常须要两个条件：

1. 存在一层适配层，这一层负责作相关的转换，对于C和Lua互调来讲，这一层由Lua底层实现，好比上面的luc_call，lua_load等等；

2. 须要某种通讯协议来达成共识，这样才能顺畅的交流；

一样的，这两个前提条件一样适用于Lua调用C，转换依然由Lua底层实现，通讯载体依然是一个栈，通讯协议虽然有一点变化，可是原理相似，具体以下：

Lua底层对存在C映射关系的lua函数调用时，好比redis.call，Lua底层会将函数参数依次压栈，当C函数调用时从栈中获取参数，C函数执行完成之后将返回值压栈，C函数的返回结果为返回值的数量，Lua底层根据函数返回值去栈中获取必定数量的值做为lua的返回值；

经过一组图描述下调用过程：

 

 

  阶段1-c函数入栈

void lua_pushcfunction (lua_State *L, lua_CFunction f);

　　

阶段2-将C函数设置为lua全局变量，其实就是lua调用到c调用的映射

void lua_setglobal (lua_State *L, const char *name);

　　

阶段3-函数调用

redis.call('set',KEYS[1],'bar')

 lua底层会将redis.call这个lua调用的参数依次压栈，而后触发对应的C函数，好比luaRedisCallCommand，它会从栈中获取参数而后执行。

 

阶段4-C函数调用完成

lua_pushxxx(luaState,结果);//结果压栈
return 1;//返回结果的个数

　　

阶段5-获取C函数执行结果

 这一步是由lua底层自动完成的，lua底层根据C函数的返回结果去栈中获取相应的结果，好比返回值为1，那就获取栈顶元素做为返回值，若是返回值为2，那就获取栈顶前两个元素做为返回值。

 

最后一块儿来看下luaRedisGenericCommand这个C函数的源码：

int luaRedisGenericCommand(lua_State *lua, int raise_error) {
    //获取函数个数
    int j, argc = lua_gettop(lua);
    struct redisCommand *cmd;
    robj **argv;
    redisClient *c = server.lua_client;
    sds reply;

    /* Build the arguments vector */
    argv = zmalloc(sizeof(robj*)*argc);

    //从栈中依次获取各参数的值
    for (j = 0; j < argc; j++) {
        if (!lua_isstring(lua,j+1)) break;
        argv[j] = createStringObject((char*)lua_tostring(lua,j+1),
                                     lua_strlen(lua,j+1));
    }
   
    /* Setup our fake client for command execution */
    //将参数个数和参数值告诉redis client，这里比较有意思，为何叫
    //fake client呢？正常状况下redis client都是真实的应用程序，可是这里是
    //redis server伪造的一个redis client
    c->argv = argv;
    c->argc = argc;

    /* Command lookup */
    //根据redis命令查找对应的c函数，argv[0]就是redis命令
    cmd = lookupCommand(argv[0]->ptr);
    if (!cmd || ((cmd->arity > 0 && cmd->arity != argc) ||
                   (argc < -cmd->arity)))
    {
        if (cmd)
            luaPushError(lua,
                "Wrong number of args calling Redis command From Lua script");
        else
            luaPushError(lua,"Unknown Redis command called from Lua script");
        goto cleanup;
    }

    /* There are commands that are not allowed inside scripts. */
    if (cmd->flags & REDIS_CMD_NOSCRIPT) {
        luaPushError(lua, "This Redis command is not allowed from scripts");
        goto cleanup;
    }

    /* Write commands are forbidden against read-only slaves, or if a
     * command marked as non-deterministic was already called in the context
     * of this script. */
    if (cmd->flags & REDIS_CMD_WRITE) {
        if (server.lua_random_dirty) {
            luaPushError(lua,
                "Write commands not allowed after non deterministic commands");
            goto cleanup;
        } else if (server.masterhost && server.repl_slave_ro &&
                   !server.loading &&
                   !(server.lua_caller->flags & REDIS_MASTER))
        {
            luaPushError(lua, shared.roslaveerr->ptr);
            goto cleanup;
        } else if (server.stop_writes_on_bgsave_err &&
                   server.saveparamslen > 0 &&
                   server.lastbgsave_status == REDIS_ERR)
        {
            luaPushError(lua, shared.bgsaveerr->ptr);
            goto cleanup;
        }
    }

    if (cmd->flags & REDIS_CMD_RANDOM) server.lua_random_dirty = 1;
    if (cmd->flags & REDIS_CMD_WRITE) server.lua_write_dirty = 1;

    /* Run the command */
    c->cmd = cmd;
    //调用具体的C函数
    call(c,REDIS_CALL_SLOWLOG | REDIS_CALL_STATS);

    /* Convert the result of the Redis command into a suitable Lua type.
     * The first thing we need is to create a single string from the client
     * output buffers. */

    //解析响应结果
    reply = sdsempty();
    if (c->bufpos) {
        reply = sdscatlen(reply,c->buf,c->bufpos);
        c->bufpos = 0;
    }
    while(listLength(c->reply)) {
        robj *o = listNodeValue(listFirst(c->reply));

        reply = sdscatlen(reply,o->ptr,sdslen(o->ptr));
        listDelNode(c->reply,listFirst(c->reply));
    }
    if (raise_error && reply[0] != '-') raise_error = 0;

    //根据不一样的响应将返回值压入栈
    redisProtocolToLuaType(lua,reply);
    /* Sort the output array if needed, assuming it is a non-null multi bulk
     * reply as expected. */
    if ((cmd->flags & REDIS_CMD_SORT_FOR_SCRIPT) &&
        (reply[0] == '*' && reply[1] != '-')) {
            luaSortArray(lua);
    }
    sdsfree(reply);
    c->reply_bytes = 0;

cleanup:
    /* Clean up. Command code may have changed argv/argc so we use the
     * argv/argc of the client instead of the local variables. */
    for (j = 0; j < c->argc; j++)
        decrRefCount(c->argv[j]);
    zfree(c->argv);

    if (raise_error) {
        /* If we are here we should have an error in the stack, in the
         * form of a table with an "err" field. Extract the string to
         * return the plain error. */
        lua_pushstring(lua,"err");
        lua_gettable(lua,-2);
        return lua_error(lua);
    }

    //返回结果的数量
    return 1;
}

　　

总结

redis和Lua可以直接通讯得益于底层都是C实现的，关键在于LuaState，能够简单理解为一个栈，充当了通讯的载体，其次就是通讯协议的定义，参数的传递、返回值的获取、方法的调用都经过简单的入栈、出栈操做实现。

 

推荐阅读

Lua官方文档  http://www.lua.org/manual/5.1/manual.html

 

Lua编程指南 http://www.lua.org/pil/24.html http://www.lua.org/pil/25.html http://www.lua.org/pil/26.html 

 

   　　　　　　　　　　　　　　　　　　　　　　　　　　　　来个人公众号与我交流