When designing complex ASICs, such as a highly-integrated system-on-chip (SoC), engineers are highly motivated to perform comprehensive verification under as real-world operating conditions as possible to ensure that bugs can be identified and corrected before final tapeout. The source of the motivation, of course, is the high-cost and time required to re-spin an ASIC.
While discovering and tracking down the root cause of bugs can be challenging in the best of circumstances, inherent limitations in the various technologies available to ASIC designers for verification testing make the job much harder as each involves a variety of tradeoffs. Now, however, new technologies are emerging that offer the promise of much more efficient and less time intensive debug processes using FPGA prototypes.
A SoC consists of both hardware and software controlling the microcontroller, microprocessor or DSP cores, peripherals and interfaces. The design flow for a SoC aims to develop the hardware and software in parallel. Most SoCs are developed from pre-qualified hardware blocks for the hardware elements, together with software drivers that control their operation. Also important are protocol stacks that drive industry-standard interfaces like USB or PCI Express. The hardware blocks are put together using EDA tools while the software modules are integrated using a software development environment.
In order to debug the SoC, all these various pieces need to be pulled together into a functional unit and tested extensively. When this functional verification turns up bugs, the root causes need to be tracked down and either fixed, or a work around needs to be developed. Further, if time permits, it can be useful to conduct optimization testing to identify and correct performance bottlenecks in the design. Core requirements for optimal SoC debugging include:
- Full RTL-level visibility with minimal dependence on FPGA CAD flows
- Fast, efficient identification of the root cause of bugs
- Run at full speed to enable verification with real-world signals
- Time-correlated signals across different clock domains
- Scale seamlessly to support large, complex designs
- Enable efficient debugging of firmware and application-level software
- Verify hardware and software interactions at the system-level
ASIC prototyping approaches and tradeoffs
The three main approaches traditionally used to verify and debug both hardware and software for SoC designs are simulation acceleration, emulation and FPGA-based prototyping technology. To date, all three fail to meet all the requirements outlined above for ASIC debugging.
With high capacity and fast compilation time, acceleration and emulation are powerful technologies that provide wide visibility into systems. Both technologies, however, operate slowly, on the order of MHz, which may be significantly slower – up to 100X slower – than the ASIC’s operating frequency. As a result, emulators and accelerators cannot use real-world stimulus for testing without creating specialized interface circuits. Nor are they feasible for developing a system’s software. For instance, at the rate of 100X slower, emulating a system running for 15 minutes of real-time would take more than 24 hours. Acceleration and emulation boxes are also very large and expensive ($1M+) and thus beyond the means of many chip manufacturers.
FPGA-based prototyping platforms use FPGAs directly to enable engineers to validate and test at, or close to, a system’s full operating frequency with real-world stimulus. FPGA-based prototypes are small enough to be portable and used at an engineer’s desk. They are also much less expensive than emulators or accelerators, on the order of $75K. Given these advantages, it’s no wonder that about 80 percent of all ASICs and SoCs are prototyped in FPGAs.
But that doesn’t mean that FPGAs are the ideal platform either. Some teams use an emulator in addition to building up an FPGA prototype. That may be changing.