Dual-Core... Quad-Core... what's next?

By Juergen Jaeger, Director of Channel Marketing - DCS Division, Mentor Ggraphics Corporation

Faster processors, multi-core CPUs, and smarter CPU architectures provide more compute power, better performance, and more capabilities for embedded systems—despite the demand for less power and smaller form factors. Yet all of these advances are more or less gradual and evolutionary improvements. The question remains: How can we take the next revolutionary step forward? How can we not just double the performance of an embedded system, but rather improve it by an order of magnitude or two?

Remember the times of the 80286 and 80386 processors? Back then, we were "helping" the CPU through the use of co-processors, arithmetic co-processors, and graphics co-processors that have now morphed into GPUs. Today, there's a technology out there that lends itself in an ideal way to becoming the next generation of "co-processor" within embedded systems: the field-programmable gate array (FPGA). FPGAs have come a long way since their introduction in the early 1990s. They went from containing just a few hundred gates and being used for simple glue-logic to holding several million (ASIC) gates. Although FPGAs can be found on many of today's embedded boards, they usually do pretty mundane and boring things. We don't even begin to tap into their real potential.

Of special interest in the context of embedded processing is the ability of FPGAs to implement and execute tasks in parallel that are typically executed sequentially. This in itself boosts performance by more than an order of magnitude. It also offloads the CPU, freeing it up to do other things or use a smaller and cheaper CPU in the embedded system. The CPU has enough things to do in today's embedded systems with operating systems getting more demanding, more protocols to be dealt with, and more applications running concurrently.

Just how much performance and compute horsepower can an FPGA provide? To answer that, let's look at an area in which FPGAs are currently utilized widely to support—and in some cases replace—processors. In digital-signal-processing (DSP) applications, performance is commonly measured and compared by multiply/accumulate operations per second (MMACs). In the early 1990s, DSPs and FPGAs were capable of executing a little over 30 MMACs per second. They were on par. Over the years, however, a dramatic gap has opened up. In 2007, DSPs are able to execute over 15,000 MMACs per second—a 500X increase in performance since the early 1990s. On the other hand, FPGAs can perform over 500,000 MMACs per second—an increase of 16,000X over the same period of time. In other words, today's FPGAs outperform processors by a factor of 33 for certain tasks and that gap is widening.

Chances are, your embedded system already contains one or more FPGAs. So let's put that FPGA to work. Taking applicable software routines and algorithms from the CPU and implementing them in hardware in the FPGA will result in:

  • Significantly increased performance
  • Smaller form factor
  • Power savings
  • Cost reduction
  • Increased reliability

This sounds too good to be true, doesn't it? Of course, there are some challenges. To take advantage of FPGAs for offloading a conventional processor, for example, a bit of a methodology adaption is required. An FPGA is not a processor. One cannot download a software program in an FPGA or treat an FPGA like a processor. An FPGA is a very flexible and configurable piece of digital hardware. There has to be up-front software/hardware partitioning to decide what goes into the processor (as software) and what algorithms can be implemented in hardware in the FPGA. That step requires a bit of a different approach to system design and of course some advanced tools to help in architecting the system. Luckily, all of the tools—like HW/SW performance analysis and optimization, C(++)-to-RTL synthesis, system verification, and so on—are readily available. They might not be commonly used for embedded-systems design today. But then, there's always a first for everything.