C++ Actor Model - You’ve Got Mail ...

www.italiancpp.org
C++ Actor Model
You’ve Got Mail ...

Italian C++ Community
Why are we here?

std::thread/async, isn’t it enough?

std::thread/async, isn’t it enough?
Example code: double_poll
Poll Left Poll Right
Thread 1 Thread 2
Acc
Increment
Add Add

Concurrency model
- Single Thread → Node.js
- Actor Model → Erlang
- CSP → GO
- STM → Clojure
- etc ...

Node.js
It’s simple
One thread
Asynchronous I/O (event-loop)

Node.js - Examples
var fs = require("fs");
fs.readFile('/etc/passwd', function (err, data) {
if (err) throw err;
console.log("-> " + data + " <-");
});
----
var http = require('http');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Hello Worldn');
}).listen(1337, "127.0.0.1");
console.log('Server running at http://127.0.0.1:1337/');

Node.js - Is it fast?
ab -n 10000 -c 1000 http://127.0.0.1:1337/
Time taken for tests: 1.283 seconds
Complete requests: 10000
Total transferred: 1130000 bytes
Requests per second: 7797.21 [#/sec] (mean)
Time per request: 128.251 [ms] (mean)
Time per request: 0.128 [ms] (mean, across all concurrent requests)
Transfer rate: 860.43 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 58 232.7 0 1000
Processing: 5 20 27.1 13 420
Waiting: 5 20 27.1 13 420
Total: 13 78 246.5 13 1234

Node.js - Is it fast?
YES!!!

Concurrency model
Single Thread → Node.js (Good)
Can we do better?
Copy from others ...

Erlang
Erlang is a programming language used to build massively
scalable soft real-time systems with requirements on high
availability.

Actor Model

A model of concurrent computation
that treats "actors" as the primitives
and fundamental units of computation.
Actor Model

Actor Model
It should embody three properties:
● Processing → Can do something
● Storage → Can remember something
● Communication → Can communicate with
others

Actor Model
In an actors system:
● Everything is an actor
● An actor is an entity that sends, receives
messages
● An actor is an entity with a behaviour

In response to a message that it receives, an
actor can:
● create more actors
● send messages to other actors
● determine how to respond to the next
message received
Actor Model

Actor Model
A1
A3
M1
A21
A22
A23
M2
M3
A2

Actor Model
Does it work?
Is it fast?

Erlang - Results
ab -n 10000 -c 1000 http://127.0.0.1:8080/
Connect: 0 10 4.8 10 27
Processing: 7 16 4.8 16 39
Waiting: 5 13 4.2 13 34
Total: 8 26 8.3 26 59

Erlang vs Node.js - Results
Node.js
Requests per second: 6843.55 [#/sec]
Time per request: 146.123 [ms]
Transfer rate: 761.88 [Kbytes/sec]
Connect: 0 59 234.5 0 1001
Processing: 8 22 40.7 14 443
Waiting: 7 22 40.7 14 443
Total: 10 81 262.9 14 1443
Erlang
Connect: 0 10 4.8 10 27
Processing: 7 16 4.8 16 39
Waiting: 5 13 4.2 13 34
Total: 8 26 8.3 26 59

Actor Model - Is it Fast?
YES!!!

Erlang - Example
https://github.com/extend/cowboy

C++ - Actor model

C++ library
● http://neverlord.github.io/libcppa/ - Erlang inspired
● http://www.theron-library.com/ - No fault - No Event IO
● https://code.google.com/p/actor-cpp/source/list - Not developed since
2012
● https://code.google.com/p/libactor/ - Right now it is usable, although it
may not be ready for production
● https://casablanca.codeplex.com/ - Removed actor?!?!
● http://www.stdthread.co.uk/ - No OSS

libcppa - Features
● Lightweight actor implementations
● Pattern matching for messages
● Error handling based on Erlang’s failure
model
● etc ..

libcppa - Is it enough?
Can it solve the initial problem?
example code: double_poll_actor

libcppa - Is it enough?
Main
Poll
Left
Poll
Right
Acc
poll
poll
at
incLeft
incRight
inc
beast
beast
threshold
fire
fire

libcppa - Actor == thread?
How many actors can I spawn?
A lot!!!!
example code: how_many_actors

libcppa - Errors
● Isolated
● Linked
● Monitored
example code: err_mng

libcppa - I/O - brokers
A broker is an event-based actor running in the
middleman that multiplexes socket I/O

libcppa - I/O - brokers
● Create in particular way
● Receive special messages from “system”
● Can take ownership of given connection
example code: http_actor

libcppa - Is it fast???
ab -n 10000 -c 1000 http://127.0.0.1:1339/
Connect: 1 5 5.6 3 26
Processing: 1 6 5.9 4 222
Waiting: 1 4 4.8 3 221
Total: 3 11 10.6 7 231

libcppa vs Erlang - Results
libcppa
Connect: 1 5 5.6 3 26
Processing: 1 6 5.9 4 222
Waiting: 1 4 4.8 3 221
Total: 3 11 10.6 7 231
Erlang
Connect: 0 10 4.8 10 27
Processing: 7 16 4.8 16 39
Waiting: 5 13 4.2 13 34
Total: 8 26 8.3 26 59

libcppa - Is it fast???
YES!!!

Actor Model
Gianluca Padovani
SW craftsmanship, TDD addicted, agile coach. I like Ruby,
NodeJs and everything is interesting. I also work a lot on C#,
C++. I like to code, a lot :-)
https://www.linkedin.com/pub/gianluca-padovani/2/261/a92
https://twitter.com/GPad619
https://github.com/gpad
http://www.slideshare.net/gpadovani

Reference
● Carl Hewitt's Homepage
● Hewitt, Meijer and Szyperski: The Actor Model
● Takeaways from Hewitt, Meijer and Szyperski’s talk on the Actor model
● https://github.com/Neverlord/libcppa
● http://libcppa.blogspot.de/
● Dominik Charousset and Matthias Vallentin: libcppa -- Designing an Actor
Semantic for C++11
● https://github.com/mavam/vast
● Learn you some Erlang
● https://github.com/extend/cowboy
● Actors are not a good concurrency model
● Seven Languages in Seven Weeks: A Pragmatic Guide to Learning
Programming Languages

Actor Model
Thank You!

C++ Actor Model - You’ve Got Mail ...

More Related Content

What's hot

Viewers also liked

Similar to C++ Actor Model - You’ve Got Mail ...

More from Gianluca Padovani

Recently uploaded

C++ Actor Model - You’ve Got Mail ...