luajit的ffi更快的原因_lua return

luajit的ffi更快的原因_lua returnLuajitffi接口使用小结:1.使用Luajitffi加载C链接库2.使用Luajitffi调用C函数3.使用Luajitffi处理基本类型对象,结构体对象,字符串对象cdata4.cdata赋值及修改本文仅限于使用C链接库,后面文章将介绍使用Luajitffi加载C++链接库

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

luajit ffi 小结


Lua 是一种语法简单,上手快的语言,虽然原生库比较少,但是可以方便的和 C 语言互相调用,常被用于脚本嵌入到 C 程序中。如 Redis 中可以加载 Lua 脚本,作用类似于存储过程,Nginx 中 lua-nginx-module 模块更是将 Lua 的这种特性发挥到极致。

使用 Lua 如何调用 C 的函数,个人认为是每一个 Lua 开发者必学的内容。Lua 调用 C 程序有两种方法,一种是使用 lua C API,另一种方法就是使用 luajit 提供的 ffi 库来调用 C 程序。本文主要是对 luajit ffi 的研究总结。

luajit ffi

luajit 和 lua 一样,是可以直接安装在操作系统中的,相关介绍直接参考官网 luajit。个人测试效果来看,luajit 的执行效率远高于 lua,大概是 8 倍左右。openresty 的 lua-nginx-module 模块就是将 luajit 集成到了 Nginx 中,实现在 Nginx 中执行 Lua 脚本

luajit ffi 是 luajit 提供给 Luaer 使用 Lua 调用 C 函数的 Lua 库,使用该库,Luaer 不用再去操作复杂的 Lua 栈来粘合两种程序代码,luajit ffi 官方资料

引入 luajit ffi 库

local ffi = require("ffi")

在 Lua 中调用 C 函数

和 lua 的 C API 一样,Lua 调用 C 函数,需要将 C 函数编译成链接库。区别在于 C API 查找 C 的 Lua 库是在 package.cpath 路径下进行查找,而这些库函数使用 Lua 栈接口进行编写。而 luajit 对于 C 链接库的引用遵从于普通 C 库的引用方式,先在 /usr/lib(/usr/lib64),/lib(/lib64) 目录下查找,再到用户自定义的 LD_LIBRARY_PATH 下查找。

  • 本节涉及接口:

    • ffi.cdef[[c_function define]]
    • ffi.C
    • ffi.load(name [,global])
  • 调用 C 标准库函数

    对于 C 标准库函数引用,需要引入函数,函数声明

    ffi.cdef[[c_function define]]
    

    调用 C 函数

    ffi.C.c_function
    

    如:

    local ffi = require("ffi")
    
    ffi.cdef[[
    int printf(const char *fmt, ...);
    int strcasecmp(const char *s1, const char *s2);
    ]]
    
    ffi.C.printf("Hello %s!\n", "world")
    ret = ffi.C.strcasecmp("Hello", "hello")
    print(ret)
    ret = ffi.C.strcasecmp("Hello", "hello1")
    print(ret)
    

    输出结果

    [root@AlexWoo-CentOS lua]# luajit ffic.lua 
    Hello world!
    0
    -49
    
  • 调用自定义的 C 函数

    调用自定义的 C 函数,首先要将自定义的 C 函数编译成链接库

    [root@AlexWoo-CentOS lua]# cat ffimyc.c 
    int add(int x, int y)
    {
        return x + y;
    }
    [root@AlexWoo-CentOS lua]# gcc -g -o libffimyc.so -fpic -shared ffimyc.c
    

    比调用 C 标准库函数,需要在 Lua 中引入相应的库

    ffi.load(name [,global])
    

    这里第二个参数如果为 true,则该库被引入全局命名空间,这里使用 ffi.load 需要注意两点:

    • 链接库文件必须在 C 的动态链接库查找路径中,否则会报类似错误:

      luajit: ffimyc.lua:3: libffimyc.so: cannot open shared object file: No such file or directory
      

      引入方法:

      export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:your_lib_path
      
    • 在 Linux 下,库函数名的查找与 C 程序查找动态链接库相同,如上面我生成的动态链接库文件为 libffimyc.so,我在 ffi.load 中的 name 为 ffimyc

    调用自己的函数,可以直接使用 ffi.load 返回的变量调用,下面我们看一个简单的例子:

    local ffi = require('ffi')
    
    myc = ffi.load('ffimyc')
    
    ffi.cdef[[
    int add(int x, int y);
    ]]
    
    ret = myc.add(1, 20)
    print(ret)
    

    输出结果

    [root@AlexWoo-CentOS lua]# luajit ffimyc.lua
    21
    
  • 使用 ffi.C 调用自定义的 C 函数

    上面的例子中,是不能直接使用 ffi.C 来调用 add 函数的,那么怎么用 ffi.C 来调用 add 函数,对,就是 ffi.load 时,第二个参数置为 true,将库加载为全局命名空间。示例:

    local ffi = require('ffi')
    
    ffi.load('ffimyc', true)
    
    ffi.cdef[[
    int add(int x, int y);
    ]]
    
    ret = ffi.C.add(1, 10)
    print(ret)
    

    输出结果

    [root@AlexWoo-CentOS lua]# luajit ffimyc.lua
    11
    
  • 本节小结

    • 在 lua 中调用 C 函数,需要使用 ffi.cdef 对 C 函数进行声明
    • 对于 C 标准库函数,已在全局命名空间,直接可以使用 ffi.C.函数名(函数参数…) 来调用函数
    • 对于自定义的 C 函数,需要将其先编译成链接库,并将链接库所在路径加入到 LD_LIBRARY_PATH 中,需要使用 ffi.load 载入链接库
    • 如果 ffi.load 第二个参数不填写,链接库以私有空间方式链入 Lua 脚本,使用时需要用 ffi.load 的返回值对函数进行调用
    • 如果 ffi.load 第二个参数设置为 true,可以使用 ffi.C 直接调用,调用方法同 C 标准库函数的调用

Lua 处理 cdata 对象

上面对 Lua 如何调用 C 函数进行了小结,但是光能调用 C 函数是远远不够的,我们还需要对 C 的变量,变量类型进行处理。本节将对这部分进行探讨。

  • C 类型转化为 Lua 中的 ctype

    C 类型转化为 Lua ctype,使用 ffi.typeof,该函数返回一个 ctype 变量类型

    ctype = ffi.typeof(ct)
    

    示例:

    local ffi = require('ffi')
    
    ffi.cdef[[
    struct s1 {
        int a;
        int b;
    };
    typedef struct {
        int c;
        int d;
    } s2;
    union u {
        int a;
        long b;
        float c;
    };
    enum e {
        Male,
        Female
    };
    ]]
    
    print(ffi.typeof("int8_t"))
    print(ffi.typeof("uint8_t"))
    print(ffi.typeof("int16_t"))
    print(ffi.typeof("uint16_t"))
    print(ffi.typeof("int32_t"))
    print(ffi.typeof("uint32_t"))
    print(ffi.typeof("int64_t"))
    print(ffi.typeof("uint64_t"))
    print(ffi.typeof("double"))
    print(ffi.typeof("float"))
    print(ffi.typeof("bool"))
    print(ffi.typeof("struct s1"))
    print(ffi.typeof("s2"))
    print(ffi.typeof("union u"))
    print(ffi.typeof("enum e"))
    print(ffi.typeof("struct s1*"))
    print(ffi.typeof("struct s1[]"))
    

    输出:

    [root@AlexWoo-CentOS lua]# luajit ffit.lua 
    ctype<char>
    ctype<unsigned char>
    ctype<short>
    ctype<unsigned short>
    ctype<int>
    ctype<unsigned int>
    ctype<int64_t>
    ctype<uint64_t>
    ctype<double>
    ctype<float>
    ctype<bool>
    ctype<struct s1>
    ctype<struct 98>
    ctype<union u>
    ctype<enum e>
    ctype<struct s1 *>
    ctype<struct s1 []>
    
  • 创建并初始化 cdata 对象

    使用 ctype 有以下两种构造 Lua C 对象的方法

    cdata = ffi.new(ct [,nelem] [,init...])
    cdata = ctype([nelem,] [init...])
    
    • 基本类型 cdata 对象

      首先是一个 C 的函数,我们使用构造的 cadata 对象来调用该函数:

      int add(int x, int y)
      {
          return x+y;
      }
      
      1. 直接调用

        local ffi = require('ffi')
        local t = ffi.load("t", true)
        
        ffi.cdef[[
        int add(int x, int y);
        ]]
        
        print(t.add(10, 11))
        

        执行结果

        [root@AlexWoo-CentOS lua]# luajit ffit.lua 
        21
        

        这种方法仅限于基本类型,lua 会将其基本类型转换为 cdata 的基本类型

      2. 使用 ffi.new 构造

        local ffi = require('ffi')
        local t = ffi.load("t", true)
        
        ffi.cdef[[
        int add(int x, int y);
        ]]
        
        ti = ffi.typeof("int")
        a = ffi.new(ti, 10)
        b = ffi.new("int", 11)
        print(type(a), type(b))
        print(t.add(a, b))
        

        执行结果

        [root@AlexWoo-CentOS lua]# luajit ffit.lua 
        cdata   cdata
        21
        

        这里如果执行 print(ffi.typeof(“int”)),结果就是 ctype,因此这里 ffi.new 的第一个参数直接填为 “int” 与传入一个 ctype 的类型对象是等价的

      3. 使用类型对象构造

        local ffi = require('ffi')
        local t = ffi.load("t", true)
        
        ffi.cdef[[
        int add(int x, int y);
        ]]
        
        ti = ffi.typeof("int")
        a = ti(10)
        b = ti(11)
        print(t.add(a, b))
        

        执行结果

        [root@AlexWoo-CentOS lua]# luajit ffit.lua 
        21
        
    • 基本类型指针 cdata 对象

      首先是一个 C 的函数,我们使用构造的 cadata 对象来调用该函数:

      int addp(int *x, int *y)
      {
          return *x+*y;
      }
      

      这里构造指针对象可以使用 ffi.new 和 类型构造两种方法,下面只以一种进行举例,其它举一反三

      local ffi = require('ffi')
      local t = ffi.load("t", true)
      
      ffi.cdef[[
      int add(int x, int y);
      int addp(int *x, int *y);
      ]]
      
      a = ffi.new("int[1]", {10})
      b = ffi.new("int[1]", {10})
      print(t.addp(a, b))
      

      执行结果

      [root@AlexWoo-CentOS lua]# luajit ffit.lua 
      21
      

      没有将 Lua 原生类型直接转换为指针类型的方法(至少我没找到),这里使用的是将 Lua 的 table 转为只有一个元素的数组,并将数组当作指针类型参数传入 addp 中

    • 结构类型 cdata 对象

      首先是一个 C 程序,我们使用构造的 cadata 对象来调用该函数:

      #include <stdio.h>
      
      struct constr_t {
          int a;
          int b;
          struct innerstr {
              int x;
              int y;
          } c;
      };
      
      void print_constr_t(struct constr_t t)
      {
          printf("a:%d\n", t.a);
          printf("b:%d\n", t.b);
          printf("c.x:%d\n", t.c.x);
          printf("c.y:%d\n", t.c.y);
      }
      

      Lua 程序

      local ffi = require('ffi')
      local t = ffi.load("t", true)
      
      ffi.cdef[[
      struct constr_t {
          int a;
          int b;
          struct innerstr {
              int x;
              int y;
          } c;
      };
      void print_constr_t(struct constr_t t);
      ]]
      
      a = ffi.new("struct constr_t", {1, 2, {10, 11}})
      t.print_constr_t(a)
      

      执行结果

      [root@AlexWoo-CentOS lua]# luajit ffit.lua 
      a:1
      b:2
      c.x:10
      c.y:11
      

      这里我们看到构造一个 C 的结构类型与基本类型的方法基本类似,唯一区别就是需要使用 table 来进行构造,table 的层次结构与 C 的结构的层次必须符合

    • 结构类型指针 cdata 对象

      在日常使用中,对于结构体,我们更常使用的是指针。和基本类型指针 cdata 对象不同,可以直接使用与结构类型 cdata 对象相同的方式来构造结构类型指针的 cdata 对象

      C 程序

      #include <stdio.h>
      
      struct constr_t {
          int a;
          int b;
          struct innerstr {
              int x;
              int y;
          } c;
      };
      
      void print_pconstr_t(struct constr_t *t)
      {
          printf("a:%d\n", t->a);
          printf("b:%d\n", t->b);
          printf("c.x:%d\n", t->c.x);
          printf("c.y:%d\n", t->c.y);
      }
      

      Lua 程序

      local ffi = require('ffi')
      local t = ffi.load("t", true)
      
      ffi.cdef[[
      struct constr_t {
          int a;
          int b;
          struct innerstr {
              int x;
              int y;
          } c;
      };
      void print_pconstr_t(struct constr_t *t);
      ]]
      
      a = ffi.new("struct constr_t", {1, 2, {10, 11}})
      t.print_pconstr_t(a)
      

      执行结果

      [root@AlexWoo-CentOS lua]# luajit ffit.lua 
      a:1
      b:2
      c.x:10
      c.y:11
      
    • 字符串 cdata 对象

      可以使用 Lua string 对象来初始化字符串 cdata 对象

      C 程序

      void print(const char *s)
      {
          printf("%s\n", s);
      }
      

      Lua 程序

      local ffi = require('ffi')
      local t = ffi.load("t", true)
      
      ffi.cdef[[
      void print(const char *s);
      ]]
      
      a = ffi.new("const char*", "Hello World")
      t.print(a)
      

      执行结果

      [root@AlexWoo-CentOS lua]# luajit ffit.lua 
      Hello World
      

      注意对字符串,ffi.new 第一个参数只能是 const char *、const char[size] 或 char[size],不能是 char *,const char[?] 等类型

  • 使用 cdata 对象

    本节将探讨在 Lua 中怎么使用 cdata 对象

    C 程序

    #include <stdio.h>
    
    struct constr_t {
        int a;
        int b;
        struct innerstr {
            int x;
            int y;
        } c;
    };
    
    void print_pconstr_t(struct constr_t *t)
    {
        printf("a:%d\n", t->a);
        printf("b:%d\n", t->b);
        printf("c.x:%d\n", t->c.x);
        printf("c.y:%d\n", t->c.y);
    }
    
    int print_i(int x)
    {
        printf("x: %d\n", x);
    }
    
    int print_pi(int *px)
    {
        printf("px: %d\n", *px);
    }
    
    void print(const char *s)
    {
        printf("%s\n", s);
    }
    

    Lua 程序

    local ffi = require('ffi')
    local t = ffi.load("t", true)
    
    ffi.cdef[[
    struct constr_t {
        int a;
        int b;
        struct innerstr {
            int x;
            int y;
        } c;
    };
    void print_pconstr_t(struct constr_t *t);
    int print_i(int x);
    int print_pi(int *px);
    void print(const char *s);
    ]]
    
    ti = ffi.new("int", 10)
    tpi = ffi.new("int[1]", {20})
    
    ts = ffi.new("struct constr_t", {1, 2, {3, 4}})
    
    tcstr = ffi.new("const char*", "Hello World")
    tstr = ffi.new("char[11]", "Hello World")
    
    t.print_i(ti)
    --t.print_pi(ti) --luajit: ffit.lua:29: bad argument #1 to 'print_pi' (cannot convert 'int' to 'int *')
    
    --t.print_i(tpi) --luajit: ffit.lua:31: bad argument #1 to 'print_i' (cannot convert 'int [1]' to 'int')
    t.print_pi(tpi)
    
    t.print_pconstr_t(ts)
    
    t.print(tcstr)
    t.print(tstr)
    
    --对基本类型操作
    ti = 100 --change tpi to number
    tpi[0] = 21
    --tpi=22 --change tpi to number
    --tpi[1] = 2000 --luajit: ffit.lua:44: attempt to index global 'tpi' (a number value)
    print(type(ti), type(tpi))
    t.print_i(ti)
    t.print_pi(tpi)
    
    --对 struct 类型操作
    ts.b = 100
    ts.c.y = 1000
    print(type(ts))
    t.print_pconstr_t(ts)
    
    --对字符串类型操作
    --tcstr[2] = 32 --luajit: ffit.lua:54: attempt to write to constant location
    tstr[2] = 32
    t.print(tstr)
    
    t.print("Hello Lua")
    

    执行结果

    [root@AlexWoo-CentOS lua]# luajit ffit.lua 
    x: 10
    px: 20
    a:1
    b:2
    c.x:3
    c.y:4
    Hello World
    Hello World
    number  cdata
    x: 100
    px: 21
    cdata
    a:1
    b:100
    c.x:3
    c.y:1000
    He lo World
    Hello Lua
    

    从上面的例子可以看出,对基本类型,实际上不需要将其转为 cdata 类型;对于基本类型指针,操作方式与数组类似,在 Lua 中可当作 table 数组进行处理;对结构类型,在 Lua 中可当作 table 字典进行处理;对字符串,在 Lua 中可当作 table 数组进行处理

  • 本节小结

    • Lua 可以使用 ffi.new 初始化一个 cdata 对象,也可以使用 ffi.typeof 生成的类型来初始化一个 cdata 对象
    • 对于基本类型和字符串类型,没有必要将其转为 cdata 对象,其可以作为参数传入 C 函数中。也可以接收 C 函数的返回值
    • 对于基本类型指针对象,可以使用单元素数组进行初始化,可以使用数组元素赋值的方式改变其中的值
    • 对于结构类型,可以传入 C 指针参数,也可以传入 C 普通参数。对结构类型的操作,与 table 的字典操作类似
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/185060.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • 软件安装 —— 使用官方ODT定制安装Office

    软件安装 —— 使用官方ODT定制安装Office前言正在MacOS11的BigSur如火如荼的宣传着,我这不争气的Windows系统也终于越看越是臃肿,做为生产力工具,第一还是要稳定精简,一气之下,直接换上了Windows特别版本LTSC,据说这个版本特别特别稳定,很长时间才会更新一次,但用过的都说好,想想还是激动的。重装系统是一个重大工程,那做为Windows第二重要的软件Office目前的安装模式要么官方下载安装包要么离线部署,而官方的安装包可谓是一键超级全家桶搬进C盘,有用的没用的全部装一遍,最终还是靠离线部署来安装了,可以定制想要的软件,还

  • js保留两位小数的方法_jquery 保留两位小数

    js保留两位小数的方法_jquery 保留两位小数一、我们首先从经典的“四舍五入”算法讲起1、四舍五入的情况?12varnum=2.446242342;num=num.toFixed(2);//输出结果为2.452、不四舍五入第一种,先把小数边整数:?1Math.floor(15.7784514000*100)/100//输出结果为15.77第二种,当作字符串,使用正则匹配:?1Number(…

  • hesse矩阵和jacobi矩阵_安索夫矩阵和波士顿矩阵区别

    hesse矩阵和jacobi矩阵_安索夫矩阵和波士顿矩阵区别转载自:http://jacoxu.com/jacobian%E7%9F%A9%E9%98%B5%E5%92%8Chessian%E7%9F%A9%E9%98%B5/在网上看到的一篇不错的关于雅克比

  • 安全-流量劫持形成的原因

    流量劫持,这种古老的攻击沉寂了一段时间后,最近又开始闹的沸沸扬扬。众多知名品牌的路由器相继爆出存在安全漏洞,引来国内媒体纷纷报道。只要用户没改默认密码,打开一个网页甚至帖子,路由器配置就会被暗中修改。互联网一夜间变得岌岌可危。详解流量劫持的形成原因攻击还是那几种攻击,报道仍是那千篇一律的砖家提醒,以至于大家都麻木了。早已见惯运营商的各种劫持,频繁的广告弹窗,大家也无可奈何。这么多年也没出现…

  • idea激活码 在线(注册激活)[通俗易懂]

    (idea激活码 在线)本文适用于JetBrains家族所有ide,包括IntelliJidea,phpstorm,webstorm,pycharm,datagrip等。IntelliJ2021最新激活注册码,破解教程可免费永久激活,亲测有效,下面是详细链接哦~https://javaforall.cn/100143.html…

  • DPM2012系列之十六:在SCOM2012上集成DPM2012中央控制台

    DPM2012系列之十六:在SCOM2012上集成DPM2012中央控制台

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号