Erlang和其他语言的交互

Erlang和其他语言的交互

Erlang和其他语言（如C和Java）的交互手段一直是我很感兴趣的主题，周末看了下OTP文档，终于大致理清楚了思路。这里先简单总结四种交互手段，也是更进一步学习Erlang的开始。

端口

最简单的方式是调用Erlang模块的 open_port/2 ，创建一个端口。Erlang端口可以被认为是一个外部Erlang进程，交互手段是通过标准IO输入输出，对应C语言里的read和write函数。

-spec open_port(PortName, PortSettings) -> port() when
      PortName :: {spawn, Command :: string() | binary()} |
                  {spawn_driver, Command :: string() | binary()} |
                  {spawn_executable, FileName :: file:name() } |
                  {fd, In :: non_neg_integer(), Out :: non_neg_integer()},
      PortSettings :: [Opt],
      Opt :: {packet, N :: 1 | 2 | 4}
           | stream
           | {line, L :: non_neg_integer()}
           | {cd, Dir :: string() | binary()}
           | {env, Env :: [{Name :: string(), Val :: string() | false}]}
           | {args, [string() | binary()]}
           | {arg0, string() | binary()}
           | exit_status
           | use_stdio
           | nouse_stdio
           | stderr_to_stdout
           | in
           | out
           | binary
           | eof
       | {parallelism, Boolean :: boolean()}
       | hide.

还没有读源码，但是原理很好理解，只需要重定向标准输入输出，如linux的dup2函数，就可以实现数据交互。具体的数据格式也是简单的二进制串，由{packet, N}指定开头长度标识符的位数。

例子如下：

%% erlang
%% simple test for string operation with c
-module(complex1).
-export([start/1, stop/0, init/1]).
-export([strlen/1, strcmp/2]).

start(Prog) ->
    spawn(?MODULE, init, [Prog]).

stop() ->
    ?MODULE ! stop.

strlen(S) ->
    call_port({strlen, S}).
strcmp(S, T) ->
    call_port({strcmp, S, T}).

call_port(Msg) ->
    ?MODULE ! {call, self(), Msg},
    receive
        {?MODULE, Result} ->
            Result
    end.

init(Prog) ->
    register(?MODULE, self()),
    process_flag(trap_exit, true),
    Port = open_port({spawn, Prog}, [{packet, 2}]),
    loop(Port).

loop(Port) ->
    receive
        {call, From, Msg} ->
            Port ! {self(), {command, encode(Msg)}},
            receive
                {Port, {data, Data}} ->
                    From ! {?MODULE, decode(Data)}
            end,
            loop(Port);
        stop ->
            Port ! {self(), close},
            receive
                {Port, closed} ->
                    exit(normal)
            end;
        {'EXIT', Port, _Reason} ->
            exit(port_exit_error)
    end.

encode({strlen, X}) -> [1, list_to_binary(X)];
encode({strcmp, X, Y}) -> [2, list_to_binary(X), 0, list_to_binary(Y), 0].

decode([Int]) -> Int.

后面的Erlang端程序大同小异，只写关键点。C语言那边也很简单：

#include 
#include "comm.h"

int read_exact(byte*, int);
int write_exact(byte*, int);

int read_cmd(byte* buf)
{
    int len;
    if (read_exact(buf, 2) != 2)
        return -1;
    len = (buf[0] <<8) | buf[1];
    return read_exact(buf, len);
}

int write_cmd(byte* buf, int len)
{
    byte li;

    li = (len >> 8) & 0xff;
    write_exact(&li, 1);

    li = len & 0xff;
    write_exact(&li, 1);

    return write_exact(buf, len);
}

int read_exact(byte* buf, int len)
{
    int i, got = 0;
    do {
        if ((i = read(0, buf+got, len-got)) <= 0)
            return i;
        got += i;
    } while (got 
    return len;
}

int write_exact(byte* buf, int len)
{
    int i, wrote = 0;
    do {
        if ((i = write(1, buf+wrote, len-wrote)) <= 0)
            return i;
        wrote += i;
    } while (wrote 
    return len;
}

// C
#include 
#include 
#include 
#include 
#include "comm.h"

#define LOG_FILE "einterface.log"

void split_string(char* s, char** s1, char** s2)
{
    *s1 = s;
    *s2 = s + strlen(s) + 1;    
}

int main()
{
    int fn, res, len, i;
    char *s1, *s2;
    
    byte buf[100] = {0};
    
    FILE* f = fopen(LOG_FILE, "w");
    if (f == NULL)
        return -1;

    while ( (len=read_cmd(buf)) > 0) {
        fn = buf[0];
        
        fprintf(f, "Data: ");
        for (i = 0; i             fprintf(f, "0x%02x ", buf[i]);
        fprintf(f, "\n");
        
        if (fn == 1) {
            res = strlen((char*)buf + 1);
        } else if (fn == 2) {
            split_string((char*)buf + 1, &s1, &s2);
            fprintf(f, "s1: %s, s2: %s\n", s1, s2);
            res = strcmp(s1,s2);
        }

        buf[0] = res;
        write_cmd(buf, 1);
        memset(buf, 0, sizeof(buf));
    }

    fclose(f);
    
    return 0;
}

端口方式最简单，但是缺点也很明显，数据量大的时候效率很低。

Erl_Interface

准确的说，这和上一种方式一样，都是利用输入输出。Erl_Interface是Erlang官方提供的数据编码手段，用来替换我们的decode和encode。能把所有Erlang项式编码成二进制。

    {call, From, Msg} ->
        Port ! {self(), {command, term_to_binary(Msg)}},
        receive
            {Port, {data, Data}} ->
                From ! {?MODULE, binary_to_term(Data)}
        end,

C结构体的定义在erl_interface.h，缺少文档说明的接口也能在这里找到。用到的关键结构ETERM是所有Erlang基本数据结构的union。

typedef struct _eterm {
  union {
    Erl_Integer    ival;
    Erl_Uinteger   uival; 
    Erl_LLInteger  llval;
    Erl_ULLInteger ullval;
    Erl_Float      fval;
    Erl_Atom       aval;
    Erl_Pid        pidval;     
    Erl_Port       portval;    
    Erl_Ref        refval;   
    Erl_List       lval;
    Erl_EmptyList  nval;
    Erl_Tuple      tval;
    Erl_Binary     bval;
    Erl_Variable   vval;
    Erl_Function   funcval;
    Erl_Big        bigval;
  } uval;
} ETERM;

常用的转换函数也都封装成了宏：

#define ERL_INT_VALUE(x)  ((x)->uval.ival.i)
#define ERL_INT_UVALUE(x) ((x)->uval.uival.u)
#define ERL_LL_VALUE(x)   ((x)->uval.llval.i)
#define ERL_LL_UVALUE(x)  ((x)->uval.ullval.u)

#define ERL_FLOAT_VALUE(x) ((x)->uval.fval.f)

#define ERL_ATOM_PTR(x) erl_atom_ptr_latin1((Erl_Atom_data*) &(x)->uval.aval.d)
#define ERL_ATOM_PTR_UTF8(x) erl_atom_ptr_utf8((Erl_Atom_data*) &(x)->uval.aval.d)
#define ERL_ATOM_SIZE(x) erl_atom_size_latin1((Erl_Atom_data*) &(x)->uval.aval.d)
#define ERL_ATOM_SIZE_UTF8(x) erl_atom_size_utf8((Erl_Atom_data*) &(x)->uval.aval.d)

#define ERL_PID_NODE(x) erl_atom_ptr_latin1((Erl_Atom_data*) &(x)->uval.pidval.node)
#define ERL_PID_NODE_UTF8(x) erl_atom_ptr_utf8((Erl_Atom_data*) &(x)->uval.pidval.node)
#define ERL_PID_NUMBER(x) ((x)->uval.pidval.number)
#define ERL_PID_SERIAL(x) ((x)->uval.pidval.serial)
#define ERL_PID_CREATION(x) ((x)->uval.pidval.creation)

使用erl_interface的C程序如下：

#include 
#include 
#include "comm.h"
#include "erl_interface.h"
#include "ei.h"


int main()
{
    ETERM *tuplep, *intp;
    ETERM *fnp, *argp, *sp1, *sp2;

    byte buf[100] = {0};
    int res, allocated, freed;

    erl_init(NULL, 0);

    while (read_cmd(buf) > 0) {
        tuplep = erl_decode(buf);
        fnp = erl_element(1, tuplep);
        sp1 = erl_element(2, tuplep);

        if (strncmp((const char*)ERL_ATOM_PTR(fnp), "strlen", 6) == 0) {
            res = strlen(erl_iolist_to_string(sp1));
        } else if (strncmp((const char*)ERL_ATOM_PTR(fnp), "strcmp", 6) == 0) {
            sp2 = erl_element(3, tuplep);
            res = strcmp(erl_iolist_to_string(sp1), erl_iolist_to_string(sp2));
        }

        intp = erl_mk_int(res);
        erl_encode(intp, buf);
        write_cmd(buf, erl_term_len(intp));

        erl_free_compound(tuplep);
        erl_free_term(fnp);
        erl_free_term(argp);
        erl_free_term(intp);
    }
    return 0;
}

erl_init 用于初始化内存管理等。

嵌入式端口（端口驱动）

和前面两种方式不同，嵌入式端口作为动态模块直接加载到Erlang虚拟机。Erlang端需要先加载模块：

start(ProgLib) ->
    case erl_ddll:load_driver("./", ProgLib) of
        ok ->
            ok;
        {error, already_loaded} ->
            ok;
        Reason ->
            io:format("error: ~p~n", [Reason]),
            exit({error, could_not_load_driver})
    end,
    spawn(?MODULE, init, [ProgLib]).

C程序做的变动比较大，主要是完善ErlDrvEntry接口：

/*
 * This structure defines a driver.
 */

typedef struct erl_drv_entry {
    int (*init)(void);      /* called at system start up for statically
                   linked drivers, and after loading for
                   dynamically loaded drivers */ 

#ifndef ERL_SYS_DRV
    ErlDrvData (*start)(ErlDrvPort port, char *command);
                /* called when open_port/2 is invoked.
                   return value -1 means failure. */
#else
    ErlDrvData (*start)(ErlDrvPort port, char *command, SysDriverOpts* opts);
                /* special options, only for system driver */
#endif
    void (*stop)(ErlDrvData drv_data);
                                /* called when port is closed, and when the
                   emulator is halted. */
    void (*output)(ErlDrvData drv_data, char *buf, ErlDrvSizeT len);
                /* called when we have output from erlang to
                   the port */
    void (*ready_input)(ErlDrvData drv_data, ErlDrvEvent event); 
                /* called when we have input from one of 
                   the driver's handles */
    void (*ready_output)(ErlDrvData drv_data, ErlDrvEvent event);  
                /* called when output is possible to one of 
                   the driver's handles */
    char *driver_name;      /* name supplied as command 
                   in open_port XXX ? */
    void (*finish)(void);        /* called before unloading the driver -
                   DYNAMIC DRIVERS ONLY */
    void *handle;       /* Reserved -- Used by emulator internally */
    ErlDrvSSizeT (*control)(ErlDrvData drv_data, unsigned int command,
                char *buf, ErlDrvSizeT len, char **rbuf,
                ErlDrvSizeT rlen); /* "ioctl" for drivers - invoked by
                          port_control/3 */
    void (*timeout)(ErlDrvData drv_data);   /* Handling of timeout in driver */
    void (*outputv)(ErlDrvData drv_data, ErlIOVec *ev);
                /* called when we have output from erlang
                   to the port */
    void (*ready_async)(ErlDrvData drv_data, ErlDrvThreadData thread_data);
    void (*flush)(ErlDrvData drv_data);
                                /* called when the port is about to be 
                   closed, and there is data in the 
                   driver queue that needs to be flushed
                   before 'stop' can be called */
    ErlDrvSSizeT (*call)(ErlDrvData drv_data,
             unsigned int command, char *buf, ErlDrvSizeT len,
             char **rbuf, ErlDrvSizeT rlen,
             unsigned int *flags); /* Works mostly like 'control',
                          a synchronous
                          call into the driver. */
    void (*event)(ErlDrvData drv_data, ErlDrvEvent event,
          ErlDrvEventData event_data);
                                /* Called when an event selected by 
                   driver_event() has occurred */
    int extended_marker;    /* ERL_DRV_EXTENDED_MARKER */
    int major_version;      /* ERL_DRV_EXTENDED_MAJOR_VERSION */
    int minor_version;      /* ERL_DRV_EXTENDED_MINOR_VERSION */
    int driver_flags;       /* ERL_DRV_FLAGs */
    void *handle2;              /* Reserved -- Used by emulator internally */
    void (*process_exit)(ErlDrvData drv_data, ErlDrvMonitor *monitor);
                                /* Called when a process monitor fires */
    void (*stop_select)(ErlDrvEvent event, void* reserved);
                                /* Called on behalf of driver_select when
                   it is safe to release 'event'. A typical
                   unix driver would call close(event) */
    void (*emergency_close)(ErlDrvData drv_data);
                                /* called when the port is closed abruptly.
                   specifically when erl_crash_dump is called. */
    /* When adding entries here, dont forget to pad in obsolete/driver.h */
} ErlDrvEntry;

作为样例，简单的初始化stop、start和output就行：

ErlDrvEntry driver_entry = {
    NULL,
    drv_start,
    drv_stop,
    drv_output,
    NULL,
    NULL,
    "port_driver",
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    ERL_DRV_EXTENDED_MARKER,
    ERL_DRV_EXTENDED_MAJOR_VERSION,
    ERL_DRV_EXTENDED_MINOR_VERSION,
    0,
    NULL,
    NULL,
    NULL
};

利用宏 DRIVER_INIT 完成初始化：

#ifdef STATIC_ERLANG_DRIVER
#  define ERLANG_DRIVER_NAME(NAME) NAME ## _driver_init
#  define ERL_DRIVER_EXPORT
#else
#  define ERLANG_DRIVER_NAME(NAME) driver_init
#  if defined(__GNUC__) && __GNUC__ >= 4
#    define ERL_DRIVER_EXPORT __attribute__ ((visibility("default")))
#  elif defined (__SUNPRO_C) && (__SUNPRO_C >= 0x550)
#    define ERL_DRIVER_EXPORT __global
#  else
#    define ERL_DRIVER_EXPORT
#  endif
#endif

#ifndef ERL_DRIVER_TYPES_ONLY

#define DRIVER_INIT(DRIVER_NAME) \
    ERL_DRIVER_EXPORT ErlDrvEntry* ERLANG_DRIVER_NAME(DRIVER_NAME)(void); \
    ERL_DRIVER_EXPORT ErlDrvEntry* ERLANG_DRIVER_NAME(DRIVER_NAME)(void)

三个回调如下：

typedef struct {
    ErlDrvPort port;
} data;

static ErlDrvData drv_start(ErlDrvPort port, char* buf)
{
    data* d = (data*)driver_alloc(sizeof(data));
    d->port = port;
    return (ErlDrvData)d;
}

static void drv_stop(ErlDrvData handle)
{
    driver_free(handle);
}

void split_string(char* s, char** s1, char** s2)
{
    *s1 = s;
    *s2 = s + strlen(s) + 1;    
}

static void drv_output(ErlDrvData handle, char* buf,
        ErlDrvSizeT len)
{
    data* d = (data*)handle;
    char *s1, *s2;

    int res = 0, fn = buf[0];
    
    if (fn == 1) {
        res = strlen(buf + 1);
    } else if (fn == 2) {
        split_string(buf + 1, &s1, &s2);
        res = strcmp(s1,s2);
    }

    driver_output(d->port, (char*)&res, 1);
}

依然是利用端口交互。

分布式Erlang节点

分布式方式用C创建一个Erlang节点，以分布式的方式和Erlang交互。很独特的一种方法，详细的工作原理和数据格式以后会分析。

%% Erlang
-module(complex4).
-export([strlen/1, strcmp/2]).

-define(CNODE, 'cnode@192.168.0.4').

strlen(S) ->
    call_port({strlen, S}).
strcmp(S, T) ->
    call_port({strcmp, S, T}).

call_port(Msg) ->
    {any, ?CNODE} ! {call, self(), Msg},
    receive
        {cnode, Result} ->
            Result
    end.

另一端是什么语言编写的完全无所谓。

C程序用ErlMessage封装了消息：

typedef struct {
  int type;   /* one of the message type constants in eiext.h */
  ETERM *msg; /* the actual message */
  ETERM *from;
  ETERM *to;
  char to_name[MAXREGLEN+1];
} ErlMessage;

erl_receive_msg 接收消息，erl_send 发送消息，消息格式用erl_interface封装。可以实现为服务端和客户端，服务端等待Erlang节点连接，客户端节点要在Erlang启动后发起连接：

    erl_init(NULL, 0);

    addr.s_addr = inet_addr("192.168.0.4");
    if (erl_connect_xinit("192.168.0.4", "cnode", "cnode@192.168.0.4",
                &addr, "123456", 0) == -1)
        erl_err_quit("erl_connect_init error");

    if ((listen = listen_port(port)) <= 0)
        erl_err_quit("listen_port error");

    if (erl_publish(port) == -1)
        erl_err_quit("erl_publish error");

    if ((fd = erl_accept(listen, &conn)) == ERL_ERROR)
        erl_err_quit("erl_accept error");

    erl_init(NULL, 0);

    addr.s_addr = inet_addr("192.168.0.4");
    if (erl_connect_xinit("192.168.0.4", "cnode", "cnode@192.168.0.4",
                &addr, "123456", 0) == -1)
        erl_err_quit("erl_connect_init error");

    if ((fd = erl_connect("e1@192.168.0.4")) <0)
        erl_err_quit("erl_connect error");

    fprintf(stderr, "Connected to e1@192.168.0.4\n"); 

连接成功后就是数据交互：

    while (loop) {
        got = erl_receive_msg(fd, buf, BUFSIZE, &emsg);
        if (got == ERL_ERROR) {
            loop = 0;
        } else if (got == ERL_TICK) {
            // pass
        } else {
            if (emsg.type == ERL_REG_SEND) {
                fromp = erl_element(2, emsg.msg);
                tuplep = erl_element(3, emsg.msg);
                fnp = erl_element(1, tuplep);
                s1 = erl_element(2, tuplep);
                
                if (strncmp((const char*)ERL_ATOM_PTR(fnp), "strlen", 6) == 0) {
                    res = strlen(erl_iolist_to_string(s1)); 
                } else if (strncmp((const char*)ERL_ATOM_PTR(fnp), "strcmp", 6) == 0) {
                    s2 = erl_element(3, tuplep);
                    res = strcmp(erl_iolist_to_string(s1), erl_iolist_to_string(s2));
                }

                resp = erl_format("{cnode, ~i}", res);
                erl_send(fd, fromp, resp);

                erl_free_term(emsg.from);
                erl_free_term(emsg.msg);
                erl_free_term(fromp);
                erl_free_term(tuplep);
                erl_free_term(fnp);
                erl_free_term(s1);
                erl_free_term(s2);
                erl_free_term(resp);
            }
        }
    }

NIF

最后一张方式，也是最新的，实现NIF内部函数。具体来说，就是编写一个动态链接库，加载到Erlang虚拟机，导出接口让Erlang调用。

-module(complex5).
-export([cstrlen/1, cstrcmp/2]).

-on_load(init/0).

init() ->
    ok = erlang:load_nif("./cnif", 0).

cstrlen(_S) ->
    exit(nif_library_not_loaded).

cstrcmp(_S, _T) ->
    exit(nif_library_not_loaded).

load_nif 加载模块，erlang形式的函数用于模块导出函数不存在时的stub。

C程序填充ERL_NIF_INIT宏：

#define ERL_NIF_INIT(NAME, FUNCS, LOAD, RELOAD, UPGRADE, UNLOAD) \
ERL_NIF_INIT_PROLOGUE                   \
ERL_NIF_INIT_GLOB                       \
ERL_NIF_INIT_DECL(NAME);        \
ERL_NIF_INIT_DECL(NAME)         \
{                   \
    static ErlNifEntry entry =      \
    {                   \
    ERL_NIF_MAJOR_VERSION,      \
    ERL_NIF_MINOR_VERSION,      \
    #NAME,              \
    sizeof(FUNCS) / sizeof(*FUNCS), \
    FUNCS,              \
    LOAD, RELOAD, UPGRADE, UNLOAD,  \
    ERL_NIF_VM_VARIANT,     \
    ERL_NIF_ENTRY_OPTIONS       \
    };                                  \
    ERL_NIF_INIT_BODY;                  \
    return &entry;          \
}     

实际上是初始化了ErlNifEntry结构体。

typedef struct enif_entry_t
{
    int major;
    int minor;
    const char* name;
    int num_of_funcs;
    ErlNifFunc* funcs;
    int  (*load)   (ErlNifEnv*, void** priv_data, ERL_NIF_TERM load_info);
    int  (*reload) (ErlNifEnv*, void** priv_data, ERL_NIF_TERM load_info);
    int  (*upgrade)(ErlNifEnv*, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info);
    void (*unload) (ErlNifEnv*, void* priv_data);
    const char* vm_variant;
    unsigned options;
}ErlNifEntry;

作为简单例子，这里只关注导出函数：

static ErlNifFunc nif_func[] = {
    {"cstrlen", 1, strlen_nif},
    {"cstrcmp", 2, strcmp_nif}
};

分别是函数名、元数和实现：

static ERL_NIF_TERM strlen_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    int ret;
    char s[100];
    
    if (!enif_get_string(env, argv[0], s, 100, 1)) {
        return enif_make_badarg(env);
    }

    ret = strlen(s);

    return enif_make_int(env, ret);
}

static ERL_NIF_TERM strcmp_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    int ret;
    char s1[100], s2[100];

    if (!enif_get_string(env, argv[0], s1, 100, 1) || 
            !enif_get_string(env, argv[1], s2, 100, 1)) {
        return enif_make_badarg(env);
    }

    ret = strcmp(s1, s2);

    return enif_make_int(env, ret);
}

最后

完整的代码在这里找到。

对我而言，平时C语言写的最多，而且往往是内核模块。结合C和Erlang是很有必要的，一定要搞清楚交互方式。这几种方式都透露着Erlang的设计哲学和内部实现，接下来需要深入代码来学习了。