lock2.erl

-module(lock2).
-export([init/2]).

%lock2: Each lock has a unique identifier: 1,2,3,4 which gives the lock a priority.
%change the waiting state so that a lock in the waiting state will send ok to a request
%if this request is coming from a lock with higher priority. If it comes from a lock
%with lower priority, then proceed as in lock1.

init(MyId, Nodes) ->	%when the lock is started it is given a unique ID: MyId
	open(Nodes, MyId).
	

open(Nodes, MyId) ->
	receive
		{take, Master} ->	%my worker wants the lock
			Refs = requests(Nodes, MyId),	%inform all other locks that i need to be taken
			wait(Nodes, Master, Refs, [], MyId);	%and enter waiting state
		{request, From, Ref, _} ->	%request from another lock
			From ! {ok, Ref},	%immediately reply ok (i'm in open state) 
			open(Nodes, MyId);	%and enter open state again
		stop ->
			ok
	end.

requests(Nodes, MyId) ->	%send a request message to all locks
	lists:map(fun(P) -> R = make_ref(), P ! {request, self(), R, MyId}, R end, Nodes).	%I send my ID together with the request message.

wait(Nodes, Master, [], Waiting, MyId) ->	%waiting state with empty list of locks -- all of the locks sent me an ok message!! -> I can take the lock!
	Master ! taken,		%the lock is taken
	held(Nodes, Waiting, MyId);	%enter the held state

wait(Nodes, Master, Refs, Waiting, MyId) ->	%waiting for ok messages
	receive
	%prepei na allaksw to format tou mhnymatos request, wste na periexei kai to Id tou lock apo to opoio erxetai to request!!!
		{request, From, Ref, Req_Id} ->
			if
				MyId > Req_Id ->	%The requesting lock has higher priority
				From ! {ok, Ref},	%send an ok message to it!	
				%send another request to the lock with higher priority
				%to ensure the "happened before" order
				Ref2 = requests([From], MyId),
				wait(Nodes, Master, Ref2, Waiting, MyId);	%and enter waiting state
				% NOT back to open state -> back to WAIT state!!!
			
				true ->	%I have higher priority: I keep the request and I go on :p
				wait(Nodes, Master, Refs, [{From, Ref}|Waiting], MyId)
			end;
		{ok, Ref} ->	%i received an ok message from a lock
			Refs2 = lists:delete(Ref, Refs),	%and I delete it from my list
			wait(Nodes, Master, Refs2, Waiting, MyId);	%waiting for the rest of the ok messages
		release ->	%I have to release the lock
			ok(Waiting),	%I sent ok messages to the locks that requested me while I was waiting
			open(Nodes, MyId)	%back to open state
	end.

ok(Waiting) ->	%send ok message
	lists:map(fun({F,R}) -> F ! {ok, R} end, Waiting).

held(Nodes, Waiting, MyId) ->	%The lock is mine!!!
	receive
		{request, From, Ref, _} ->	%I keep on accepting requests from other locks to send them ok afterwards
			held(Nodes, [{From, Ref}|Waiting], MyId);
		release ->	%release message from the worker -> I have to release the lock
			ok(Waiting),	%I inform the waiting locks!
			open(Nodes, MyId)	%back to open state!!
	end.