| 42 interested
Vertical scaling is today a major issue when writing server code. Threads and locks are the traditional approach to making full utilization of fat (multi-core) computers, but result is code that is difficult to maintain and which to often does not run much faster than single-threaded code.
Actors make good use of fat computers but tend to be slow as messages are passed between threads. Attempts to optimize actor-based programs results in actors with multiple concerns (loss of modularity) and lots of spaghetti code.
The approach used by JActor is to minimize the messages passed between threads by executing the messages sent to idle actors on the same thread used by the actor which sent the message. Message buffering is used when messages must be sent between threads, and two-way messaging is used for implicit flow control. The result is an approach that is easy to maintain and which, with a bit of care to the architecture, provides extremely high rates of throughput.
On an intel i7, 250 million messages can be passed between actors in the same JVM per second–several orders of magnitude faster than comparable actor frameworks.
A fully durable in-memory database was also developed as a proof of concept, which processes transactions at a rate of 1 million per second when using an SSD for the backing store. Again, this is orders of magnitude greater than comparable approaches.
All code is LGPL, so there are effectively no constraints on usage.
Slides: Actors in the Small, Code Samples
Web Site: Jactor Consulting
Our open source company, JActor Consulting, was founded as a means of promoting this disruptive technology. And we do not believe in dual licensing.
42 Interested
Tags
Share this session:
As I understand it, there will only be 10 min for a presentation, followed by a 40 min discussion. That is not enough time to cover the slides listed above, so I suggest you review them before attending, though that is NOT a requirement–I’ll do my best in the 10 min to introduce this technology and explain its potential impact.
Also, please add comments here for anything you want me to cover, as well as any questions you have. I can always try to answer your questions here as well. This way we can make the best use of our time.
Bill
[email protected]
[…] Vertical Scaling made easy through high-performance actors […]
Here’s my dream machine, with 66 cores: http://goparallel.sourceforge.net/virtualized-symmetric-multiprocessing-eases-mic-transition/
Without something like JActor, writing an application that would fully utilize a machine like this would be quite a challenge, hmm?
Here’s a set of 10 slides on developing high-performance Java code that you may also find of interest: http://www.slideshare.net/laforge49/high-performancejava
(Just wrote these slides today.)
Bill
Hi Bill,
You can plan your session as your wish but suggest you to keep some time for discussion. It does not need to be 10 + 40 min method.
Good Luck,
Viral
Been thinking that I’ll give a brief introduction, field any questions and then fill in the remaining time with slides & more questions.
Expecting a 40 min. discussion seems unrealistic, though I would very much welcome that.
My desired outcome is to (a) build the development team, (b) encourage early adoptors and of course (c) build awareness.
I have just reworked and expanded on the talk I gave into the form of a Blog: https://www.ibm.com/developerworks/mydeveloperworks/blogs/jactor/entry/the_problem_with_actors56?lang=en
I’ll be giving a 3-hr talk on 4th October (Thursday): http://www.meetup.com/Bangalore-TechMeetups/events/83810782/?a=ea1_grp&rv=ea1