An introduction to Erlang and the actor model of concurrency. Author: Alex Miller Blog: http://tech.puredanger.com Twitter: @puredanger

1. Actor Concurrency
Alex Miller
Blog: http://tech.puredanger.com Twitter: @puredanger

4. 8086

7. Moore’s Law?
http://en.wikipedia.org/wiki/CPU_speed http://en.wikipedia.org/wiki/Transistor_count

8. Moore’s Law?
http://en.wikipedia.org/wiki/CPU_speed http://en.wikipedia.org/wiki/Transistor_count

9. Moore’s Law?
http://en.wikipedia.org/wiki/CPU_speed http://en.wikipedia.org/wiki/Transistor_count

10. State of the Practice
public class Counter {
private int count = 0;
public int increment() {
synchronized(this) {
return ++count;
}
}
}

12. JCIP says:
• It’s the mutable state, stupid.
• Make fields final unless they need to be mutable.
• Immutable objects are automatically thread-safe.
• Encapsulation makes it practical to manage the complexity.
• Guard each mutable variable with a lock.
• Guard all variables in an invariant with the same lock.
• Hold locks for the duration of compound actions.
• A program that accesses a mutable variable from multiple threads
without synchronization is a broken program.
• Don’t rely on clever reasoning about why you don’t need to
synchronize.
• Include thread safety in the design process - or explicitly document
that your class is not thread-safe.
• Document your synchronization policy.

13. JCIP says:
• It’s the mutable state, stupid.
• Make fields final unless they need to be mutable.
• Immutable objects are automatically thread-safe.
• Encapsulation makes it practical to manage the complexity.
• Guard each mutable variable with a lock.
• Guard all variables in an invariant with the same lock.
• Hold locks for the duration of compound actions.
• A program that accesses a mutable variable from multiple threads
without synchronization is a broken program.
• Don’t rely on clever reasoning about why you don’t need to
synchronize.
• Include thread safety in the design process - or explicitly document
that your class is not thread-safe.
• Document your synchronization policy.

14. The problem with shared state concurrency

15. The problem with shared state concurrency
...is the shared state.

16. Actors
• No shared state
• Lightweight processes
• Asynchronous message-passing
• Buffer messages in a mailbox
• Receive messages with pattern matching

17. The Basics

18. The Basics
spawn

19. The Basics
send
spawn

20. The Basics
receive

21. Erlang
• Invented at Ericsson
• Functional language
• Dynamic typing
• Designed for concurrency, fault-tolerance

22. Single assignment
Eshell V5.6.3 (abort with ^G)
1> A = 4.
4
2> A.
4
3> A = 6.
** exception error: no match of right hand
side value 6
4> A = 2*2.
4

23. Atoms and Tuples
1> F=foo.
foo
2> Stooges = {larry,curly,moe}.
{larry,curly,moe}
3> Me = {person,quot;Alexquot;,quot;nachosquot;}.
{person,quot;Alexquot;,quot;nachosquot;}
4> {person,Name,Food} = Me.
{person,quot;Alexquot;,quot;nachosquot;}
5> Name.
quot;Alexquot;
6> Food.
quot;nachosquot;

24. Lists
1> List=[1,2,3].
[1,2,3]
2> [First|Rest]=List.
[1,2,3]
3> First.
1
4> Rest.
[2,3]
5> List2=[4|List].
[4,1,2,3]
6> [Char|String] = “abc”.
“abc”
7> Char.
97

25. Functions
1> Square = fun(X) -> X*X end.
#Fun<erl_eval.6.13229925>
2> Square(5).
25.
3> TimesN = fun(N) -> (fun(X) -> N*X end)
3> end.
#Fun<erl_eval.6.13229925>
4> lists:map(TimesN(10), [1,2,3]).
[10,20,30]

26. Modules
-module(mymath).
-export([square/1,fib/1]).
square(Value) -> Value*Value.
fib(0) -> 0;
fib(1) -> 1;
fib(N) when N>0 -> fib(N-1) + fib(N-2).
1> c(mymath.erl).
2> mymath:square(5).
25
3> mymath:fib(7).
13

27. Modules and Functions
-module(mymath2).
-export([fibtr/1]).
fibtr(N) -> fibtr_iter(N, 0, 1).
fibtr_iter(0, Result, _Next) -> Result;
fibtr_iter(Iter, Result, Next)
when Iter > 0 ->
fibtr_iter(Iter-1, Next, Result+Next).
1> c(mymath2.erl).
2> mymath2:fibtr(200).
280571172992510140037611932413038677189525

28. Concurrency Primitives
• Pid = spawn(fun)
• Pid ! message
• receive...end

29. Concurrency Primitives
• Pid = spawn(fun)
• Pid ! message
• receive...end Pid

30. Concurrency Primitives
• Pid = spawn(fun)
• Pid ! message
• receive...end Pid

31. Concurrency Primitives
• Pid = spawn(fun)
• Pid ! message
• receive...end Pid

32. Concurrency Primitives
• Pid = spawn(fun)
• Pid ! message
• receive...end
receive
Pid ...
end

33. A Simple Process
loop() ->
receive
{toF, C} ->
io:format(quot;~p C is ~p F~nquot;,
[C, 32+C*9/5]),
loop();
{toC, F} ->
io:format(quot;~p F is ~p C~nquot;,
[F, (F-32)*5/9]),
loop();
{stop} ->
io:format(quot;Stopping~nquot;);
Other ->
io:format(quot;Unknown: ~p~nquot;, [Other]),
loop()
end.

34. Spawn!
1> c(temperature).
{ok,temperature}
2> Pid = spawn(fun temperature:loop/0).
<0.128.0>
3> Pid ! {toC, 32}.
32F is 0.0 C
{convertToC,32}
4> Pid ! {toF, 100}.
100C is 212.0 F
{convertToF,100}
5> Pid ! {stop}.
Stopping
{stop}

35. Responding
-module(temp2).
-export([start/0,convert/2]).
start() ->
spawn(fun() -> loop() end).
convert(Pid, Request) ->
Pid ! {self(), Request},
receive
{Pid, Response} -> Response
end.

36. Responding
loop() ->
receive
{From, {toF, C}} ->
From ! {self(), 32+C*9/5},
loop();
{From, {toC, F}} ->
From ! {self(), (F-32)*5/9},
loop();
{From, stop} ->
From ! {self(), stop},
io:format(quot;Stopping~nquot;);
{From, Other} ->
From ! {self(), {error, Other}},
loop()
end.

37. Responding
1> c(temp2).
{ok,temp2}
2> Pid = temp2:start().
<0.57.0>
3> temp2:convert(Pid2, {toF, 100}).
212.0

38. Process Ring

39. Running Rings
1> c(ring).
2> T=ring:startTimer().
3> R=ring:startRing(100,T).
spawned 100 in 241 microseconds
4> R ! start.
{1230,863064,116530} Starting message
{1230,863064,879862} Around ring 10000 times
{1230,863065,642097} Around ring 20000 times
...etc
{1230,863140,707023} Around ring 990000 times
{1230,863141,471193} Around ring 1000000 times
Start={1230,863064,116875}
Stop={1230,863141,471380} Elapsed=77354505
5> R20k = ring:startRing(20000,T).
spawned: 20000 in 118580 microseconds

40. Processes and
Messages
• Processes cheap to create (10ks < second)
• Create many processes (10ks to 100ks)
• Messages very fast to send (1M / second)

41. Error Handling

42. Error Handling
link

43. Error Handling
link

44. Error Handling
exit signal

45. Linked Processes
reportExit(WatchedPid) ->
spawn(fun() ->
process_flag(trap_exit, true),
link(WatchedPid),
receive
{'EXIT', _Pid, Msg} ->
io:format(quot;got linked exit: ~p~nquot;, [Msg])
end
end).
startWatched() ->
spawn(fun() ->
receive
die -> exit(quot;diequot;);
crash -> erlang:error(quot;crashquot;)
end
end).

46. Linked Processes
1> c(link).
2> P1 = link:startWatched().
3> P2 = link:startWatched().
4> link:reportExit(P1).
5> link:reportExit(P2).
6> P1 ! die.
got linked exit: quot;diequot;
7> P2 ! crash.
got linked exit: {quot;crashquot;,[{link,'-
startWatched/0-fun-0-',0}]}

47. Does it work?

48. Ericsson AXD301
• Telecom ATM switch
• Millions of calls / week
• 99.9999999% uptime =
32 ms down / year
• -> Nortel Alteon SSL
Accelerator

49. YAWS
http://www.sics.se/~joe/apachevsyaws.html

50. Messaging

51. Facebook Chat
“For Facebook Chat, we rolled our own subsystem
for logging chat messages (in C++) as well as an epoll-
driven web server (in Erlang) that holds online users'
conversations in-memory and serves the long-polled
HTTP requests. Both subsystems are clustered and
partitioned for reliability and efficient failover. ”
Reference: http://www.facebook.com/note.php?note_id=14218138919

52. And others...

53. • JVM-based language
• Object-functional hybrid
• Actor library

54. Scala Rings
def act() {
loop {
react {
case StartMessage => {
log(quot;Starting messagesquot;)
timer ! StartMessage
nextNode ! TokenMessage(nodeId, 0)
}
case StopMessage => {
log(quot;Stoppingquot;)
nextNode ! StopMessage
exit
}

55. Scala Rings
case TokenMessage(id,value) if id == nodeId => {
val nextValue = value+1
if(nextValue % 10000 == 0)
log(quot;Around ring quot; + nextValue + quot; timesquot;)
if(nextValue == 1000000) {
timer ! StopMessage
timer ! CancelMessage
nextNode ! StopMessage
exit
} else {
nextNode ! TokenMessage(id, nextValue)
}
}
case TokenMessage(id,value) => {
nextNode ! TokenMessage(id,value)
}
}

56. Comparison to Erlang
• receive-based actors cheap to create
(Erlang about 3x faster)
• Can also create many processes
• Messages also fast to send (Erlang about 2x
faster)

57. • Java-based framework with compile-time weaving
• Tasks - lightweight threads/processes/etc
• @pausable - let task be paused during execution
• sleep / yield
• Mailbox (typed via generics) - single consumer
• Messaging - mutable (in limited ways)

58. Kilim Ring
import kilim.Mailbox;
import kilim.Task;
import kilim.pausable;
public class NodeActor extends Task {
private final int nodeId;
private final Mailbox<Message> inbox;
private final Mailbox<Message> timerInbox;
private Mailbox<Message> nextInbox;
public NodeActor(int nodeId,
Mailbox<Message> inbox,
Mailbox<Message> timerInbox) {
this.nodeId = nodeId;
this.inbox = inbox;
this.timerInbox = timerInbox;
}

59. Kilim Ring
@pausable
public void execute() throws Exception {
while(true) {
Message message = inbox.get();
if(message.equals(Message.START)) {
timerInbox.putnb(Message.START);
nextInbox.putnb(new TokenMessage(nodeId, 0));
} else if(message.equals(Message.STOP)) {
nextInbox.putnb(Message.STOP);
break;
...

60. Kilim Ring
} else if(message instanceof TokenMessage) {
TokenMessage token = (TokenMessage)message;
if(token.source == nodeId) {
int nextVal = token.value+1;
if(nextVal == 1000000) {
timerInbox.putnb(Message.STOP);
timerInbox.putnb(Message.CANCEL);
nextInbox.putnb(Message.STOP);
break;
} else {
token.value = nextVal;
nextInbox.putnb(token);
}
} else {
nextInbox.putnb(token);
}
}
}

61. Performance
10.0 400
7.5 300
milliseconds
milliseconds
5.0 200
2.5 100
0 0
100 nodes 20k nodes
130,000
Erlang
97,500
milliseconds
Scala
Kilim 65,000
32,500
0
100M messages

63. http://tech.puredanger.com/presentations/actor-concurrency