Dining Philosophers (my implementation) processes don't communicate - concurrency

Question

I'm attempting to implement my own solution for the well known Dijkstra's Dining Philosophers problem. All I'm given is the state machines and that a philosopher should grab both of the forks at the same time.
Here is my code:
-module(assess3).
-compile([export_all]).
-define(EAT,1000).
-define(THINK,1000).
college() ->
R = spawn_link(?MODULE, report,[]),
F1 = spawn_link(?MODULE, fork,["fork1",R]),
F2 = spawn_link(?MODULE, fork,["fork2",R]),
F3 = spawn_link(?MODULE, fork,["fork3",R]),
F4 = spawn_link(?MODULE, fork,["fork4",R]),
F5 = spawn_link(?MODULE, fork,["fork5",R]),
spawn_link(?MODULE, philosopher,["Socrates", R, F1,F2]),
spawn_link(?MODULE, philosopher,["Confucius", R, F2,F3]),
spawn_link(?MODULE, philosopher,["Aristole", R, F3,F4]),
spawn_link(?MODULE, philosopher,["Homer", R, F4,F5]),
spawn_link(?MODULE, sphilosopher,["Plato", R, F1,F5]).
%%create philosophers randomly
philosopher(Name, Report, LeftF, RightF) ->
random:seed(erlang:phash2([node()]),
erlang:monotonic_time(),erlang:unique_integer()),
create_phils(Name,Report,LeftF,RightF).
%%create special philosopher
sphilosopher(Name, Report, RightF, LeftF) ->
random:seed(erlang:phash2([node()]),
erlang:monotonic_time(),erlang:unique_integer()),
create_special_phil(Name,Report,RightF,LeftF).
%%creates random 4 philosophers who get the Left fork first then the right fork
create_phils(Name,Report,LeftF,RightF) ->
%%thinking state
reporting(Name,Report,thinking),
timer:sleep(random:uniform(?THINK)),
%%hungry state
reporting(Name,Report,hungry),
LeftF ! RightF! {pick,self()},
receive
{pick, LeftF} -> reporting(Report, Name, left);
{pick, RightF} -> reporting(Report, Name, right)
end,
receive
{pick, LeftF} -> reporting(Report, Name, left);
{pick, RightF} -> reporting(Report, Name, right)
end,
%%eating state
reporting(Report,Name,eating),
timer:sleep(random:uniform(?EAT)),
LeftF ! RightF ! {let_go,self()},
create_phils(Name,Report,LeftF,RightF).
%%create special philosopher who attempts to communicate first with the
%%right fork proccess instead of the left fork
create_special_phil(Name,Report,RightF,LeftF) ->
%%thinking state
reporting(Name,Report,thinking),
timer:sleep(random:uniform(?THINK)),
%%hungry state
reporting(Name,Report,hungry),
RightF ! LeftF ! {pick,self()},
receive
{pick, RightF} -> reporting(Report, Name, right);
{pick, LeftF} -> reporting(Report, Name, left)
end,
receive
{pick, RightF} -> reporting(Report, Name, right);
{pick, LeftF} -> reporting(Report, Name, left)
end,
%%eating state
reporting(Report,Name,eating),
timer:sleep(random:uniform(?EAT)),
RightF ! LeftF ! {let_go,self()},
create_special_phil(Name,Report,RightF,LeftF).
%%prepares what the Report proccess will print
reporting(Name,Report,Status) ->
Report ! {Name,Status,self()},
receive
{Report,ack} -> true
end.
%%Report proccess, receives and prints
report() ->
receive
{Name,Status, Pid} ->
io:format("~s : ~s ~n",[Name,status(Status)]),
Pid ! {ack,self()},
report()
end.
%%function to pass the appropriate status in string for io:format
status(Status) ->
case Status of
thinking -> "is thinking";
hungry -> "is hungry";
eating -> "is eating";
right -> "got right fork";
left -> "got left fork";
on_table -> "on table";
in_use ->"in use";
Status -> atom_to_list(Status)
end.
fork(Name,Report) ->
receive
{picked,Pid} ->
reporting(Report,Name,in_use),
Pid ! {picked,self()},
receive
{let_go,Pid} ->
reporting(Report,Name,on_table)
end,
fork(Name,Report)
end.
I get no errors at all but when I try to run assess3:college(). in the Erlang shell, instead of seeing the processes communicate, all I see is this:
Socrates : is thinking
Confucius : is thinking
<0.265.0>
Aristole : is thinking
Homer : is thinking
Plato : is thinking
I do not understand why this occurs, because before I started coding I designed everything by hand in order to avoid getting lost. Any help appreciated.
PS. this implementation is supposed to prevent deadlock because four philosophers grab the left fork first and the 5th one tries to pick the right fork first, although I do understand that this can run into resource starvation meaning that one philosopher might never eat. I don't care about this for now — one step at a time.

Answer 1

You have several problems related to mismatched messages, and function arguments in the wrong order. The mismatched messages cause things to hang waiting forever for messages that are never sent. Fixing those issues then leads to crashes because of the incorrect arguments problem.
For example, consider your fork function:
fork(Name,Report) ->
receive
{picked,Pid} ->
reporting(Report,Name,in_use),
Pid ! {picked,self()},
receive
{let_go,Pid} ->
reporting(Report,Name,on_table)
end,
fork(Name,Report)
end.
It's waiting for a {picked,...} message, but your philosophers are sending {pick,...} messages, and it's replying with a {picked,...} message but the philosophers are expecting to receive {pick,...} messages.
Have a look at your report function:
report() ->
receive
{Name,Status, Pid} ->
io:format("~s : ~s ~n",[Name,status(Status)]),
Pid ! {ack,self()},
report()
end.
It sends an {ack, self()} message back to Pid, but those processes are expecting {Report, ack} messages.
In a number of places you call reporting(Report,Name,...) where the Report and Name arguments are in the wrong order.
Here's a fixed version that seems to work.
-module(assess3).
-compile([export_all]).
-define(EAT,1000).
-define(THINK,1000).
college() ->
R = spawn_link(?MODULE, report,[]),
F1 = spawn_link(?MODULE, fork,["fork1",R]),
F2 = spawn_link(?MODULE, fork,["fork2",R]),
F3 = spawn_link(?MODULE, fork,["fork3",R]),
F4 = spawn_link(?MODULE, fork,["fork4",R]),
F5 = spawn_link(?MODULE, fork,["fork5",R]),
spawn_link(?MODULE, philosopher,["Socrates", R, F1,F2]),
spawn_link(?MODULE, philosopher,["Confucius", R, F2,F3]),
spawn_link(?MODULE, philosopher,["Aristole", R, F3,F4]),
spawn_link(?MODULE, philosopher,["Homer", R, F4,F5]),
spawn_link(?MODULE, sphilosopher,["Plato", R, F1,F5]).
%%create philosophers randomly
philosopher(Name, Report, LeftF, RightF) ->
random:seed(erlang:phash2([node()]),
erlang:monotonic_time(),erlang:unique_integer()),
create_phils(Name,Report,LeftF,RightF).
%%create special philosopher
sphilosopher(Name, Report, RightF, LeftF) ->
random:seed(erlang:phash2([node()]),
erlang:monotonic_time(),erlang:unique_integer()),
create_special_phil(Name,Report,RightF,LeftF).
%%creates random 4 philosophers who get the Left fork first then the right fork
create_phils(Name,Report,LeftF,RightF) ->
%%thinking state
reporting(Name,Report,thinking),
timer:sleep(random:uniform(?THINK)),
%%hungry state
reporting(Name,Report,hungry),
LeftF ! RightF ! {pick,self()},
receive
{picked, LeftF} -> reporting(Name, Report, left);
{picked, RightF} -> reporting(Name, Report, right)
end,
receive
{picked, LeftF} -> reporting(Name, Report, left);
{picked, RightF} -> reporting(Name, Report, right)
end,
%%eating state
reporting(Name,Report,eating),
timer:sleep(random:uniform(?EAT)),
LeftF ! RightF ! {let_go,self()},
create_phils(Name,Report,LeftF,RightF).
%%create special philosopher who attempts to communicate first with the
%%right fork proccess instead of the left fork
create_special_phil(Name,Report,RightF,LeftF) ->
%%thinking state
reporting(Name,Report,thinking),
timer:sleep(random:uniform(?THINK)),
%%hungry state
reporting(Name,Report,hungry),
RightF ! LeftF ! {pick,self()},
receive
{picked, RightF} -> reporting(Name, Report, right);
{picked, LeftF} -> reporting(Name, Report, left)
end,
receive
{picked, RightF} -> reporting(Name, Report, right);
{picked, LeftF} -> reporting(Name, Report, left)
end,
%%eating state
reporting(Name,Report,eating),
timer:sleep(random:uniform(?EAT)),
RightF ! LeftF ! {let_go,self()},
create_special_phil(Name,Report,RightF,LeftF).
%%prepares what the Report proccess will print
reporting(Name,Report,Status) ->
Report ! {Name,Status,self()},
receive
{Report,ack} -> ok
end.
%%Report proccess, receives and prints
report() ->
receive
{Name,Status,Pid} ->
io:format("~s : ~s ~n",[Name,status(Status)]),
Pid ! {self(),ack},
report()
end.
%%function to pass the appropriate status in string for io:format
status(Status) ->
case Status of
thinking -> "is thinking";
hungry -> "is hungry";
eating -> "is eating";
right -> "got right fork";
left -> "got left fork";
on_table -> "on table";
in_use ->"in use";
Status -> atom_to_list(Status)
end.
fork(Name,Report) ->
receive
{pick,Pid} ->
reporting(Name,Report,in_use),
Pid ! {picked,self()},
receive
{let_go,Pid} ->
reporting(Name,Report,on_table)
end,
fork(Name,Report)
end.