programming erlang ch12 - andstudy/forge GitHub Wiki

• example1.c

    int twice(int x) {
    	return 2 * x;
    }
    
    int sum(int x, int y) {
    	return x + y;
    }
  

• erlang에서 실행하는 형태

    X1 = example1:twice(23).
    Y1 = example1:sum(45, 32).
  

• 얼랭 병행 프로그래밍에서 프로세스를 생성하고 메시지를 송수신하는 것과 비슷하게 동작

• C 프로그램은 얼랭 시스템 외부에서 실행되고, 포트를 통해서만 메시지를 송수신

• 가장 권장하는 방법

• 포트생성

    @spec open_port(PortName, [Opt]) -> Port
  

• 포트를 통해 C 프로그램으로 메시지 전송 및 수신

    Port ! {PidC, {command, Data}}
    Port ! {PidC, {connect, Pid1}}
    Port ! {PidC, close}
    
    receive
        {Port, {data, Data}} ->
           ...
  

• example1.erl

    ...
    
    start() ->
    ...
    		  Port = open_port({spawn, "./example1"}, [{packet, 2}]),
    ...
    
    loop(Port) ->
        receive
    	{call, Caller, Msg} ->
    	    Port ! {self(), {command, encode(Msg)}}, 
    	    receive
    		{Port, {data, Data}} ->
    		    Caller ! {example1, 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. 
  

• Port = open_port({spawn, "./example1"}, [{packet, 2}])

  • 2바이트 헤더 자동 추가 (1, 2, 4중 택일)
  • twice(10) 일 경우, <<0, 2, 1, 10>>

• {Port, {data, Data}}

  • 데이터 수신

• {Port, closed}

  • 포트가 닫혔을 경우 수신

• {'EXIT', Port, Reason}

  • 에러가 났을 경우 수신

• example_driver1.c

    int main() {
    	int fn, arg1, arg2, result;
    	byte buff[100];
    
    	while (read_cmd(buff) > 0) {
    		fn = buff[0];
    
    		if (fn == 1) {
    			arg1 = buff[1];
    			result = twice(arg1);
    		} else if (fn == 2) {
    			arg1 = buff[1];
    			arg2 = buff[2];
    			result = sum(arg1, arg2);
    		}
    
    		buff[0] = result;
    		write_cmd(buff, 1);
    	}
    }
  

• erl_comm.c

    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);
    }
  

• read(0, buf+got, len-got)

  • 표준 입력을 통해 erlang으로부터 메시지 수신

• write(1, buf+wrote, len-wrote)

  • 표준 출력을 통해 erlang으로 메시지 송신

• erlang과의 패킷을 맞추기 위해 write_cmd 에 2바이트 헤더 수동으로 추가

    1> example1:start().
    <0.32.0>
    2> example1:sum(43, 32).
    77
    3> example1:twice(10).
    20

• 포트 프로그램과 정확하게 똑같은 프로토콜을 따른다
• 얼랭 시스템 "내부" 에서 실행된다는 점이 포트와의 차이점
• 효율성 측면에서 좋을 수도 있지만, 문제가 생길 경우 얼랭 시스템에 영향을 미치는 위험성

• example1_lid.erl

    ...
    
    start() ->
        start("example1_drv").
    
    start(SharedLib) ->
        case erl_ddll:load_driver(".", SharedLib) of
    	ok -> ok;
    	{error, already_loaded} -> ok;
    	_ -> exit({error, could_not_load_driver})
        end,
        spawn(fun() -> init(SharedLib) end).
    
    init(SharedLib) ->
        register(example1_lid, self()),
        Port = open_port({spawn, SharedLib}, []),
        loop(Port).
    
    ...
  

• erl_ddll:load_driver(".", SharedLib)

  • C 드라이버를 (Unix에서는 so, Windows에서는 dll) 얼랭 시스템 내부에 로딩

• open_port({spawn, SharedLib}, [])

  • 포트 생성

• example1_lid.c

    #include <stdio.h>
    #include "erl_driver.h"
    
    typedef struct {
        ErlDrvPort port;
    } example_data;
    
    static ErlDrvData example_drv_start(ErlDrvPort port, char *buff)
    {
        example_data* d = (example_data*)driver_alloc(sizeof(example_data));
        d->port = port;
        return (ErlDrvData)d;
    }
    
    static void example_drv_stop(ErlDrvData handle)
    {
        driver_free((char*)handle);
    }
    
    static void example_drv_output(ErlDrvData handle, char *buff, int bufflen)
    {
        example_data* d = (example_data*)handle;
        char fn = buff[0], arg = buff[1], res;
        if (fn == 1) {
          res = twice(arg);
        } else if (fn == 2) {
          res = sum(buff[1], buff[2]);
        }
        driver_output(d->port, &res, 1);
    }
    
    ErlDrvEntry example_driver_entry = {
        NULL,               /* F_PTR init, N/A */
        example_drv_start,  /* L_PTR start, called when port is opened */
        example_drv_stop,   /* F_PTR stop, called when port is closed */
        example_drv_output, /* F_PTR output, called when erlang has sent
    			   data to the port */
        NULL,               /* F_PTR ready_input, 
                               called when input descriptor ready to read*/
        NULL,               /* F_PTR ready_output, 
                               called when output descriptor ready to write */
        "example1_drv",     /* char *driver_name, the argument to open_port */
        NULL,               /* F_PTR finish, called when unloaded */
        NULL,               /* F_PTR control, port_command callback */
        NULL,               /* F_PTR timeout, reserved */
        NULL                /* F_PTR outputv, reserved */
    };
    
    DRIVER_INIT(example_drv) /* must match name in driver_entry */
    {
        return &example_driver_entry;
    }
  

}}}

• driver_alloc
  • thread-safe, driver_free를 통해 명시적으로 해제해야 함
• driver_free
  • thread-safe, driver_alloc을 통해 생성한 메모리 해제
• driver_output
  • Port Owner로 메시지 송신

    1> c(example1_lid).
    {ok, example1_lid}
    2> example1_lid:start().
    <0.41.0>
    3> example1_lid:twice(50).
    100
    4> example1_lid:sum(10, 20).
    30

• 분산 프로그래밍과 유사하게 실행
• 얼랭 프로그램 관점에서 C 프로그램이 하나의 노드처럼 행동
• erl_interface를 통해 C 프로그램 작성
• 사용하는 경우는 매우 드물다 (대부분 포트로 충분)

• example1_cnode.erl

    -module(example1_cnode).
    -export([twice/1, sum/2]).
    
    twice(X) -> X * 2.
    
    sum(X, Y) -> X + Y.
  

• example1_cnode.c

    #define __WIN32__
    
    #include "C:\Program Files\erl5.6.3\lib\erl_interface-3.5.7\include\erl_interface.h"
    #include "C:\Program Files\erl5.6.3\lib\erl_interface-3.5.7\include\ei.h"
    
    int main(int argc, char **argv) {
      int fd;                                  /* fd to Erlang node */
      int res;
    
      ETERM *rpcp, *resp, *argp;
      
      erl_init(NULL, 0);
    
      if (erl_connect_init(1, "secretcookie", 0) == -1)
        erl_err_quit("erl_connect_init");
    
      if ((fd = erl_connect("erlang_node@SSB-PC")) < 0)
        erl_err_quit("erl_connect");
      fprintf(stderr, "Connected to erlang_node@SSB-PC\n\r");
    
    /* twice(10) */
    	argp = erl_format("[~i]", 10);
    	rpcp = erl_rpc(fd, "example1_cnode", "twice", argp);
    	res = ERL_INT_VALUE(rpcp);
    
    	fprintf(stderr, "rpc:call(erlang_node@SSB-PC, example1_cnode, twice, [10])\r\n%d\r\n", res);
    
        erl_free_term(argp);
        erl_free_term(rpcp);
    
    /* sum(11, 22) */
    	argp = erl_format("[~i, ~i]", 11, 22);
    	rpcp = erl_rpc(fd, "example1_cnode", "sum", argp);
    	res = ERL_INT_VALUE(rpcp);
    
    	fprintf(stderr, "rpc:call(erlang_node@SSB-PC, example1_cnode, sum, [11, 22])\r\n%d\r\n", res);
    
        erl_free_term(argp);
        erl_free_term(rpcp);
    }
  

    d:\>erl -sname erlang_node -setcookie secretcookie
    d:\>example1_cnode.exe
    Connected to erlang_node@SSB-PC
    rpc:call(erlang_node@SSB-PC, example1_cnode, twice, [10])
    20
    rpc:call(erlang_node@SSB-PC, example1_cnode, sum, [11, 22])
    33