John Williams – Multicore vs. FPGAs

FPGAs, or Field Programmable Gate Arrays, are essentially arrays of primitive digital logic resources which can be configured and connected in a huge variety of ways, to implement arbitrary digital logic functions.

Starting out life as humble glue logic, FPGAs are now large and fast enough to implement sophisticated digital systems, across a wide spectrum of architectures and applications.  From complex System-on-Chip designs, cryptographic processors, computational engines and massively parallel DSP and image processing machines, any application which can make use of the massive bit-level parallelism inherent in modern FPGA architectures is a candidate for development on this platform.

In spite of this potential, the use of FPGAs as computational accelerators to conventional computing architectures remains relatively limited.  The so-called “productivity gap” between the resources offered by modern devices vs designers’ abilities to actually make use of them, is one such reason.  Hardware circuits were traditionally designed at a very low level of abstraction, which is just not feasible for 1 million-plus gates.  High level design tools and component based re-use are two approaches to tackle this issue.

Finally there are practical issues such as bandwidth mismatches between CPUs, system memory, backplanes and FPGA devices themselves.

Looking at the world of multicore, it is tempting to draw parallels. There is no shortage of multicore architectures, with impressive specifications at all scales from embedded through to supercomputer.

The problem seems to be in actually writing software to use them. Generations of software developers have grown up in a strict single-core, Von Neumann framework, and are now struggling with the parallel thinking required to make efficient use of multicore architectures.  This is the “productivity gap” all over again.

Other analogies exist – for example the problem of automatically generating (efficient) hardware circuits from high level specifications such as C code, is more or less identical to the problem of automatic parallelisation of single-threaded code for multicore execution.  In both communities, similar approaches have been proposed – for example functional programming and its side-effect free semantics offers a good mapping to both FPGA and multicore implementations.  Unfortunately, they remain relatively obscure.

In this talk I will attempt to bring the audience up to speed with the basics of FPGA-based computing, talk about some of the ongoing research on the FPGA side, and hopefully stimulate discussion on ways that the parallels between these technologies might be fruitfully exploited.