If you read last week's blog, you know that some corners of the DSP world are overly enthusiastic about FPGAs. At the same time, many DSP engineers have overly negative views of FPGAs. For the most part, these negative views seem to have three main themes. Let's take a quick look at these ideas:
FPGAs are expensive. In the past, FPGAs commanded a huge price premium over DSPs. FPGAs capable of serious signal processing cost hundreds or even thousands of dollars. While you can still find pricey FPGAs, you can also buy a DSP-capable FPGA for less than $10. Examples include the Xilinx Spartan-3 and Altera Cyclone-II. (Be warned that pricing FPGAs is tricky business, as noted in this article on the Lattice ECP2, another low-cost, DSP-capable FPGA.)
FPGAs are power-hungry. In the past, this was unambiguously true. Today, this has become a question of context. If your application offers limited opportunities for parallelism, an FPGA is probably a bad choice (see my last blog). But if you can take advantage of the massive parallelism available in an FPGA, then an FPGA may well draw less power than a DSP. Why? From a power perspective, it is always to better to maximize parallelism and minimize clock rates —and this is exactly what an FPGA lets you do. It's also important to remember that off-chip communications often constitute the bulk of power consumption. If you can replace multiple DSPs with a single FPGA, you will reduce off-chip communications, thus improving your power consumption.
It's also worth noting that FPGA vendors are increasingly focused on power consumption. For example, the just-announced Altera Stratix III allows logic blocks to be individually configured for either high speed or low power. Advances are helping FPGAs overcome their past power woes.
FPGAs are hard to program. Again, this is a matter of context. If you evaluate the standard tool flows for FPGAs and DSPs, you will conclude that FPGAs are much harder to program. However, there are many ways to program FPGAs. Vendors like Celoxica offer tools that let you program FPGAs in C, and you can also program FPGAs using block-diagram-based languages such as Simulink. The main drawback to these tools is that they produce inefficient implementations, but this may be less of a problem than you think—particularly when you compare it to the problems of programming a DSP in C.
In short, FPGAs may not be the right solution for every application, but they are much better than they used to be. If it's been a while since you last considered using FPGAs, it may be time to take another look.