Multiprocessing Made Easy Through MIT Breakthrough

Computers have become a much more desirable item ever since the concept of multicore processors hit the market. Having small supercomputers lined up and waiting for your commands make you look like the general who is commanding his army to war, the electronic war. But the main problem with multicore processors wasn't tied to their design, or features, but it was closely related to the software support, which is supposed to "talk" to each core of the processor.

The software support has been an issue that processor manufacturers have taken very seriously and released different programs that help developers create compatible games and other software products for multicore processors. But that was never enough, because the software, once written for a single core processor, for it to be rewritten to support multicore processors meant basically rewriting almost everything. Some time ago I've discussed about a concept I've thought of, making the processor handle each individual thread, instead of leaving the job for the software program or game.

Seems MIT had the same idea, and have been working on a resolution for this problem; the end result is called StreamIt. It has to do with the way software developers use parallel programming to write code for multiple cores. "Creating software is still something a lot of people can do, but if they had to deal with parallelism, it becomes much more difficult" said Saman Amarasinghe, a professor of electrical engineering and computer science at MIT and the developer of StreamIt. To make it simple, when a program "talks" to a processor, it does it by using a sequential pattern; when that same software has to talk to multiple cores, tasks get split among cores, and it is required that the tasks have a careful synchronization so that they don't create errors in the program. That in itself is a major problem, and gets even worse when having more than one program running on your multicore processor.

What Amarasinghe did was to take the concept of data flow "in which data is streamed sequentially through a sort of pipeline of functions" and apply it to multicore processors. The necessary tools for this job were a programming language and a compiler, which were developed by the same man, and basically take away the parallelism of the multiple cores and run threads of information to each core, depending on how many programs are running. That is, one program running, information goes to core 1, 2 programs running, first program goes to first core, second program to second core, a.s.o. This way it's no longer the programmer's job to write code for multiple core, but for single core, and StreamIt takes care of the rest for them. I'm glad that this happened because now, after some good time, having a multicore processor means actually benefiting of all of those cores in normal, day to day applications, such as listening to music while browsing the Internet, or working with multiple documents, spreadsheets and pictures, not by looking at some benchmark specially designed to fit multicore processors, and say "well, it scores better than that other multicore processor by 2000 points, that's a 20% performance increase".