Ruby and threading for multi-cores

With the CPU manufacturers’ focus on multi-core architecture rather than GHz boost, a lot of debate and research has started to scale existing software applications to take advantage of this development.

Let’s consider Moore’s Law for a moment. This is not really a mathematical law but just a rule of thumb that CPU manufacturers aka Intel & AMD follow. Therefore the software industry expecting that much growth in processing power X months down the road always optimize their software to match the performance of the hardware at the time when their solution will be launched. This growth pattern is followed by all game developers, DBMS vendors, corporate solution vendors like SAP, Siebel etc. and others.

Optimizing software solutions to match raw GHz processing power was easy but matching it with multiple cores, 2\4\8, seems a rather difficult task. As the software languages of today don’t support auto multi-processing. That means to say that a lot of manual coding effort is required to keep parallel processing optimized for parallel tasks. Then there is the insurmountable work of synchornizing the manual threads to avoid deadlock situations, thread starvation, keeping critical section safe and the like. This is the situation with all the modern dominant languages like Java and C#.

On the other hand, its time for another software language shift. Industry consultants predict that after every 10 years, the dominant software language gets replaced by some other language. Case in point is, Cobol, Fortran, C++ and now Java.

The most appropriate successor to Java seems to be Ruby<period>

I found one of *the* most comprehensive coverage of threading in Ruby and the latest trends/research.
But the problem I figured out is that there is no pattern of thought process developing or research heading somewhere concrete.
Although Ruby MVM is posed as the best option available but still issues with this approach are mentioned. Also any successful work on that is hard to find.

It seems threading in Ruby will remain experimental in nature and may only improve with the advent of some other language that has a solid implementation of the threading experiments done in Ruby side.

Advertisements

1 Comment

  1. 11111


Comments RSS TrackBack Identifier URI

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s