Kilim - actors and message passing in Java
As discussed in The multicore crises: Scala vs. Erlang, massage passing and the actor model of concurrency is one promising way for the massive parallelization needed to utilize current and especially future CPUs. Erlang has it built in from the start and Scala incorporated the Scala Actor library into it’s framework. But there is also a pure Java solution - Kilim
Kilim is a message-passing framework for Java that claims provides ultra-lightweight threads and facilities for fast, safe, zero-copy messaging between these threads.
It consists of a bytecode postprocessor (a “weaver”), a run time library with buffered mailboxes (multi-producer, single consumer queues) and a user-level scheduler and a type system that puts certain constraints on pointer aliasing within messages to ensure interference-freedom between threads.
And it seems to perform well. According to Sriram Srinivasan in his Google Tech Talk, task-switching in Kilim is 1000x faster than Java threads and its message-passing is 3x faster than Erlang.
Kilim works with code annotations on methods and arguments. A method is annotated as
@pausable if it directly it indirectly calls other pausable methods, which somewhere in the call chain will result in calls to Kilim methods, such as
Mailbox.get(). The annotated code is transformed by the bytecode weaver to code in a continuation passing style. Continuations are native in some languages but has been retrofitted into Java code before in well known web frameworks and web servers, such as RIFE and Jetty.
Arguments on the other hand are annotated as
@safe. These argument qualifiers are described in an ECOOP 2008 presentation by Sriram Srinivasan and Alan Mycroft:
These qualifiers can be understood in terms of two orthogonal capabilities of an object in a tree: first, whether it is pointed to by another object or not (called a root in the latter case) and second, whether or not it is structurally modifiable (whether its pointer-valued fields are assignable). The latter is a transitive property; an object is structurally modifiable if its parent is.
Given this, an object is free if it is the root of a tree and is structurally modifiable. A cuttable object may or may not be the root, but is structurally modifiable. An object with a safe capability cannot be structurally modified (transitively so), and does not care whether or not it is the root.
The actor model is popping up in more and more contexts, and no matter which language or platform you will program in in the future, the concept is likely to be in important one.
Nice to see a Java only implementation I will definitely be checking this as a possible execution model type in Einstein. What's interesting is the way that he has chosen to annotate the degree of mutability. I think that thinking in gray-scale rather than monochrome is the way forward for general purpose (rather than specialist) scalability techniques. I'm not convinced yet by the absolutism of some languages/frameworks with rigid restrictions, like those in functional programming; I think we have a lot to learn from the results of using these idioms but need to be able to say the degree of, for example, idempotency, mutability, concurrency etc. that we desire or can assure etc. And exploration in this area is very interesting to see.
Definitely on my one to watch list!
All the best
Can he switch his project page back to black text on white background ?
Re: Can he switch his project page back to black text on white background ?
You may have noticed from my project page (the above link to Einstein) I am a little biased in this area :).
All the best
A few clarifications.
One of the big features of Actors, as used by the originators of the term (Carl Hewitt, Gul Agha), is isolation from one another. There is no point doing concurrent programming if you cannot isolate easily.
In Scala's actor model, isolation is not enforced; it is obtained by convention; the programmer must use immutable messages or be "very careful" while exchanging mutable messages.
A continuation is a snapshot of both the data and control planes. In that sense, Jetty doesn't provide continuations (it only restores the control plane, but no support on the data plane; it leaves it to the programmer to figure out which variables to restore, and where to store them before yielding.
Kilim can be downloaded at kilim.malhar.net. There's an "IFAQ" (Infrequently asked questions) in the download that provides more comparisons.
Java and Actor Model - eh!
Kilim - what's the matter here?
Anatole Tresch Mar 03, 2015