native modules working

Author: mojombo

contrib/ebench.erl

@@ -0,0 +1,59 @@
+% erlc *.erl && erl ebench.beam -run ebench start 10000 20
+
+-module(ebench).
+-export([start/1]).
+
+start([Ni, Ci]) ->
+  Nt = list_to_integer(Ni),
+  C = list_to_integer(Ci),
+  N = round(Nt / C),
+  T0 = erlang:now(),
+  Waiter = spawn(fun() -> wait(T0, N * C) end),
+  spawner(Waiter, N, C).
+
+spawner(_Waiter, _N, 0) ->
+  ok;
+spawner(Waiter, N, C) ->
+  spawn(fun() -> loop(Waiter, N) end),
+  spawner(Waiter, N, C - 1).
+
+% X is the total number of responses to wait for
+wait(T0, XTotal, 0) ->
+  T1 = erlang:now(),
+  Diff = timer:now_diff(T1, T0),
+  Mean = Diff / XTotal,
+  io:format("~p requests completed in ~.2fs~n", [XTotal, Diff / 1000000]),
+  io:format("Mean request time: ~.2fms (~.2f r/s)~n", [Mean / 1000, XTotal / (Diff / 1000000)]),
+  init:stop();
+wait(T0, XTotal, X) ->
+  receive
+    done -> wait(T0, XTotal, X - 1)
+  end.
+
+wait(T0, X) ->
+  wait(T0, X, X).
+
+loop(_Waiter, 0) ->
+  ok;
+loop(Waiter, N) ->
+  hit(Waiter),
+  loop(Waiter, N - 1).
+
+hit(Waiter) ->
+  % io:format("outgoing!~n", []),
+  Host = "localhost",
+  {ok, Sock} = gen_tcp:connect(Host, 8000, [binary, {packet, 4}]),
+  Request = term_to_binary({call, nat, add, [1, 2]}),
+  ok = gen_tcp:send(Sock, Request),
+  receive
+    {tcp, _Port, Reply} ->
+      % io:format("~p~n", [Reply]),
+      {reply, 3} = binary_to_term(Reply),
+      Waiter ! done,
+      ok;
+    Any ->
+      io:format("Unexpected message: ~p~n", [Any]),
+      Waiter ! done,
+      ok
+  end,
+  ok = gen_tcp:close(Sock).

elib/config.erl

@@ -11,15 +11,15 @@ load_single(Config) ->
     native ->
       verify(native, Config),
       CodePaths = proplists:get_value(codepaths, Config),
-      lists:each(fun(X) -> code:add_patha(X) end, CodePaths),
-      Config;
+      lists:map((fun code:add_patha/1), CodePaths),
+      [{id, native} | Config];
     extern ->
       verify(extern, Config),
       Handler = proplists:get_value(command, Config),
       Number = proplists:get_value(count, Config),
       {ok, SupPid} = asset_pool_sup:start_link(Handler, Number),
       [{_Id, ChildPid, _Type, _Modules}] = supervisor:which_children(SupPid),
-      [{pid, ChildPid} | Config]
+      [{id, ChildPid} | Config]
   end.
 
 verify(native, _Config) ->

elib/ernie_server.erl

@@ -97,9 +97,9 @@ code_change(_OldVersion, State, _Extra) -> {ok, State}.
 %%====================================================================
 
 extract_mapping(Config) ->
-  Pid = proplists:get_value(pid, Config),
+  Id = proplists:get_value(id, Config),
   Mods = proplists:get_value(modules, Config),
-  lists:map(fun(X) -> {X, Pid} end, Mods).
+  lists:map(fun(X) -> {X, Id} end, Mods).
 
 init_map(Configs) ->
   lists:foldl(fun(X, Acc) -> Acc ++ extract_mapping(X) end, [], Configs).
@@ -173,12 +173,17 @@ process_request(Request, State) ->
   {_Type, Mod, _Fun, _Args} = ActionTerm,
   Pid = proplists:get_value(Mod, State#state.map),
   case Pid of
-    undefined ->
+    native ->
       logger:debug("Dispatching to native module~n", []),
-      process_native_request(Request, State);
-    ValidPid ->
+      process_native_request(ActionTerm, Request, State);
+    ValidPid when is_pid(ValidPid) ->
       logger:debug("Found extern pid ~p~n", [ValidPid]),
-      process_extern_request(ValidPid, Request, State)
+      process_extern_request(ValidPid, Request, State);
+    undefined ->
+      Sock = Request#request.sock,
+      gen_tcp:send(Sock, term_to_binary({error})),
+      ok = gen_tcp:close(Sock),
+      State
   end.
 
 close_if_cast(ActionTerm, Request) ->
@@ -192,8 +197,12 @@ close_if_cast(ActionTerm, Request) ->
       ok
   end.
 
-process_native_request(_Request, State) ->
-  State.
+process_native_request(ActionTerm, Request, State) ->
+  Count = State#state.count,
+  State2 = State#state{count = Count + 1},
+  logger:debug("Count = ~p~n", [Count + 1]),
+  spawn(fun() -> native:process(ActionTerm, Request) end),
+  State2.
 
 process_extern_request(Pid, Request, State) ->
   case queue:is_empty(State#state.pending) of

elib/native.erl

@@ -0,0 +1,16 @@
+-module(native).
+-export([process/2]).
+
+-record(request, {sock = undefined,
+                  info = undefined,
+                  action = undefined}).
+
+process(ActionTerm, Request) ->
+  {_Type, Mod, Fun, Args} = ActionTerm,
+  Sock = Request#request.sock,
+  logger:debug("Calling ~p:~p(~p)~n", [Mod, Fun, Args]),
+  Result = apply(Mod, Fun, Args),
+  logger:debug("Result was ~p~n", [Result]),
+  Data = term_to_binary({reply, Result}),
+  gen_tcp:send(Sock, Data),
+  ok = gen_tcp:close(Sock).

examples/dsl.cfg

@@ -2,9 +2,9 @@
 require 'ernie'
 
 # logfile('/tmp/ernie.log')
-# loglevel(Logger::INFO)
+loglevel(Logger::FATAL)
 
-mod(:test) do
+mod(:dsl) do
   # Add two numbers together
   fun(:add) do |a, b|
     a + b

examples/dsl.rb

@@ -0,0 +1,8 @@
+[{modules, [dsl]},
+ {type, extern},
+ {command, "ruby examples/dsl.rb"},
+ {count, 2}].
+
+[{modules, [nat]},
+ {type, native},
+ {codepaths, ["examples"]}].

examples/example.cfg

@@ -1,7 +1,7 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'ernie'
 
-module Test
+module Expose
   # Add two numbers together
   def add(a, b)
     a + b
@@ -24,4 +24,4 @@ def error
   end
 end
 
-Ernie.expose(:test, Test)
+Ernie.expose(:expose, Expose)

examples/expose.rb

@@ -0,0 +1,5 @@
+-module(nat).
+-export([add/2]).
+
+add(A, B) ->
+  A + B.