1
$\begingroup$

In Seven Concurrency Models in Seven Weeks by Butcher, it compares Actor Model and Communicating Sequential Processes (CSP):

  • CSP is more flexible than actor model: In actor model, the medium of communication is tightly coupled to the unit of execution: each actor has precisely one mailbox; In CSP, channels are first class and can be independently created, written to, read from, and passed between tasks.

  • Nothing stops CSP from supporting distribution and fault tolerance, but historically CSP has not had the same level of focus and support of the two as actor model does.

  • Both actor model and CSP do not directly support parallelism. Parallelism has to be created based on concurrency building blocks.

I was wondering if the two concurrency models can be compared in terms of some metrics (some measurement, quantities, ...) in aspects either mentioned above or not. (Butcher's book doesn't mention such metrics. I also tried but haven't found it in Varela's Programming Distributed Computing Systems.)

If concurrency models can not be compared in metrics, how can they be compared?

I am looking for some metrics to fit into the comparison between the concurrency models. Also for books, papers and articles for comparing them.

Thanks.

$\endgroup$
3
  • $\begingroup$ I am having a bit of a problem with claims like actor model and CSP do not directly support parallelism. Comparing different concepts of computation is a difficult issue. The Church-Turing thesis assures us that they are all the same. Making finer distinctions raises the question: how? And it turns out that different approaches to comparison give different results. Maybe D. Gorla, A Taxonomy of Process Calculi for Distribution and Mobility is a good starting point? $\endgroup$ – Martin Berger Dec 17 '20 at 20:55
  • $\begingroup$ An relevant early summary is: V. Sassone, M. Nielsen, G. Winskel, Models for concurrency: Towards a classification. $\endgroup$ – Martin Berger Dec 17 '20 at 21:02
  • 1
    $\begingroup$ What do you mean by metric? You want to metric space of all programming languages, and have a meaningful motion of distance on this space? What should this distance express? $\endgroup$ – Martin Berger Dec 17 '20 at 22:18
5
$\begingroup$

There are no metrics, but an excellent discussion of many concurrency models, in Tony Garnock-Jones PhD thesis. See the (HTML version of the) chapter "Approaches to coordination". This studies concurrency models with a particular focus, namely how information is exchanged for coordination.

$\endgroup$
0
$\begingroup$

I think you can build such metrics as a graph of dependencies with objects and arrows (functions), both referenced as nodes, and dependencies as vertices. Then you have at least connectivity (connection, connexité) between two nodes as the shortest number of nodes between; that's a first common metric (in graphs and physics).

The topology is the discrete topology. There are no spontaneously any geometry with measure, but when one add some time notion (complexity, measured time in the context of an implementation), it is clear that such geometries and metrics can be constructed.

Several metrics hence can be invoked, as well as functions over them, in order to compare the models.

I think you might want to look on the side of operads to connect geometries, topology and algorithms, maybe Algebraic Operads, An Algorithmic Companion, Murray R. Bremner, Vladimir Dotsenko, (2016, Chapman), among others.

$\endgroup$
1
  • $\begingroup$ Could you elaborate on this? I'm not sure what you propose works, it's not clear to me why operads should be a good formalism for comparing the expressive power of programming languages at all. $\endgroup$ – Martin Berger Dec 17 '20 at 20:58

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.