The era of exponential improvement of processor performance without any
programmer effort is over. Multicores put the onus of taking advantage of
Moore's law on the programmers. While architects have known how to build
parallel processors for over a half a century, programmers' inability to
create scalable parallel programs has been the main stumbling block in
mainstream use of parallelism. In the first part of the talk I will discuss
the path to multicores, address why scalable parallel programming has been
such a difficult problem to solve and speculate on our ability to crack it
this time around.

Next I will discuss, the Petabricks Project, which attempts to alleviate
part of this heavy burden we are placing on programmers. For a multicore
application to keep-up with the exponential growth of Moore's Law requires
the algorithms in the application to efficiently scale from small to large
numbers of cores. It is observed that for a given problem, different
algorithms provide the best solution at different levels of parallelism.
However, currently there is no simple way for the programmer to express or
the compiler to take advantage of all the available algorithmic choices for
a problem. PetaBricks is a new implicitly parallel language and compiler
where having multiple implementations of multiple algorithms to solve a
problem is the natural way of programming.  The PetaBricks compiler
autotunes programs by making the best fine-grained algorithmic choices.
Choices also include different automatic parallelization techniques, data
distributions, algorithmic parameters, transformations, and blocking.