Erlang 与 c 函数 对接

    一种编程语言同其他的语言结合互操作,充分利用现有资源,是很常见的事情. 也有特定的编程语言很擅长同其他语言的结合,如LUA.  在Erlang中也有很多方法同其他的编程语言结合.如通过内链驱动,原生实现函数(NIF)等.

    Erlang虚拟机中通过一种端口的对象概念同外部程序进行通信,外部程序在端口处取得数据进行处理,处理完成后再送回端口,Erlang虚拟机创建端口的进程会将请求数据发到端口,再等待收回结果.所以说这需要一个协议,有了协议不同的语言间就可以交互了. 

    下面有两个非常简单的c语言函数,准备再erlang中调用:

example1.c

  1 int sum(int x,int y){                                                         2   3     return x + y;  4 }  5   6 int twice(int x){  7   8     return x*2;  9 }

     定义的规则如下:

    1. sum(x,y) 的调用会被编译成字节序列 [1, x, y]

    2. twice(x) 的调用会被编译成字节序列[2, x]

    3. 所有的数据包都带有两个字节的长度头

    4. 返回值,参数都是一个字节长度

    有了上述的这几条约定,就应该可以完成简单的函数的调用了.接下来就是双方都按这些规则交换数据就可以了,也就是所谓的driver程序了.

 example1_driver.c

<span style="font-size:14px;">  1 #include <stdio.h>                                                                                               2 #include <stdlib.h>  3   4 typedef unsigned char byte;  5   6 int main(){  7       8     int function = 0;  9     int arg1 = 0; 10     int arg2 = 0; 11     int result = 0; 12     byte buf[100] = {0}; 13  14     while(read_cmd(buf) > 0){ 15          16         function = buf[0]; 17          18         if(function == 1){ 19              arg1 = buf[1]; 20              arg2 = buf[2]; 21              result = sum(arg1,arg2); 22         } else if(function == 2){ 23              arg1 = buf[1]; 24              result = twice(arg1); 25         }else{ 26              exit(0);            27         } 28  29          30         buf[0] = result; 31         write_cmd(buf,1); 32     } 33 } </span>

上面是C语言端的实现逻辑,它会不断的从标准输入取得计算的数据,计算之后在输出到标准输出中,这里所谓的标准输入输出,也就是Erlang的port. Erlang的端口进程会负责启动这个C程序,同时对它进行管理,Erlang端口进程不在了,也会杀掉这个C程序, 当这个C程序意外的挂掉之后,Erlang也会负责重新启动它. 这里面还涉及到两个实现的具体函数,不会影响整个逻辑. 贴出来如下:

<span style="font-size:14px;">  1 #include <unistd.h>                                                                                              2   3 typedef unsigned char byte;  4   5 int read_cmd(byte *buf)  6 {  7     int len;  8   9     if(read_exact(buf,2) != 2) 10         return -1; 11  12     len = (buf[0] << 8 | buf[1]); 13  14     return read_exact(buf,len); 15 } 16  17 int write_cmd(byte *buf,int len) 18 { 19     byte li; 20  21     li = (len >> 8) & 0xff; 22     write_exact(&li,1); 23     li = len & 0xff; 24     write_exact(&li,1); 25  26     return write_exact(buf,len); 27 } 28  29 int read_exact(byte *buf,int len){ 30     int i = 0; 31     int got = 0; 32  33     do { 34         if((i = read(0,buf + got, len-got)) <= 0) 35                 return i; 36         got = got + i; 37     }while(got < len); 38  39     return len; 40 } 41  42 int write_exact(byte *buf,int len){ 43     int i = 0; 44     int wrote = 0; 45  46     do{ 47         if((i = write(1,buf + wrote,len - wrote)) <= 0) 48            return i; 49         wrote = wrote + i; 50     }while(wrote < len); 51  52     return len; 53 } </span><span style="font-size:18px;">     </span>

Erlang 这边同样是按照规则实现函数调用:

    example1.erl

<span style="font-size:14px;">  1 -module(example1).                                                                                               2   3 -export([start/0,stop/0]).  4 -export([twice/1,sum/2]).  5   6 start() ->  7         register(example1,spawn(  8                             fun() ->  9                                 process_flag(trap_exit,true), 10                                 Port = open_port({spawn,"./example1"},[{packet,2}]), 11                                 loop(Port) 12                             end)). 13  14  15 stop() -> 16         ?MODULE ! stop. 17  18 twice(X) -> call_port({twice,X}). 19 sum(X,Y) -> call_port({sum,X,Y}). 20  21 call_port(Msg) -> 22         ?MODULE ! {call, self(), Msg}, 23         receive 24                 {?MODULE,Result} -> 25                         Result 26         end. 27  28 loop(Port) -> 29         receive 30                 {call, Caller, Msg} -> 31                         Port ! {self(),{command,encode(Msg)}}, 32                         receive 33                                 {Port,{data,Data}} -> 34                                         Caller ! {?MODULE,decode(Data)} 35                         end, 36                         loop(Port); 37                 stop -> 38                         Port ! {self(),close}, 39                         receive 40                                 {Port,closed} -> 41                                         exit(normal) 42                         end; 43                 {'EXIT',Port,Reason} -> 44                         exit({port_terminated,Reason}) 45         end. 46  47 encode({sum,X,Y}) -> [1,X,Y]; 48 encode({twice,X}) -> [2,X]. 49  50 decode([Int]) -> Int.</span>

下面的问题就是编译,试一试了:

   erlc example1.erl

   gcc -o example1 example1.c example_driver.c erl_comm.c

    example1:start().

    example:sum(23,43).

    example:twice(10).