It was about the paradigm shift that the chip industry is undergoing – the trend towards more cores, rather than higher gigahertz horsepower. However, if you are an average Joe developer like me, you probably program your applications without leveraging the power of two or more cores simultaneously. By default, we don’t ‘think parallel’ for various reasons. For one, threading is not an easy concept. The seminar looked at some of Intel’s software offerings that help developers (especially Visual Studio developers) to create, debug and optimize threaded/multicore applications. (However, this post will not focus on those tools – you may want to visit www.intel.com/go/parallel for more information).

On a related thread (pun intended!), gcc-4.4.0 was released recently. This added support for version 3.0 of the OpenMP specification. OpenMP is something I had heard of before, but never actually tried. It is an API for C, C++ and Fortran programmers that enables you to ‘parallel program’ easily. Jargonspeak calls it ‘platform independent shared memory multiprocessing’. In effect, it’s threads without the associated headache of thread management. By the way, gcc has supported OpenMP way back from version 4.2. So, you don’t need the latest bleeding edge version for this. However, should you want to, on Windows you can always download the excellent TDM MingW builds for gcc-4.4.0 (latest direct link). If you’re a Linux geek, you probably know how to get gcc-4.4 for your distro anyway. Also, Microsoft Visual C++ Express does not include/support OpenMP – hence my experiments are limited to gcc on both Win and Lin.

All right then, let’s see how OpenMP aids a classic case of parallelization: matrix multiplication. Agreed – this is a rather simple programming problem, and real world problems are usually harder to parallelize than this. However, this should serve as a good starting point to explore further.

So, here’s the basic matrix multiplication loop that we want to parallelize, assuming arr1 and arr2 are inputs, and arr3 is the output array:

for(i=0; i<n; ++i) {
  for(j=0; j<n; ++j) {
    temp = 0;
    for(k=0; k<n; ++k) {
      temp += arr1[i][k] * arr2[k][j];
    }
    arr3[i][j] = temp;
  }
}

OpenMP is mostly a set of compiler directives (pragmas) and library routines. In this case, it's enough for us to add on single statement before our loop.

#pragma omp parallel for private(i, j, k, temp)
for(i=0; i<n; ++i) {
  for(j=0; j<n; ++j) {
    temp = 0;
    for(k=0; k<n; ++k) {
      temp += arr1[i][k] * arr2[k][j];
    }
    arr3[i][j] = temp;
  }
}

That’s it! This pragma tells the OpenMP subsystem to do it’s little magic behind the scenes and parallelize the ‘for loop’ following it.

Here’s the complete program, which contains additional code to initialize the arrays arr1 and arr2 pseudo-randomly, and to calculate the timings taken by the normal and the parallelized versions. You can compile the program with gcc-4.4 by the simple command:

gcc -fopenmp matmul.c

And on Windows, you might need to edit the PATH variable to include the GNU libgomp runtime (libgomp-1.dll). (Libgomp is GNU’s implementation of OpenMP). Here’s how I did it, for example:

set PATH=D:\MinGW\lib\gcc\mingw32\bin;%PATH%

So, the end result? Here are 4 sets of execution outputs. Two from Windows (TDM gcc-4.4.0):

Enter dimension ('N' for 'NxN' matrix) (100-2000): 1000
Populating array with random values...
Completed array init.
Crunching without OMP... took 23.032000 seconds.
Crunching with OMP... took 13.000000 seconds.

Enter dimension ('N' for 'NxN' matrix) (100-2000): 2000
Populating array with random values...
Completed array init.
Crunching without OMP... took 216.140000 seconds.
Crunching with OMP... took 118.641000 seconds.

And two from Linux (Ubuntu 9.04, gcc-4.3.3):

Enter dimension ('N' for 'NxN' matrix) (100-2000): 1000
Populating array with random values...
Completed array init.
Crunching without OMP... took 21.623144 seconds.
Crunching with OMP... took 13.686926 seconds.

Enter dimension ('N' for 'NxN' matrix) (100-2000): 2000
Populating array with random values...
Completed array init.
Crunching without OMP... took 189.184673 seconds.
Crunching with OMP... took 104.220751 seconds.

That’s almost doubling the speed, while adding one statement to your program! Actually two statements, if you include the include directive for <omp.h>. I’m sure you’d agree that for this case, OpenMP provides a really easy way of utilizing the idle core of most desktop machines out there. The good part is, even on a single core machine, the code works the way it should (the pragmas essentially NOP out, since there’d be no benefit in parallelizing on one core).

A look at the CPU utilization proves to be interesting too. (By the way, my home system runs an AMD Althon64 X2 4600 dual core, at a clock speed of 2.4GHz). In the first case, here’s a snap of the system information (using the excellent Process Explorer). Notice how the CPU usage remains peaked at around 50%, and the second CPU is mostly idle. Please click on the images below for the full view.

And here’s the usage when the OpenMP crunching is in action:

That’s more like it. Both horses in action, CPU peaked at 100%. Similar stuff can be seen on Linux, using Ubuntu’s (rather, GNOME’s) inbuilt System Monitor:

The portion where the red and orange worms collide at the top is the duration of the OpenMP version of the matrix multiplication program.

As already stated, matrix multiplication is an ideal case – and such 2x speedup on dual core machines are possible with only such ideal problems. However, there often are, if you look closely enough, parts of your program that can be parallelized. Further, we have not even scratched the surface of what’s possible using OpenMP 3.0. It goes way beyond parallelizing simple for loops. (Here’s the link to the spec in PDF).

And for sure, OpenMP is not the only way to go parallel portably. If you work in C++, you would have heard of the Boost C++ libraries. Give boost::threads a go!

With Intel gearing up for the release of its eight core Nehalem EX processors, and with AMD’s six core Istanbul processor already finding its way into mainstream desktop boards, there remains only one thing to say: if there is a time to think in parallel, this is it!

~Raj

As you can see here, it’s obscenely expensive, at almost 5k INR, and not something lesser mortals such as I would consider buying otherwise. Perhaps what Russel Peters says about Indians here is true, after all

(Poor) jokes apart, unboxing the package reveals a manual, a warranty-card, two extra sets of plugs (for abnormally small and abnormally large ears) and a leather carrying case, apart from the headphones. The medium sized plugs come mounted on the headphones. People seem to have complaints that these plugs keep falling off, but that hasn’t happened with me.

The earphones by themselves are the ‘in-ear’ type, meaning that they go quite a bit inside your ear-canal. At this point, I should probably mention that I’m no hardcore audiophile. Though this is my first set of in-ear headphones, I find that they fit in quite nicely, albeit a tad loose perhaps.

I plugged these babies into my PC, and set the mode to “headphone” on the Realtek HD Sound Manager (an app bundled with my motherboard). On my PC, I personally find that the best sound is produced by VLC media player (in “Rock” equalizer mode) for mp3 files.

The first thing I noticed about the sound was the humongous bass reproduction. I’ve never experienced such bass from such small earphones, for sure. The highs were also very crisp, but not tinny. After about a month of testing, this is what I would have to say, in summary:

Pros:

• Awesome bass reproduction, very good mids and highs
• Comfortable even after long hours of use
• Good looks, good build quality

Cons:

• Extremely expensive
• No noise cancellation, ineffective noise isolation

Overall, a very good pair of headphones. However, the price is way too much. And for that very reason, you tend to be very cautious – being extremely careful not to tug it by mistake, for example. So the bottomline is, if you have tons of money, go for it! If that’s the case, you may also want to take a look at the Bose Quiet Comfort range of headphones, which are said to offer the best noise-cancellation in the market today.

~Raj

My PC was already a venerable powerhouse. Equipped with an AMD Sempron 2200+ (1.5GHz) processor, 512MB of RAM, and a GeForce 400MX IGP, it had the muscle to play all 3D FPS games of… well, the year 2003 at best

The reason behind this upgrade was to spend less of my extremely valuable time twiddling my thumbs and waiting for Firefox to start, or a Half-Life 2 episode to load.

So I headed off to Chenoy Trade Centre at Secunderabad, to an affable guy named Gaffar at a store called ‘Computer Bazaar’. Incidentally, this is also where I had bought this PC. Till date, I’m not sure if this guy hoodwinks me with all his tall claims

I had a budget of around 10k INR in mind. This is what I ended up with, after overshooting it by around 1.3k:

• AMD Althon64 X2 4600 (dual core, clock speed of 2.4GHz)
• Gigabyte MA78GM-S2H mobo based on the AMD 780G chipset, featuring ATI Radeon 3200 HD IGP
• 2GB DDR 667 RAM
• Seagate Barracuda 250GB SATA hard drive
• A new 400W SMPS from a shady brand (Xtec, if I remember correctly)

This does look neat!

The motherboard itself was highly rated by tech articles on the internet, and it does boast an array of features. I’ve yet to test the performance of the IGP on this board. As per this Techtree.com article, this IGP is capable of allowing playable framerates at medium resolutions/quality details for quite recent games such as F.E.A.R, HL2: Lost Coast and Quake 4! Far Cry should also be playable, woo hoo!

The folks at the store assembled this setup, and I brought the cabinet home. Powered on, and was greeted with this message:

GRUB: Loading stage 1.5…. Read Error

Since I had two hard drives now (an older 80GB IDE/PATA drive, and the new SATA drive), I was half expecting things to go wrong. Hence, I had planned to perform a fresh dual boot setup of Ubuntu Hardy Heron and Windows XP on the new SATA drive. When I popped in the Windows XP bootable disc, and rebooted the system, the CD failed to boot.

I rebooted into the BIOS, and could not find the DVD drive listed anywhere. Trying to plug in the IDE cable and power supply for the DVD drive again did not help. Finally it dawned upon me that the master-slave configuration of the drive was probably incorrect for my new configuration. I switched the jumper at the back of the DVD drive. Voila! Not only was the DVD drive recognized, but GRUB was also able to boot everything properly!

I still plan to perform fresh OS installs on the SATA drive for better performance. For now, I’m continuing with my old XP install, and a fresh Ubuntu 8.04 install over the 7.10 installation (since I’ve had a few problems with ATI drivers on Gutsy, and wanted an excuse to upgrade to Hardy anyway).

I’ll probably post on the performance of the IGP and the new processor/RAM combo later. But from what I’ve seen, the toil has been well worth it

~Raj