C# TeX Visual Basic Other
Switch branches/tags
Nothing to show
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.
AsyncTest Restored some fst code, reduced number of boids; removed strongname key Aug 26, 2015

#A Scalable Joins Library

Scalable Joins is a CLR library for declarative, scalable parallel synchronization.


.NET 4.5 Visual Studio 2013 (optional) pdflatex (optional)


With multiple cores, even mainstream programmers need to write parallel code. Those parallel threads need to communicate and synchronize.

Writing correct synchronization code is hard; achieving performance that scales with the number of cores is a black art.

Scalable Joins is a library that extends C# and other Common Language Runtime languages with declarative, high-level synchronization constructs.

The model is based on the message passing join calculus:

  • Objects can declare channels on which to receive messages and requests;
  • Methods are declared to react when sets of channels are filled.

Threads coordinate by sending messages. The ideas are simple, yet powerful.

The library is a new, lock-free re-implementation of the lock-based Joins concurrency library, designed to scale on parallel hardware. As before, programmers write simple, high-level code but now they also get the parallel scalability of complex, low-level code previously crafted by experts. The library provides both lock-based and lock-free implementations of join patterns. Its modular design supports experimentation with other implementation strategies.


Consider E. Dijkstra's classic Dining Philosophers problem. Declarative join patterns, provided by our Joins library, make it almost trivial to solve - all we have to do is state the desired constraints:

var table = Join.Create(2 * n); 
// channel arrays for requests and resources
Synchronous.Channel[] hungry; table.Initialize(out hungry, n);
Asynchronous.Channel[] forks; table.Initialize(out forks, n);
for (int i = 0; i < n; i++) { 
 var leftFork = forks[i]; var rightFork = forks[(i + 1) % n];
 // a join pattern
 table.When(hungry[i]).And(leftFork).And(rightFork).Do(() => {
    // eat ... 
    leftFork(); rightFork(); // replace forks 
    // think ...
// set the table 
foreach (var fork in forks) fork();  
// spawn the philosophers
for (int i = 0; i < n; i++) { var _i = i; 
  var phil = new Thread(() => {   
    while (true) hungry[_i](); // request to eat

This code represents the resources of the problem (the forks) as asynchronous channels. A resource is available if, and only if, there is a message on its channel. When hungry, philosopher i makes a synchronous request on his dedicated channel, hungry[i]. A request on hungry[i] will wait until or unless the philosopher's left and right forks are available. Once done eating, a philosopher releases his forks by invoking their channels, replenishing the resources he just consumed.


With VS2013 simply open the solution file Joins.sln.

This contains projects for the library as well as larger demos, smaller samples and tutorial style documentation.


Papers describing the implementation(s) and performance evaluation are available here:

Aaron Turon and Claudio Russo. Scalable Join Patterns. Proceedings of the 2011 ACM International Conference on Object Oriented Programming Systems Languages and Applications, OOPSLA '11, pages 575-594, New York, NY, USA, 2011. ACM. [pdf | ( ]

Claudio Russo. The Joins Concurrency Library. Ninth International Symposium on Practical Aspects of Declarative Languages (PADL 2007), volume 4354 of * Lecture Notes In Computer Science (LNCS)*, pages 260-274. Springer-Verlag, January 2007. (c) Springer-Verlag, [pdf | (")]|

More generally, see Wikipedia's join pattern page.


The primary authors are Claudio Russo, Aaron Turon and Matthew Parkinson. Thanks also to Nick Benton, Cedric Fournet, Dan Alistarh and Lucas Bordeaux.