【Erlang新手成长日记】Erlang端口与外部C程序交互

参考文档：

　　《Programming Erlang》，第12章：Interfacing Techniques

 

创建C源文件：

　　hello.c  具体函数的实现

int twice(int arg) {
    return (arg * arg);
}

int sum(int arg1, int arg2) {
    return (arg1 + arg2);
}

 

　　hello_driver.c  驱动程序运行

#include <stdio.h>

#define BUFFER_SIZE 100

typedef unsigned char byte; //8 bit

int read_cmd(byte *buffer);
int write_cmd(byte *buffer, int length);

int main() {
    int function_number; //函数号
    int arg1, arg2; //参数
    int result; //结果
    byte buffer[BUFFER_SIZE]; //缓冲区
    
    while(read_cmd(buffer) > 0) {
        function_number = buffer[0];
        switch(function_number) {
            case 1:
                //执行函数 twice
                arg1 = buffer[1];
                result = twice(arg1);
                break;
            case 2:
                //执行函数 sum
                arg1 = buffer[1];
                arg2 = buffer[2];
                result = sum(arg1, arg2);
                break;
            default:
                // error
                break;
        }
        buffer[0] = result;
        write_cmd(buffer, 1);
    }
    
    return 0;
}

 

　　erl_communication.c  与Erlang程序交互

#include <unistd.h>

typedef unsigned char byte;

int read_cmd(byte *buffer);
int write_cmd(byte *buffer, int length);
int read_exact(byte *buffer, int length);
int read_exact(byte *buffer, int length);

int read_cmd(byte *buffer) {
    int length; //int 长度 16 bit
    
    if(read_exact(buffer, 2) != 2) {
        return -1;
    }
    length = (buffer[0] << 8) | buffer[1];
    
    return read_exact(buffer, length);
}

int write_cmd(byte *buffer, int length) {
    byte li; //unsigned char 长度 8 bit
    
    li = (length >> 8) & 0xff;
    write_exact(&li, 1);
    li = length & 0xff;
    write_exact(&li, 1);
    
    return write_exact(buffer, length);
}

int read_exact(byte *buffer, int length) {
    int i, got = 0;
    
    do {
        /*
         * read函数定义：ssize_t read(int fildes, void *buf, size_t nbyte);
         * read函数描述：The read() function attempts to read nbyte bytes from the file associated with the open file descriptor, fildes, into the buffer pointed to by buf.
         * 备注：fildes值0，标准输入
         */
        if((i = read(0, (buffer + got), (length - got))) <= 0) {
            return i;
        }
        got += i;
    } while(got < length);
    
    return length;
}

int write_exact(byte *buffer, int length) {
    int i, wrote = 0;
    
    do {
        /*
         * write函数定义：ssize_t write(int fildes, const void *buf, size_t nbyte);
         * write函数描述：The write() function attempts to write nbyte bytes from the buffer pointed to by buf to the file associated with the open file descriptor, fildes.
         * 备注：fildes值1，标准输出
         */
        if((i = write(1, (buffer + wrote), (length - wrote)))) {
            return i;
        }
        wrote += i;
    } while(wrote < length);
    
    return length;
}

 

创建Erlang源文件

　　hello.erl  创建进程，打开与C生成的可执行文件之间的端口，通过消息传递进行交互

　　Port = open_port(PortName, PortSettings)

　　open_port/2：http://www.erlang.org/doc/man/erlang.html#open_port-2  

　　This returns a port. The following messages can be sent to a port: 

　　Port ! {PidC, {command, Data}}  

　　　　Send Data (an IO List) to the port.

　　Port ！{PidC, {connect, Pid1}}

　　　　Change the PID of the connected process from PidC to Pid1.

　　Port ! {PidC, close}

　　　　Close the port.

-module(hello).

-export([start/0, stop/0]).
-export([twice/1, sum/2]).

-define(PORTNAME, ?MODULE).

start() ->
    Fun = fun() ->
            register(?PORTNAME, self()),
            process_flag(trap_exit, true),
            Port = open_port({spawn, "./hello"}, [{packet, 2}]),
            loop(Port)
        end,
    spawn(Fun).
    
stop() -> 
    ?PORTNAME ! stop.
    
twice(X) -> call_port({twice, X}).
sum(X, Y) -> call_port({sum, X, Y}).

call_port(Message) ->
    ?PORTNAME ! {call, self(), Message},
    receive
        {?PORTNAME, Result} ->
            Result
    end.
    
loop(Port) -> 
    receive
        {call, Caller, Message} ->
            Port ! {self(), {command, encode(Message)}},
            receive
                {Port, {data, Data}} ->
                    Caller ! {?PORTNAME, decode(Data)}
            end,
            loop(Port);
        stop ->
            Port ! {self(), close},
            receive
                {Port, closed} ->
                    exit(normal)
            end;
        {'EXIT', Port, Reason} ->
            exit({port_terminated, Reason})
    end.
    
encode({twice, X}) ->
    [1, X];
encode({sum, X, Y}) ->
    [2, X, Y].
    
decode([Int]) ->
    Int.

 

编译C源文件，生成可执行文件

gcc -o hello hello.c hello_driver.c erl_communication.c

 

编译Erlang源文件，生成.beam文件

erlc hello.erl