[ANN] celluloid 0.1.0: a concurrent object framework for Ruby

Tony_Arcieri3 · 21 June 2011 20:19

Celluloid is a concurrent object framework for Ruby inspired by Erlang and
the Actor Model:

* Github: http://github.com/tarcieri/celluloid
* RDoc: http://celluloid.github.com/

This is the second release of Celluloid, and introduces a new reentrant
method dispatch system based on fibers. More information about this new
system, the problems it solves, and how Celluloid uses fibers is available
in this commit message:

github.com/tarcieri/celluloid

Wrap synchronous method dispatch in a fiber. Celluloid now requires 1.9

The initial release of Celluloid suffered from a pretty nasty problem/bug.
Synchronous calls work fine so long as the actors in a call chain are all
unique (e.g. A calls B calls C). However, if the call chain ever loops back
around to the same actor (e.g. A calls B calls A) a deadlock occurs. A is
blocked waiting for a response from B, so it never realizes B called it.
Meanwhile B has asked A to handle a call and starts blocking waiting from
a response from A. DEADLOCK!

How can this be fixed? The only solution is to allow A to continue to service
method calls even though the method it is currently dispatching is blocked
waiting for a call response. If A could take another request while it's waiting
for a call response from B, it could in turn service the new request B just
made, and unblock the entire call chain.

To accomplish this, we need to wrap the call in a fiber. Whenever an actor
makes a synchronous call to another actor, the fiber can yield, and the
actor can wait for the call response as it processes additional incoming
method calls. As soon as the call response is received, the fiber is resumed,
and method execution continues. Actors remain sequential and only process one
method at a time, but switch back and forth between running methods whenever
synchronous calls are made to other actors.

With this approach in Celluloid, you no longer have any control of the
order methods are executed in. Several actors (each running in their own thread)
may be making method calls at the same time. The receivers process them in
a first come, first served manner, but if the receiver makes another outgoing
call, the actor suspends the method it's processing and moves on to the next
request.

The end result is you may just need to be a little more vigilant when working
with instance variables. Other methods need to work with that state too, so keep
it consistent. Don't mutate an object into an inconsistent state then make a
method call. In general, try to preserve a class invariant.

Don't write sloppy code with implementation logic coupled together between
methods through instance variables. Treat instance variables as the state of
the object, not a temporary space for passing state between method calls.
That's what the stack is for.

If you do that, which I hope you're doing anyway, then everything should be fine
and concurrent objects Celluloid's actors provide should continue functioning as
plain old Ruby objects with awesome concurrent and asynchronous capabilities.

by tarcieri on 12:01AM - 20 Jun 11

changed 1 files with 25 additions and 6 deletions.

Celluloid's concurrent objects should now function just like Ruby objects
whenever synchronous calls are used (the previous release suffered deadlocks
in certain cases). Celluloid objects also support asynchronous method calls
which allow them to run methods in the background without blocking the
caller.

Because this release uses fibers, it no longer works on 1.8.7 and requires
you use 1.9 mode on JRuby (see README for instructions). Rubinius is still
supported in 1.8 mode and Celluloid will work on Rubinius 2.0.0pre.

···

--
Tony Arcieri

Eric_Wong2 · 21 June 2011 22:23

This is the second release of Celluloid, and introduces a new reentrant
method dispatch system based on fibers. More information about this new
system, the problems it solves, and how Celluloid uses fibers is available
in this commit message:

Wrap synchronous method dispatch in a fiber. Celluloid now requires 1.9 · tarcieri/celluloid@3c7d500 · GitHub

I initially had one question/concern with this release I answered for
myself by reading the code:

Q: Did it switch to using fibers (and drop threads), so it becomes like
Revactor uses and thus need its own scheduler?

existing, thread-safe/aware code and not require rearchitecting your
application like Revactor did.

···

Tony Arcieri <tony.arcieri@gmail.com> wrote:
A: No, it still uses threads in addition to fibers. It'll still work with

--
Eric Wong

Tony_Arcieri3 · 28 June 2011 23:25

Hi,

I've posted a reply to your announcement to the Ruby Forum.
Celluloid 0.1.0: a concurrent object framework for Ruby - Ruby - Ruby-Forum

Maybe you have not received it.

Hey, not sure why but I didn't get that email. Are you posting through
Usenet or something?

Thanks for this useful framework with its nice and Ruby like API.

I'm wondering whether you intend to support asynchronous call with
return value(s). Such call would return a future, then the caller would
be able to retrieve or try to retrieve the value(s) at any time.
I know that there is Celluloid::Future but this is not really
"integrated" with the asynchronous call feature. So the nice API is not
complete regarding this aspect.

Yeah, I wanted to do this sort of thing in Reia. I was going to do

obj<-futurized_method_call(...) for that, which would return a future. The
cooresponding obj->methoI'm not sure what syntax would be appropriate for
Celluloid. Perhaps obj.future(:method, *args, &block) ?

PS : The readme still indicates that 'new' creates a normal object, yet
new is now an alias for spawn.

Oops, I changed that in the most recent release and didn't update the

README. Thanks!

···

On Tue, Jun 28, 2011 at 2:54 AM, Chauk-Mean Proum <chauk.mean@gmail.com> wrote:

--
Tony Arcieri

Topic		Replies	Views
[ANN] celluloid 0.0.3: a concurrent object framework for Ruby ruby-talk	11	147	27 June 2011
[ANN] celluloid 0.5.0: easy-to-use concurrent objects for Ruby ruby-talk	0	137	25 October 2011
[ANN] celluloid 0.2.0: a concurrent object framework for Ruby ruby-talk	0	123	12 July 2011
[ANN] celluloid 0.11.1: actor-based concurrent objects for Ruby ruby-talk	0	127	17 July 2012
[ANN] celluloid 0.6.0: easy-to-use concurrent objects for Ruby ruby-talk	0	123	19 November 2011

[ANN] celluloid 0.1.0: a concurrent object framework for Ruby

Related topics