Actor model Devoxx Ukraine 2018 version

1. Actor, an elegant model for concurrent and
distributed computation
1
Alessio Coltellacci
Twitter: @lightplay8 Github: @NotBad4U
Mail: alessio.coltellacci@clever-cloud.com

2. Didier Plaindoux
Developer | @DevFestToulouse team member
twitter: @dplaindoux github: @d-plaindoux
2
Credits to

3. Actor, an elegant model for concurrent computation
3
Concurrency refers to the ability of different parts or units
of a program to be executed out-of-order or in partial
order, without affecting the final outcome
TL;DR: dealing a lots of things at once

4. Mutex, semaphore, spinlock, ...
4

5. n! unit tests
5

6. Process Calculus
6
● CSP described by Tony Hoare in 1978
● π-calculus developed by R. Milner, J. Parrow and D. Walker in 1992

7. Communicating Sequential Processes (CSP)
7
PRODUCER ==
nb : integer := 0;
*[
nb < 100 -> consumer ! nb; nb :=
nb + 1
]

8. Communicating Sequential Processes (CSP)
PRODUCER ==
nb : integer := 0;
*[
nb < 100 -> consumer ! nb; nb
:= nb + 1
]
8

9. Communicating Sequential Processes (CSP)
CONSUMER ==
nb : integer;
*[
true -> producer ? nb; print (nb)
]
9
PRODUCER ==
nb : integer := 0;
*[
nb < 100 -> consumer ! nb; nb :=
nb + 1
]

10. Communicating Sequential Processes (CSP)
CONSUMER ==
nb : integer;
*[
true -> producer ? nb; print (nb)
]
10
PRODUCER ==
nb : integer := 0;
*[
nb < 100 -> consumer ! nb; nb :=
nb + 1
]

11. Communicating Sequential Processes (CSP)
CONSUMER ==
nb : integer;
*[
true -> producer ? nb; print (nb)
]
11
PRODUCER ==
nb : integer := 0;
*[
nb < 100 -> consume ! nb; nb := nb + 1
]
MAIN ==
[
producer :: PRODUCER
||
delegate :: DELEGATE
]

12. 12
Distributed system is a system whose components are located on different
networked computers, which coordinate their actions by passing messages to
one another
TL;DR: multiple software components that are on multiple
computers
Actor, an elegant model for distributed computation

13. π-Calculus
13

14. Actor
14

15. Actor,
encapsulate common resources and
act as service or resource providers
15

16. Actor Anatomy
Actor
16

17. Actor Anatomy
Actor
State
Behavior
17
Interface

18. Actor Anatomy
Actor
State
Mailbox
Behavior
18
Interface

19. Actor Anatomy
Actor
State
Mailbox
Behavior
Address
19
Interface

20. Actor Anatomy
Actor
State
Mailbox
Behavior
Address
ref
20
Interface

21. Actor Physiology
State
MailboxAddress
Behavior
Actor
21
Interface

22. Actor Physiology
State
MailboxAddress
Behavior
Actor
22
Interface

23. Actor Physiology
State
MailboxAddress
Behavior
Actor
23
Interface

24. Actor Physiology
State
MailboxAddress
Behavior
Actor
24
Interface

25. Actor Axiomes
1. Create actors to replace failed actors or to increase the processing
2. Send messages to actors it knows i.e. Acquaintances
3. Behaviour: designate what to do with the next message
25

26. Actor Axiomes illustrated
26
1. class Energy(value: Int)(region: ActorRef) extends Actor {
2.
3. def receive: Receive = {
4. case TryConsume =>
5. sender ! Consumed(value)
6. region ! Destroy(self)
7. context become consumed
8. }
9.
10. def consumed: Receive = {
11. case _ =>
12. ()
13. }
14. }

27. Actor Axiomes illustrated
27
1. class Energy(value: Int)(region: ActorRef) extends Actor {
2.
3. def receive: Receive = {
4. case TryConsume =>
5. sender ! Consumed(value)
6. region ! Destroy(self)
7. context become consumed
8. }
9.
10. def consumed: Receive = {
11. case _ =>
12. ()
13. }
14. }

28. Actor Axiomes illustrated
28
1. class Energy(value: Int)(region: ActorRef) extends Actor {
2.
3. def receive: Receive = {
4. case TryConsume =>
5. sender ! Consumed(value)
6. region ! Destroy(self)
7. context become consumed
8. }
9.
10. def consumed: Receive = {
11. case _ =>
12. ()
13. }
14. }

29. Actor Axiomes illustrated
29
1. class Energy(value: Int)(region: ActorRef) extends Actor {
2.
3. def receive: Receive = {
4. case TryConsume =>
5. sender ! Consumed(value)
6. region ! Destroy(self)
7. context become consumed
8. }
9.
10. def consumed: Receive = {
11. case _ =>
12. ()
13. }
14. }

30. Actor Axiomes illustrated
30
1. class Energy(value: Int)(region: ActorRef) extends Actor {
2.
3. def receive: Receive = {
4. case TryConsume =>
5. sender ! Consumed(value)
6. region ! Destroy(self)
7. context become consumed
8. }
9.
10. def consumed: Receive = {
11. case _ =>
12. ()
13. }
14. }

31. Properties of Communication
The only way for an Actor to affect another
is through explicit messaging.
This allow to avoid concurrency problem.
31

32. Do not communicate by sharing memory;
instead, share memory by communicating.
32

33. Properties of Communication
Actor 1 Actor 2
mailbox mailbox
33

34. Properties of Communication
● Zero-copy message
● Immutable message
● Acquaintance
● Not deterministic
34

35. Address
/events/storage
Actor 1 Actor 2 /procedures
Actor 2
35

36. Address
/events/storage
Actor 1 Actor 2 /procedures
Actor 2
M x N relations
36

37. Message
● Past
● Now
● Future | Promise
● Performative
● Ontology
● Delivered at most one (no duplication)
37

38. Message processing
● Paradigm
● Continuous
● Consecutive vs Interleaved
● Dead Letters
38

39. The isolated Turn (epoch) principle
● Macro-step semantics
● An actor processing a message from its Inbox
● Single isolated step
● Model is free of low-level data race & deadlocks
39

40. Actors come in system
40

41. Demo
41

42. 42

43. Can I use ?
Synchronisation: superviser actor
Actor
consumer
Actor
consumer
Actor
consumer
Actor
superviser
Actor supply
clerk
Can I use ?
Actor don’t compete for resources they use a superviser
43

44. You usually have
to wait for that
which is worth
waiting for.
Synchronisation: superviser actor
Actor
consumer
Actor
consumer
Actor
consumer
Actor
superviser
Actor supply
clerk
yes
44

45. Synchronisation: superviser actor
Actor
consumer
Actor
consumer
Actor
consumer
Actor
superviser
Actor supply
clerk
Release lock
Your turn
45

46. Domain
1 let bst = domain {
2 insert(key, value) {
3 ...
4 }
5 query(key) {
6 ...
7 }
8 }
9
10 let plugin1 = actor {
11 insert(bst, key, value) {
12 whenExclusive(bst) {
13 bst.insert(key, value);
14 }
15 }
16 }
17
18
19 let plugin2 = actor {
20 queryInsert(bst, key) {
21 whenExclusive(bst) {
22 value := bst.query(key);
23 if(value > 0) {
24 bst.insert(key, value - 1)
25 }
26 }
27 }
28 }
46

47. Domain
1 let bst = domain {
2 insert(key, value) {
3 ...
4 }
5 query(key) {
6 ...
7 }
8 }
9
10 let plugin1 = actor {
11 insert(bst, key, value) {
12 whenExclusive(bst) {
13 bst.insert(key, value);
14 }
15 }
16 }
17
18
19 let plugin2 = actor {
20 queryInsert(bst, key) {
21 whenExclusive(bst) {
22 value := bst.query(key);
23 if(value > 0) {
24 bst.insert(key, value - 1)
25 }
26 }
27 }
28 }
47

48. Domain
1 let bst = domain {
2 insert(key, value) {
3 ...
4 }
5 query(key) {
6 ...
7 }
8 }
9
10 let plugin1 = actor {
11 insert(bst, key, value) {
12 whenExclusive(bst) {
13 bst.insert(key, value);
14 }
15 }
16 }
17
18
19 let plugin2 = actor {
20 queryInsert(bst, key) {
21 whenExclusive(bst) {
22 value := bst.query(key);
23 if(value > 0) {
24 bst.insert(key, value - 1)
25 }
26 }
27 }
28 }
48

49. Players must be able to interact and move across region map boundaries
49

50. Pattern: Map-Centric Game Server
50
Region 1 Region 2

51. Players must be able to interact and move across region map boundaries
51

52. Players must be able to interact across region map boundaries with other entities
52

53. ...And move across region map boundaries
53
Move in region 1

54. ● Global existence
● Automatic instanciation
Location Transparency
54

55. Demo
55

56. Persistence
● Event sourcing
● Akka persistence
● Serialization
● Eventual consistency
● Messaging Guarantees
56

57. Recovery
The “let it crash” Philosophy
57

58. Handling external input | output
58

59. Handling Failure
59
“An actor never fails:
If a server S crashes, the next
message sent to an actor A that was
running on S causes Orleans to
automatically reinstantiate A on
another server.”
TL;DR: If the recipient doesn’t exist…
create it so thing will never fails

60. Akka Hierarchy and Supervision
● Supervision
● Strategy (Resume, Restart, Stop or Escalate)
60

61. Microservice based on Actors
61

62. Testing & Debugging
Actoverse, debugging a program of the two-phase commit protocol
62

63. Blue Green
Actors can be improved or re-factored
without affecting or stopping the rest of the application
63

64. Actor Use-Cases
64
● Multithreaded program for concurrent computation
● Distributed system
● System that can need mobility and discovery
● Based on events or commands (event s

65. Anti Use-Cases
65
“Shared-state concurrency is nevertheless a fundamental programming style,
needed for systems code, for maximal performance, and for implementing other
styles of concurrency.”
Aaron Turon
TL;DR: If you need true execution time performance, don’t use the
actor model

66. Concurrent, distributed and mobile computation
● Join-Calculus: Formalism for distributed computations design
● Brane-Calculus: …
● Ambient-Calculus: Formalism for distributed and mobile computations
design
66

67. Ambient Calculus
67

68. Ambient Calculus
68

69. Ambient Calculus
69
n [ in m.P ] | m [ R ] -> m [ n [ in m.P ] | R ]
in m.P R Rin
m.P
ambient n ambient m m
n

70. AmbientTalk
70
Producer
1. deftype EchoService;
2.
3. def echoF := when: EchoService discovered: { |echoSvc|
4. system.println("Discovered an echo service");
5. echoSvc;
6. } within: 2.minutes;
7.
8. network.online();
9.
10. echoF<-echo("test1");
11.
12. def resultF := echoF<-echo("test2")@TwoWay;
13. when: resultF becomes: { |value|
14. system.println("Reply: " + value);
15. };
Consumer
1. def service := object: {
2. def echo(text) {
3. system.println("Received: "+text);
4. text
5. }
6. };
7.
8. deftype EchoService;
9.
10. def pub := export: service as: EchoService;
11. network.online();

71. AmbientTalk
71
Producer
1. deftype EchoService;
2.
3. def echoF := when: EchoService discovered: { |echoSvc|
4. system.println("Discovered an echo service");
5. echoSvc;
6. } within: 2.minutes;
7.
8. network.online();
9.
10. echoF<-echo("test1");
11.
12. def resultF := echoF<-echo("test2")@TwoWay;
13. when: resultF becomes: { |value|
14. system.println("Reply: " + value);
15. };
Consumer
1. def service := object: {
2. def echo(text) {
3. system.println("Received: "+text);
4. text
5. }
6. };
7.
8. deftype EchoService;
9.
10. def pub := export: service as: EchoService;
11. network.online();

72. AmbientTalk
72
Producer
1. deftype EchoService;
2.
3. def echoF := when: EchoService discovered: { |echoSvc|
4. system.println("Discovered an echo service");
5. echoSvc;
6. } within: 2.minutes;
7.
8. network.online();
9.
10. echoF<-echo("test1");
11.
12. def resultF := echoF<-echo("test2")@TwoWay;
13. when: resultF becomes: { |value|
14. system.println("Reply: " + value);
15. };
Consumer
1. def service := object: {
2. def echo(text) {
3. system.println("Received: "+text);
4. text
5. }
6. };
7.
8. deftype EchoService;
9.
10. def pub := export: service as: EchoService;
11. network.online();

73. AmbientTalk
73
Producer
1. deftype EchoService;
2.
3. def echoF := when: EchoService discovered: { |echoSvc|
4. system.println("Discovered an echo service");
5. echoSvc;
6. } within: 2.minutes;
7.
8. network.online();
9.
10. echoF<-echo("test1");
11.
12. def resultF := echoF<-echo("test2")@TwoWay;
13. when: resultF becomes: { |value|
14. system.println("Reply: " + value);
15. };
Consumer
1. def service := object: {
2. def echo(text) {
3. system.println("Received: "+text);
4. text
5. }
6. };
7.
8. deftype EchoService;
9.
10. def pub := export: service as: EchoService;
11. network.online();

74. AmbientTalk
74
Producer
1. deftype EchoService;
2.
3. def echoF := when: EchoService discovered: { |echoSvc|
4. system.println("Discovered an echo service");
5. echoSvc;
6. } within: 2.minutes;
7.
8. network.online();
9.
10. echoF<-echo("test1");
11.
12. def resultF := echoF<-echo("test2")@TwoWay;
13. when: resultF becomes: { |value|
14. system.println("Reply: " + value);
15. };
Consumer
1. def service := object: {
2. def echo(text) {
3. system.println("Received: "+text);
4. text
5. }
6. };
7.
8. deftype EchoService;
9.
10. def pub := export: service as: EchoService;
11. network.online();

75. 75
https://docs.google.com/presentation/d/1756ZfeqY00h-lnKsDl
6tRBiJyGZscOGbvdoqZ5R0Cv0/edit?usp=sharing
Twitter: @lightplay8 Github: @NotBad4U
Mail: alessio.coltellacci@clever-cloud.com
Demo: https://github.com/agtors