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 <unistd.h>
#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 < len);
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 < len);
return len;
}
// C
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#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 < len; ++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 <unistd.h>
#include <string.h>
#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的设计哲学和内部实现，接下来需要深入代码来学习了。