Erlang (programming language)/Tutorials

Erlang Language Programming Tutorials

Examples

Prime Sieve (parallel with linda type coordination)

-module(primes).

-copyright(' Gnu version 3 (c) 2008 Eric Evers').

% This is a simple linda tuplespace. Here we use it to find primes  numbers.

% This tuple-space can not have duplicate tuples, but with a prime sieve it does

%  not matter.

-compile(export_all).

start() -> start(100).  % defualt value for max is 100

start(Max) -> 

io:format(" Loading ~w numbers into matrix (+N) \n ", [ Max ] ),

Lid = spawn_link( primes, linda, [Max, [], [] ]), Sqrt = round(math:sqrt(Max)+0.5), io:format(" Sqrt(~w) + 1 = ~w \n " , [Max,Sqrt] ),

io:format(" Tuple space is started ~n ",[]),

io:format(" ~w sieves are spawning (+PN) ~n ", [Sqrt] ),

io:format(" Non prime sieves are being halted (-PN) ~n ", [] ),

% load numbers into tuplespace

% and spawn seive process

spawn( primes, put_it, [Max, Max, Lid] ).

sleep(N) ->

receive after N -> time_is_up end.

start_sieves(Lid) ->

Lid ! {self(), get, all, pids},

receive

{lindagram, pids, Pids} -> done

end,

start_sieve_loop(Pids).

start_sieve_loop([]) -> done;

start_sieve_loop([Pid|Pids]) ->

receive

after 100 -> done

end,

Pid ! {start},

start_sieve_loop(Pids).

spawn_sieves( _Max, Sqrt, _Lid, Sqrt ) -> done;  
spawn_sieves( Max, Inc, Lid, Sqrt ) ->

T = 1000, Pid = spawn( primes, sieve, [ Max, Inc+Inc, Inc, Lid, T ]), Name = list_to_atom("P" ++ integer_to_list(Inc)),

Lid ! {put, pid, Name},

register( Name, Pid),

io:format(" +~s ", [atom_to_list(Name)]),

spawn_sieves( Max, Inc+1, Lid, Sqrt ).

put_it(Max, N, Lid) when N =< 1 ->

Sqrt = round(math:sqrt(Max)+0.5), spawn_sieves( Max, 2, Lid, Sqrt );

put_it(Max, N,Lid) when N > 1 ->

receive

after 0 ->

Lid ! {put, N, N}, if N rem 1000 == 0 ->

io:format(" +~w ", [N]); true -> done end,

put_it(Max, N-1,Lid)

end.

% the 2 sieve starts last and has the most to do so it finishes last
sieve(Max, N, 2, Lid, _T) when N > Max -> 

io:format("final sieve ~w done, ~n", [2] ), Lid ! {dump,output};

sieve(Max, N, Inc, _Lid, _T) when N > Max ->    

io:format("sieve ~w done ", [Inc] );

sieve(Max, N, Inc, Lid, T) when N =< Max ->   

receive

after

T -> NT = 0

end, receive {lindagram,Number} when Number =/= undefined -> clearing_the_queue;

{exit} -> exit(normal) after 1 -> done end,

% remove multiple of number from tuple-space

Lid ! {self(), get, N},

Some_time = (N rem 1000)==0,

if Some_time -> io:format("."); true -> done end,

% remove (multiple of Inc) from sieve-process space

Name = list_to_atom("P" ++ integer_to_list(N)),

Exists = lists:member( Name, registered()),

if

Exists ->

Name ! {exit},

io:format(" -~s ", [atom_to_list(Name)] );

true -> done

end,

sieve(Max, N+Inc, Inc, Lid, NT). % next multiple

%% linda is a simple tutple space 

%%    if it receives no messages for 2 whole seconds it dumps its  contents 
%%    as output and halts

linda(Max, Keys, Pids) ->

   receive

{put, pid, Pid} ->

linda(Max, Keys, Pids++[Pid]);

       {put, Name, Value} ->

put( Name, Value),

linda(Max, Keys++[Name], Pids);

{From, get, Name} ->

From ! {lindagram, get( Name)},

erase( Name ),  % get is a desructive read

linda(Max, Keys--[Name],Pids);

{From, get, all, pids} ->

From ! {lindagram, pids, Pids},

linda(Max, Keys, Pids );

{From, get, pid, Pid} ->

L1 = length( Pids ),

L2 = length( Pids -- [Pid]),

if

L1 > L2 ->  % if it exists

From ! {lindagram, pid, Pid};

true ->

From ! {lindagram, pid, undefined}

end,

linda(Max, Keys, Pids ); {dump,output} -> io:format(" ~w final primes remain: ~w ~n ", [length(Keys), lists:sort(Keys) ])

after (100*Max) -> % if there is not tuple action after some time then print the results

io:format(" ~w primes remain: ~w ~n ", [length(Keys), lists:sort(Keys) ])

   end.