The processor war seems to be hotting up. IBM recently (8th February) launched their latest Power7 processor, which adds more cores and improved multithreading capabilities to boost the performance of servers requiring high up time. The Power7 chip has up to eight cores, with each core able to run four threads, and can simultaneously run 32 tasks. This is four times the number of cores on the older Power6 chip.

http://www.pcworld.com/article/188790/ibm_launches_eightcore_power7_processor_servers.html

IBM has reported that eMeter, a leading maker of software that runs e-grids, ran a successful benchmark on IBM Power6 systems for more than 20 million smart meters. Scott Smith, eMeter client business manager, said, “Combining eMeter and IBM’s Power7, we are confident we can hit much higher numbers to meet their needs.

IBM’s Power7 is sure to raise the heat on Intel. Intel will be under tremendous pressure because its Itanium Tukwila is only quad core. Nehalem EX the eight-core chip can only carry out hyperthreading for two threads.

http://www.slashgear.com/intel-nehalem-ex-server-cpu-8-cores-16-threads-64-dimms-per-platform-2744906/

Meanwhile, Oracle appears to have a “trick or two” up its sleeve. Take a look at their TPC-C benchmark in cluster mode. They use an eight core, eight thread, UltraSparc T2

http://tpc.org/tpcc/results/tpcc_result_detail.asp?id=109110401

And they beat IBM’s non-clustered numbers by a good 25%. While this may not be an appropriate comparison; if speed is all that counts, this is definitely ok.

When CPU clock speeds accelerated past the 1 GHz mark, there were many who predicted that the 10 GHz mark was in sight. However, this proved to be premature as, manufacturing challenges apart, an exponential increase in clock rate led to corresponding increase in generated heat.

Parallelism presented itself as a viable alternative. While six core processors are available today, eight cores will be ready within the year. GPU cores are already running into their hundreds.

Parallelism necessitated custom software, and threads were introduced to leverage availability of multiple cores. But, along with threads, comes the problem of synchronization i.e. the ability to correctly manipulate collections (i.e. data structures) since the same list, map, or queue may end up being manipulated by different threads on different cores.

Java and C#, both being object oriented programming (OOP) languages with mutable data structures, have been trying to address this challenge for a while. Java 1.5 introduced the Java.util.concurrent package with concurrentXXXX collections and java.utilatomic with atomicXXX datatypes.

.NET 4.0/C# has now caught up with TaskParallel Library (See link below)

http://software.intel.com/en-us/blogs/2009/04/08/concurrent-collections-for-c-using-parallel-extensions/

This however has some limitations. Read comments from Gaston Hillar in the above link as explained here . . .

http://blogs.msdn.com/pfxteam/archive/2010/01/26/9953725.aspx

So does it mean Java is automatically multicore friendly?

No, but they “seem” to have made a very smart move. They just wrapped Intel Thread Building Blocks (TBB)

http://habanero.rice.edu/Habanero_Home.html
http://habanero.rice.edu/cnc.html

The brains behind Habanero Java…

http://www.media.rice.edu/media/NewsBot.asp?MODE=VIEW&ID=11728

But, it’s not part of standard Java yet. Also even if it’s possible to “parallelize” recursive functions (read Brian Goetz’s Java Concurrency in Practice — Applying Thread Pools) with ScheduledExecutorService, why should one do that?

Because there is the alternative of Functional Programming. Functional programming eliminates the need for synchronization by making data structures immutable and functions parallelizable.

But Haskell is hard. So Microsoft introduces F# — a diluted Haskell, but still better than C# & Java — with no synchronization issues

As it stands, Habanero Java is ahead of .NET Task Parallel Library, but .NET has F#. And the dance continues…

Wow! What a difference two years can make. At the end of 2007, it seemed as though Microsoft’s fortunes were fading. Bill Gates had retired, and Steve Ballmer had taken over as CEO. Ruby on Rails and Google satellite maps were a rage and iPhone/Apple pretty much defined ‘bleeding edge.’

Fast forward to 2010 and how things have changed. Microsoft seems to be on a come back trail. Among its most exciting projects is ‘Natal.’ Natal is the code name for a “controller-free” gaming and entertainment experience from Microsoft for the Xbox 360 video game platform. Based on an add-on peripheral for the Xbox 360 console, Project Natal enables users to control and interact with the Xbox 360 without the need to touch a game controller – by using a natural user interface that accommodates gestures, spoken commands, or presented objects and images.

http://www.microsoft.com/presspass/events/ces/videogallery.aspx?contenti

This is like computer vision and makes Wii seem so tame, not to mention Google Goggles!

Another of Microsoft’s projects to look forward to is F#, a functional programming language for the .NET Framework. It combines the succinct, expressive, and compositional style of functional programming with the runtime, libraries, interoperability, and object model of .NET. This is bad news for IBM/ORACLE and Google Go!

http://msdn.microsoft.com/en-us/fsharp/default.aspx

And Ruby folks are trying to act ‘functional’ . . .

http://www.rubyinside.com/functional-programming-in-ruby-2713.html?utm_s

Also on the way is DryadLINQ, Microsoft’s own Hadoop. DryadLINQ is a simple, powerful, and elegant programming environment for writing large-scale data parallel applications running on large PC clusters.

http://research.microsoft.com/en-us/projects/DryadLINQ/

With the exception of the recently released apple tablet, there seems to be no “tech magic” from anyone other than Microsoft. Google really has to watch their back now; because with F# on their menu and Simon Peyton Jones & most of the Haskell team on their payroll, Microsoft appears to have won the compiler war. Microsoft is also quickly catching up on the scalability side with DryadLINQ. The combination of F# and DryadLINQ could deliver a knockout punch to Google! What’s more, once Natal rolls out for Christmas, iPhones could be running for cover.

The concept of relational model is based on set theory. A relation is a set. A set is made of unique (i.e. non-duplicate) elements. A relation can be represented as a table. No two columns in a table can be the same. A subset of A can have at most all the elements of A. A given view on a table (i.e. ignoring join scenarios, since they define new sets) can at most have all the columns in A.

Now considering an Entity model of a table A (Hibernate/java, Entity Framework/C#, ActiveRecord/ruby), a table is represented by an Entity class and rows as instances of that Entity. By definition, classes allow “Inheritance” unless explicitly defined otherwise. “Inheritance” allows attributes to be “added” i.e. it “breaks” the definition of a set.

Under no circumstance in set theory, can a subset “add” new elements to its parent set because it would negate the definition of a subset. But in an object-oriented world, this is exactly what happens through “Inheritance”.

A parent class definition is “extended” through additional attributes/methods in child/subclass. So now the subclass is a “superset” of the parent class and there by has lost all “set based” foundation i.e. now JOIN,UNION,INTERSECTION will be useless, because there would different results based on how deep or how shallow one stands on the inheritance hierarchy.

In another perspective, relational/set model is deterministic i.e. # of elements are governed by a rule whereas an inheritance model is non-deterministic i.e. a class can extended to any extent and there are no rules to govern what attributes (instance variables) may or may not be added. This is true even in the case of “Single Inheritance” driven languages — Java/C#/ruby. This lack of ability to control “inheritance depth” is what creates the object relational mismatch.