Erlang Programming

Slide titleIn CAPITALS

Slide subtitle 32 pt

Erlang Programming

Top right corner for field-mark, customer or partner logotypes. See Best practice for example.

Slide title 40 pt

Text 24 pt

Bullets level 2-520 pt

Ericsson Internal Erlang Programming for ITI 2009-05-172 (209)

Session 4

Concurrent Programming– Processes.– Messages.– Process pattern.– Process aliases.– Timeouts.– Example: Client-Server model

Slide title 40 pt

Text 24 pt

Processes

Concurrent activities are modeled using light-weight processes.

Many processes may be running simultaneously.

The identity of the newly created process is returned from the BIF spawn/3:

Code run by PidA:PidB = spawn(Mod, Func, Args)

PidBPidA

Slide title 40 pt

Text 24 pt

Erlang Example

Creating a new process using spawn

-module(ex3).-export([activity/3]).

activity(Name,Pos,Size) -> …………

Pid = spawn(ex3,activity,[Joe,75,1024]) activity(Joe,75,1024)activity(Joe,75,1024)

Slide title 40 pt

Text 24 pt

Processes

spawn(Module, Function, Args).

Creates a new process, i.e. another thread of execution, starting in the function call given by the arguments.

Example: spawn(m, f, [1,2,3])

creates a process starting in m:f(1,2,3).

Slide title 40 pt

Text 24 pt

Processes

The function used in spawn/3 must be exported.

A process will terminate when there is no more code to execute.

Slide title 40 pt

Text 24 pt

Processes

Messages are sent using “!” (Sometimes called bang).

Pid ! Msg

Msg is any legal Erlang term Pid is of type process identifier (most probably returned

by spawn)

Slide title 40 pt

Text 24 pt

Processes

Processes communicates by sending and receiving messages

PidA PidBhello

PidB ! hello receive

hello ->

Slide title 40 pt

Text 24 pt

Processes

The BIF self/0 returns the process identifier of the process calling it

Try it in the shell.

Slide title 40 pt

Text 24 pt

Example: Area server

-module(area_server0).-export([loop/0]).loop() ->

receive{rectangle, Width, Ht} ->

io:format("Area of rectangle is ~p~n",

[Width * Ht]),loop();

{circle, R} ->io:format("Area of circle is

~p~n" , [3.14159 * R * R]),loop();

Other ->io:format("I don't know what the

area of a ~p is ~n" ,[Other]),loop()

Slide title 40 pt

Text 24 pt

Example: Area server

1> Pid = spawn(fun area_server0:loop/0).<0.36.0>

2> Pid ! {rectangle, 6, 10}.Area of rectangle is 60

{rectangle,6,10}3> Pid ! {circle, 23}.

Area of circle is 1661.90{circle,23}

4> Pid ! {triangle,2,4,5}.I don't know what the area of a {triangle,2,4,5} is{triangle,2,4,5}

Slide title 40 pt

Text 24 pt

Transparent Distribution

Erlang Run-Time SystemErlang Run-Time System Erlang Run-Time SystemErlang Run-Time System

B ! Msg

network

C ! Msg

Slide title 40 pt

Text 24 pt

Process Patternstart() -> spawn(mymod, init, [...]).

init() ->

<initializations>,

loop(...).

loop(...)

receive

stop ->

true; %%The process stops here

Pattern1 ->

<actions>,

loop(...);

PatternN ->

<actions>,

loop(...)

Slide title 40 pt

Text 24 pt

Process example (echo process)A process that receives a message and returns it back to the sender.

-module (echo).-export ([start/0, init/0]).

start() -> spawn(echo, init, []).

init() ->loop().

loop() ->receive

stop ->

true;{Pid, Msg} ->

Pid ! {self(), Msg},loop()

Slide title 40 pt

Text 24 pt

Process example (Testing echo)-module(test_echo).-export([start/1, init/1]).

start(N)-> spawn(test_echo, init, [N]).

init(N)-> Epid = echo:start(), loop(N, Epid).

loop(0, Epid) -> Epid ! stop, io:format("Echo passed this test ~n", []);loop(N, Epid) -> Epid ! {self(), N}, io:format("Sending message, N= ~p~n", [N]), receive

stop -> true;{Epid, N} -> loop(N-1, Epid)

Slide title 40 pt

Text 24 pt

Process example (echo process)-module (echo).-export ([start/0, init/0]).

start() -> spawn(echo, init, []).

init() ->loop().

loop()-> receive

stop -> io:format("I got message ~p from process ~p~n", [stop, unknown]),

true;{Pid, Msg} -> io:format("I got message ~p from process ~p~n", [Msg, Pid]), Pid ! {self(), Msg}, loop()end

Slide title 40 pt

Text 24 pt

Process aliases

To use a name instead of process ID, use the BIF register/2

register(Alias, Pid)

Any process can send a message using the alias.register(iti, Pid),……iti ! hello,

Sending a message to a non-existant alias, fails.

Slide title 40 pt

Text 24 pt

Timeouts

To be able to program a process that does not wait forever for a message to arrive.

receive

hello ->

io:format(“hi”, [])

1000 -> %1000 millisec

Slide title 40 pt

Text 24 pt

Timeouts

test_echo with timeouts (in case the echo process dies).

loop(N, Epid) -> Epid ! {self(), N}, receive

stop ->true;

{Epid, N} -> loop(N-1, Epid) after

1000 ->io:format(“Echo timed out”)

Slide title 40 pt

Text 24 pt

Example: Client-Server model

Message protocol:

{request, ClientPid, alloc} {reply, Resource}

{request, ClientPid, {free, Resource}} {reply, ok}

server

server.erl

hw.erl

Slide title 40 pt

Text 24 pt

Client-Server (cont.)

Server Code

-module(server).-export([start/0]).-export([alloc/0, free/1]).-export([init/0]).

start() -> spawn(server, init, []).

init() ->register(server, self()),Resources = hw:get_resources(),

loop(Resources).

Slide title 40 pt

Text 24 pt

loop(ResDB) ->

receive

{request, From, alloc} ->

{Resources, NewResDB} = hw:alloc(ResDB},

From ! {reply, Resource},

loop(NewResDB};

{requet, From, {free, Resource}}->

From ! {reply, ok},

loop(hw:free(Resource, ResDB));

_Other

loop(ResDB)

Slide title 40 pt

Text 24 pt

Client functions:

alloc() -> call(alloc).

free(Resource)call({free, Resource}).

call(Request) ->server ! {request, self(), Request},receive

{reply, Reply} ->Reply

Slide title 40 pt

Text 24 pt

Lesson 4

Links. Exit signals. Trapping exit signals. Robust systems. Monitors.

Slide title 40 pt

Text 24 pt

Processes can be linked together using the BIF

link(Pid).or spawn_link(Module, Function, Args).

Links are removed using:unlink(Pid).

PidA PidB

Slide title 40 pt

Text 24 pt

Exit Signals

When a process terminates, exit signals are sent over all links connected to the terminating process

PidA PidBEXIT

Slide title 40 pt

Text 24 pt

Exit Signals

A process can terminate:

– normally: (when it has no more code to execute).

– abnormally: due to run-time error.

– abnormally: due to execution of BIF causing termination exit(Reason).

Note: a signal is not a message.

Slide title 40 pt

Text 24 pt

Exit signals

When a process terminates normally (no more code to execute), the emitted exit-signals are ignored by the linked processes.

When the process terminates abnormally, linked process will notice the emitted exit signals…

… and terminate themselves

Slide title 40 pt

Text 24 pt

Exit Signals

When a process terminates, an exit signal is sent to all linked processes

… and the termination is propagated

Slide title 40 pt

Text 24 pt

Exit Signals

The BIF exit/2 emits an exit-signal to a process even if there is no link between them.

exit(DestPid, Reason).

PidA doesn’t terminate, it just terminates PidB

PidA PidBEXIT

Slide title 40 pt

Text 24 pt

Trapping exit signals

To protect itself from exit signals, a process uses the BIF:

process_flag(trap_exit, true).

Then, incoming exit signals will be transformed to a message and put in the message que in the format:

{‘EXIT’, Pid, Reasons}

Slide title 40 pt

Text 24 pt

Trapping exit causes any exit signal to be transformed into a message even signals occuring due to normal termination of linked processes.

When a process PidA is linked to PidB, PidB is trapping exit and PidA terminates normally (no more code to execute), PidB receives the following message:

{‘EXIT’, Pid, Reasons}

Remember what happens in the above case when PidB is not trapping exit?

– PidB just receives the exit signal but ignores it.

Slide title 40 pt

Text 24 pt

Processes that traps exit can also be killed by sending them an exit signal with reason kill

The process terminates with the reason killed

Slide title 40 pt

Text 24 pt

Summary of trapping exits

Process Flag Reason: normal Abnormal reasons

Reason: kill Reason: Other

Not trapping exit

Trapping exit

Slide title 40 pt

Text 24 pt

Not trapping exit

Ignores signal

Trapping exit

Slide title 40 pt

Text 24 pt

Not trapping exit

Ignores signal Terminates

Reason = kill

Trapping exit

Slide title 40 pt

Text 24 pt

Not trapping exit

Reason = kill

Terminates

Reason = Other

Trapping exit

Slide title 40 pt

Text 24 pt

Not trapping exit

Reason = kill

Terminates

Reason = Other

Trapping exit Receives:

{‘EXIT’, Pid, normal}

Slide title 40 pt

Text 24 pt

Not trapping exit

Reason = kill

Terminates

Reason = Other

Terminates

Reason = killed

Slide title 40 pt

Text 24 pt

Not trapping exit

Reason = kill

Terminates

Reason = Other

Terminates

Reason = killed

Receives:

{‘EXIT’, Pid, Other}

Slide title 40 pt

Text 24 pt

Client-Server (robust)

Server Code

-module(server).-export([start/0]).-export([alloc/0, free/1]).-export([init/0]).

start() -> spawn(server, init, []).

init() ->process_flag(trap_exit, true),register(server, self()),Resources = hw:get_resources(),

loop(Resources).

Slide title 40 pt

Text 24 pt

loop(ResDB) -> receive {request, From, alloc} ->

{Resources, NewResDB} = hw:alloc(ResDB}, link(From), From ! {reply, Resource}, loop(NewResDB};

{requet, From, {free, Resource}}-> unlink(From),

From ! {reply, ok}, loop(hw:free(Resource, ResDB));

{‘EXIT’, From, _Reason}-><do something>loop(NewResDB);

_Other ->loop(ResDB)

Slide title 40 pt

Text 24 pt

Monitors

The BIF erlang:monitor/2 offers a way to monitor another process.

The monitor is not bi-directional like links.MRef = erlang:monitor(process, Process).Process = pid() | atom() documentation style

If the process terminates the calling process will receive a

{‘DOWN’, MRef, process, Object, Reason}

Slide title 40 pt

Text 24 pt

Exercises

Write a process that upon receiving a certain message terminates normally and when receiving another message terminates ubnormaly.

loop() -> receive

stop -> io:format("Process stopped~n");error -> io:format("Process will terminate ubnormally~n"), abc = abcd;Msg -> io:format("Message ~p received ~n", [Msg]), loop()

Slide title 40 pt

Text 24 pt

Exercises

Write a function that starts another process– pmon:start(SupervisedPID).

The process shall use a link to monitor the supervised process.

The monitoring process shall print a message if the supervised process terminates abnormally.

The monitoring process should terminate whenever the supervised process does, regardless of the reason.

Slide title 40 pt

Text 24 pt

Solution

-module(pmon).-export([start/1, init/1]).

start(Pid)-> spawn(pmon, init, [Pid]).

init(Pid)-> process_flag(trap_exit, true), link(Pid), loop(Pid).

loop(Pid)-> receive

{'EXIT', Pid, normal}-> ok;{'EXIT', Pid, Reason} -> io:format("Process ~p terminated abnormally, reason: ~p~n", [Pid, Reason]);_Other -> loop(Pid)

Slide title 40 pt

Text 24 pt

Master and Slaves

Write a module ms that has the following interfaces:– start(N): starts a master process and tells it to start N slave

processes. Register the master as master.

– to_slave(Message, N): Sends a message to the master and tell it to relay the message to slave N.

– The slave should exit if it receives the message die.

– The master should restart the dead slave and restarts it.

Slide title 40 pt

Text 24 pt

Master and slaves

ms:start(4). true ms:to_slave(hello, 2). {hello, 2} Slave 2 got message hello.

ms:to_slave(die, 3). {die, 3} master restarting dead slave 3.

Slide title 40 pt

Text 24 pt

Solution

-module(ms).-export([start/1, to_slave/2]).-export([master_init/1, slave_init/1]).

start(N)-> spawn(ms, master_init, [N]).

to_slave(Msg, N)-> master ! {to_slave, self(), Msg, N}.

master_init(N)-> register(master, self()), process_flag(trap_exit, true), Slaves = start_slaves(N, []), master_loop(Slaves).

Slide title 40 pt

Text 24 pt

Solution

start_slaves(0, Slaves)->

Slaves;

start_slaves(N, Slaves) ->

start_slaves(N-1, [spawn_link(ms, slave_init, [N])|Slaves]).

Slide title 40 pt

Text 24 pt

Solution

master_loop(Slaves)->

receive

{to_slave, _Pid, Msg, N}->

lists:nth(N, Slaves) ! Msg,

master_loop(Slaves);

{'EXIT', Pid, _Reason} ->

master_loop(replace(Pid, Slaves, 1));

_Other ->

master_loop(Slaves)

Slide title 40 pt

Text 24 pt

Solution

slave_init(N)->

slave_loop(N).

slave_loop(N)->

receive

die ->

Msg ->

io:format("Slave ~p got message ~p~n", [N, Msg]),

slave_loop(N)

Slide title 40 pt

Text 24 pt

Solution

replace(Pid, [Pid|Rest], N)->

io:format("master restarting dead slave ~p~n", [N]),

[spawn_link(ms, slave_init, [N]) | Rest];

replace(Pid, [OtherPid|Rest], N) ->

[OtherPid | replace(Pid, Rest, N+1)].

Slide title 40 pt

Text 24 pt

Summary

Links. Exit signals. Trapping exit signals. Robust systems. Monitors.

Erlang Programming

Documents

Simple Network Management Protocol - Erlang Programming Language

Secure Socket Layer - Erlang Programming Language

The Erlang Programming Language

EventTracer(ET) - erlang.org · Guide: familiarity with the Erlang system and Erlang programming in general and the especially the art of Erlang tracing. The application requires

Concurrency Oriented Programming in Erlang - RabbitMQ · PDF fileConcurrency Oriented Programming in Erlang Joe Armstrong Distributed Systems Laboratory Swedish Institute of Computer

Erlang: Practical Functional Programming · Programming Functional Thursday, Taipei December 11, 2014 Jake Morrison Philosophy of Erlang Erlang was designed

Getting Started - Erlang Programming Language

Erlang C++ Ruby C - JUGS€¦ · Erlang Fortran C Programming Languages are not enough. high-level C# C++ Java Python Ruby Groovy Erlang Fortran C Programming Languages are not enough

Programming Erlang, Second Edition

Erlang - functional programming in a concurrent world · PDF file2 Erlang • Concurrent Oriented Programming –processes have state –communicate using message passing –access

Erlang Programming for Multi-corepls/damp09/damp09-wiger-keynote.pdf · Ulf Wiger, Ericsson AB 2009-01-16 ProTest -Property-Based Testing 1 Erlang Programming for Multi-core Ulf Wiger

Erlang Programming Language

DRAKON-Erlang: Visual Functional Programming · DRAKON-Erlang: Visual Functional Programming By Stepan Mitkin Abstract Functional programming is based on useful and practical ideas

Meta programming for Erlang

National Technical University of Athens2.1 Erlang and Erlang/OTP Erlang is a strict, dynamically typed functional programming language with support for concurrency, communication,

Multicore Programming in Erlang

Teaching Functional Programming and Erlang: The Galician ...erlang.se/euc/05/1400Victor.pdf · eachingT Functional Programming and Erlang: The Galician Experience Victor M. Gulias

Practical Erlang Programming Process Error Handling

Erlang: the unintentional neural network programming language

Erlang Programming Rules