High-performance cars and FPGAs? -- More in common than you think

The 1960s and early 1970s are considered the "muscle car" era. This began with the introduction of large engines into mid-range car designs. The most famous examples include Chevelles, Fairlanes, GTOs, 442s, Chargers, and Roadrunners. During this same period, the Ford Mustang began to develop into a "pony car," which soon attracted competition such as the Camaro, Firebird, Barracuda, AMX, and Challenger. Engine size was expressed in cubic inches, and it was obvious to see the engine on the car. Numbers such as "396," "429," "440," or "455" indicated a level of performance.

The most legendary of these engines is the 426 Hemi. This engine has evolved into the first, second, third and fourth generations since its introduction in 1964, and became famous after NASCAR restricted it. From 1966 until 1971, meeting NASCAR's approval terms, or product quality manufacturing requirements, led to the famous "Street Hemi" being introduced on some Dodges and Plymouths.

The Hemi engine displaced 7 liters, used high-revving cylinders, and was topped by two basketball-sized 4-barrel carburetors, with a very conservative 425 hp rating. Few cars could match the Hemi-powered Cudas and Challengers; perhaps only the 427 Corvette could match it.

The muscle car era continues to this day, with a more limited selection of models. The prices are acceptable, and most consumers can afford a Camaro, Mustang, Corvette, Challenger, or Charger, which have V8 engines that reach 400+ hp, with 600-700 hp engines available as other options.

Today's FPGA manufacturers are engaged in similar competition, which is very good for FPGA customers. In the past few years, logic density, memory capacity, DSP blocks, transceiver speed and quantity, and almost all performance indicators have been increasing. Of course, readers are not unfamiliar with this.

One comparison is how these performances are achieved, that is, the connection between theory and practice. Back in the early days of muscle cars, there were both manual and automatic transmissions. The dedicated enthusiasts chose the manual transmission. In the hands of a good driver, the 4-speed manual transmission is obviously better than the inefficient 3-speed automatic transmission. The manual transmission is also more fuel-efficient, but that was not a big deal back then.

With modern muscle cars, however, the opposite is true. Automatics use electronic controls instead of hydraulics, and shift speeds are on the order of 100-200ms, much faster than a human can, as is rev matching. Electronic controls help the driver prevent wheel spin. Paddle shifters are included for selecting your own gear, although this hardly improves performance. Automatics are also now fuel-efficient, which is important today. The relative number of gears is now reversed. For example, the current Dodge Challenger has an 8-speed automatic and a 6-speed manual. Of course, many purists still prefer manual gears, both for tradition and the direct feel of manual shifting. But it's no longer about improving performance.

For FPGAs, the same trend has occurred, but it is not as well known. Traditionally, FPGAs are programmed manually in Verilog or VHDL, using fixed-point (integer) numbers, and the programmer decides the underlying implementation, such as when to insert pipeline registers, etc. Even if the synthesis and adapter tools fully automate the design, the quality of the final design depends largely on the skill level of the FPGA programmer.

New FPGA architectures are beginning to change this. For example, Altera Arria 10 FPGAs now have single-precision floating-point engines built into thousands of DSP blocks. With floating point, FPGA programmers no longer have to determine bit widths, truncation, and saturation levels after each digital operation, greatly simplifying the programming task. Floating-point number representation and implementation do this automatically. Integers are now reserved for common functions such as loop counts, state machines, and memory indexes. This establishes a direct path between algorithm simulation and implementation, maintaining consistency between system and FPGA engineers.

Supporting the implementation of these features using traditional Verilog and VHDL design flows will continue to dominate the FPGA design flow. However, there are other design flows. OpenCL is the language of GP-GPU programmers, now optimized for FPGAs, providing a true "push-button" compile experience.

With Model-Based Design, designers can remain in the Mathworks environment and still achieve the best results, as evidenced by many complex, high-throughput reference designs.

Similar to manual transmission, FPGA designers can still choose to design and optimize as before, and traditional designs will work as before. However, FPGA designers will find that new automatic methods can achieve the same or even better results. Moreover, with the rapid growth of logic density, many engineers will find that they do not have enough time to manually optimize large-scale FPGA designs as before. Just like a high-performance muscle car, in the FPGA world, it is time to start taking advantage of automation.