Saturday, January 31, 2009

What to do with thousands of cores

I recently went to a talk by my ex-advisor on multi-core operating systems. They've been working on a lot of interesting ways to make existing operating systems like Linux deliver better application performance on multi-core hardware. Unfortunately, existing operating systems tend to not scale well themselves when run on many cores, thus preventing the applications that run on those operating systems from delivering good performance. Given the rate of technology change, they expect things to get really bad once chips are providing thousands or more cores each.

I wonder if there's a simpler way to program these massively parallel chips. Why not run a copy of your existing off-the-shelf OS on each core and view a multicore chip as a data center on a chip? Instead of trying to make operating systems scale across many cores we can just run many copies of the same operating system. We already know how to program a thousand servers running in a data center, so we would already know how to program a thousand cores acting like their own servers. We might even go so far as to put a 100 gigE switch and interconnect between cores on the same chip to really make the programming model one we're familiar with. Some cores could run a load balancer/firewall, others could run web servers, others databases and others file servers.

Obviously over time we might start specializing the interconnect a little more or run things besides a ethernet interface, though the venerable ethernet interface might serve us well. And yes it is inefficient to run tcp between cores in a chip and things like rdma or other protocols could be used for some applications in the future.

The key is making it dirt simple to scale and program even if it's not so efficient. Remember the key division of work: the software is supposed to be designed to offer the desired application functionality and be easy to write bug free applications while the hardware is supposed to deliver better and better performance. We shouldn't get too tied up in wringing every last ounce of performance out of the software at the expense of making things really hard to program or having to re-write everything before we can really benefit from multicore processors.
blog comments powered by Disqus