The Friday Fragment

It's Friday, and time again for the Friday Fragment: our weekly programming-related puzzle.

This Week's Fragment?

There's no new fragment for this week. The Friday Fragment will take a break while a couple of interesting projects keep me busy. But somehow, some way, some Friday, it'll be back to remind us all what just a fragment of code can accomplish.

Last Week's Fragment - Solution

Last week's challenge was to outsmart a call center math PhD who was just trying to get rid of me for awhile:

Write code to do ten threaded runs of the basic Leibniz formula to calculate pi to nine correct digits (one billion iterations) in significantly less time than ten successive runs.

I offered my single-threaded Ruby implementation as a starting point.

Threading this in Ruby was quick: just change the single-threaded (successive) calls to this:

     threads = []
     10.times do
       threads << Thread.new do
         puts Pi.new(1000000000).calculate
       end
     end
     threads.each { |thr| thr.join }

The updated Pi class is here.

I added some timing code and compared this to the single-threaded version, both running on my quad core machine. A typical single-threaded run under the standard VM took over 166 minutes.

As I wrote before, multi-threaded code doesn't buy much when run under the standard (green threads) VM. It's easy to see why - it doesn't keep my four CPUs busy:

And so it actually ran slower than the single-threaded version: 185.9 minutes.

To get the real benefits of threading, we have to run in a native threads environment. The threaded version running under JRuby kept all four CPUs busy until complete:

This completed in 23.4 minutes, leaving me time to call back before the end of my lunch break.

This simple fragment does a nice job of demonstrating the benefits of native threads and multi-core machines in general, and JRuby in particular.