-export([timed_run/3]).

producer(0, ConsumerPid, WithAck) ->
ConsumerPid ! {done, self()},
receive
done -> ok
end;
producer(N, ConsumerPid, WithAck = false) ->
ConsumerPid ! {msg, self()},
producer(N-1, ConsumerPid, WithAck);
producer(N, ConsumerPid, WithAck = true) ->
ConsumerPid ! {ackedmsg, self()},
receive
ack -> ok
end,
producer(N-1, ConsumerPid, WithAck).

consumer(M, EchoPid) ->
receive
{msg, From} ->
callecho(M, EchoPid),
consumer(M, EchoPid);
{ackedmsg, From} ->
From ! ack,
callecho(M, EchoPid),
consumer(M, EchoPid);
{done, From} ->
EchoPid ! done,
From ! done
end.

queuekeeperempty(ConsumerPid) ->
receive
{msg, From} ->
ConsumerPid ! {ackedmsg, self()},
queuekeeperwaiting(queue:new(), ConsumerPid);
{done, From} ->
ConsumerPid ! {done, self()},
receive
done ->
From ! done
end
end.

queuekeeperwaiting(Q, ConsumerPid) ->
receive
{msg, From} ->
queuekeeperwaiting(queue:in({ackedmsg, self()}, Q), ConsumerPid);
ack -> case queue:out(Q) of
{{value, Msg}, Q1} ->
ConsumerPid ! Msg,
queuekeeperwaiting(Q1, ConsumerPid);
{empty, Q} -> queuekeeperempty(ConsumerPid)
end
end.

callecho(0, _EchoPid) ->
ok;
callecho(M, EchoPid) ->
EchoPid ! {hello, self()},
receive
hello -> call_echo(M-1, EchoPid)
end.

echo() ->
receive
{Msg, From} ->
From ! Msg,
echo();
done -> ok
end.

run(N, M, WithAck) ->
EchoPid = spawnlink(fun echo/0),
ConsumerPid = spawnlink(
fun () ->
consumer(M, EchoPid) end),
case WithAck of
true ->
producer(N, ConsumerPid, WithAck);
false ->
producer(N, spawnlink(
fun() ->
queuekeeper_empty(ConsumerPid) end), WithAck)
end.

time(F) ->
Start = erlang:now(),
F(),
timer:now_diff(erlang:now(), Start).

timed_run(N, M, WithAck) ->
time(fun() -> run(N, M, WithAck) end).

With own queue managing it’s only about 1.25 times slower and not blocking producer.

Cheers,
Daniel

If the producer must send messages asynchronously, then a solution is to add a buffering process between it and the consumer. Send async messages and the buffer will make sync calls to the consumer, sending a small number of messages at a time and then waiting for ack.

Of course, this works only if the messages aren’ t to be selectively received.

regards,
Vlad

So, how did you go about solving this problem ?

I made the interaction between the producer and consumer synchronous. That is not an appropriate solution in general, but in this particular case it was the easiest and correct thing to do.

Did you use an intermediate process, or did you empty the message box into a seperate list ? or …. ?

Another bug-like behaviour with erlang is with regards to it’s string handling (iirc as doubly linked lists with one node per character) which tripped up tim bray:

http://www.tbray.org/ongoing/When/200x/2007/09/20/Wide-Finder