Thread by @heathercmiller

Not at @usenix #ATC19/interested in WTH @cmeik's Partisan is?

I'll live tweet it for yinz❤️

Partisan is:
a distributed runtime that removes assumptions made by initial dist actor runtimes (Dist Erlang, Orleans, Akka) & allows for significantly increased scalability & throughput

First point, the use of actors in distributed systems is popular and common in industry. (This can be a contested point depending on the audience.) Examples:

Distributed actor runtimes currently have limitations that affect them in 2 dimensions:

- scalability
- latency

We want to scale to larger clusters. We want to use all available network bandwidth.

But we don't want people to have to change their code or to need a new VM!

Limitation #1:
Current actor runtime implementations assume a full-mesh topology. Or, that all actors can directly communicate with each other.

This is prohibiting. Not all applications want/need this. & it limits how big we can make our clusters.

Eg, only 200 nodes for Erlang

Limitation #2:
All messages, no matter how many actors per machine, are multiplexed onto a single TCP connection. Background/maintenance messages often get in the way of application messages.

Enter Partisan:
A drop-in replacement for Distributed Erlang that overcomes these limitations by:

1. allowing applications, at runtime, to choose between multiple overlays (eg client-server, p2p) w/o recompiling

2. more channels, some specialized for different types of messages

#1:
Partisan enables dynamic selection of overlay at runtime, w/o recompiling

You can still do full-mesh

But we add client-server & peer-to-peer, which we show enables us to scale to 1000s of nodes

#2:
Partisan enables different ways to parallelize traffic on channels.

One example: separating application-level traffic from background/maintenance traffic.

Lots of benchmarks to understand the ways in which Partisan improves on the state-of-the-art, including:

- a replicated ad counter benchmark (think ads in Angry Birds)
- microbenchmarks + impl of Riak on Partisan to understand overhead of framework & latency improvements

Result 1:
Can scale all the way up to 1024 nodes in peer-to-peer configuration!

Can scale all the way up to 256 nodes in client-server.

(Note: y-axis of graph in log scale)

Result 2:
Partisan offers significantly improved latency over baseline/state-of-the-art Distributed Erlang (13.5x factor improvement)

Red is Distributed Erlang
Purple is Partisan
(The other colors are w/ only some optimizations switched on)

Result 3:
Partisan performs *a lot* better than Distributed Erlang when message size increases.

This is important, because actor systems are being used for data-intensive programming! It's bad if your runtime chokes for data >1MB.

Takeaways:

It turns out that actor runtimes were initially implemented too restrictively.

In Partisan, we show we can loosen these restrictions without changing the programming model! 🎉🎉🎉

Partisan is used in production already–e.g., Bondy

Most important takeaway:

We think that if other actor runtimes take advantage of some of these insights too, that it could enable all kinds of new applications to be implemented atop actor systems!

For more info, & to reproduce our benchmarks, check out:
partisan.cloud/usenix-atc-201…

Paper is open access and available here:
usenix.org/conference/atc…

❤️@usenix
joint w/ @palvaro & special thx to @zeeshanlakhani @rstutsman @frankmcsherry @slfritchie @jon_meredith