We all know that complexities in design and shrinking time-to-market windows are driving up design and verification costs. More and more, engineers are turning to hardware platforms for their quest to verify their designs on time. Hardware platforms such as FPGA prototyping are growing in popularity due to their relative low expense and ability to test system designs at speed versus simulation which is too slow and often can't provide an accurate assessment of design behavior. FPGA prototyping has often been typecast as a solution used solely for small designs late in the verification process just before the software development stage, with concerns that the difficulties of employing prototyping across multiple FPGAs have outweighed the cost and speed benefits of implementation for large designs. Emulation has been the choice for verifying large designs because of its capacity, but it too has limitations.
The truth is that today's FPGA-based prototyping advancements are breaking that restrictive notion. Innovative hardware and the addition of cutting-edge software have made it possible to realize the benefits of FPGA prototyping not only for system validation and software development, but also much earlier and throughout the design and verification flow as well as for extremely large designs.
FPGA-based prototyping is well suited for even the largest designs. Today's leading-edge FPGAs (Xilinx Virtex UltraScale+ VU19P, and Intel Stratix GX 10M) have usable logic capacities of up to about 50 million equivalent ASIC gates per FPGA. These increases in capacity have not affected FPGA prototyping speed and costs relative to emulation; it's still much faster and cheaper than emulation. To figure out if FPGA-based prototyping is the optimal choice for your design and verification flow, you should ask yourself these questions.
To answer this question, you should analyze the importance and complexities of your design's functionality. As mentioned earlier, simulation can only get you so far when dealing with complex device behavior. Deep and accurate assessment can't be achieved simply through simulation no matter how many regressions are done. Confidence in a design can often times only be achieved through the ability to test it in real-time scenarios especially for designs heavily dependent on timing accuracy.
Many applications need to be tested in real time or close to real time to assess the quality of the design. Examples of this are Video and Audio applications. In addition, some designs require real-world testing involving outside environments, noise, or interfacing with 3rd party designs and infrastructures.
As your design stabilizes and matures, validating the software components come into play. At this stage, emulation and prototyping have distinct advantages. If you need to get your model up and running quickly with only the need to run a few tests, then emulation is ripe for your application. Emulation may only need a few hours to set up and get going, while an FPGA prototype can take weeks. However, if the number of tests you need to perform are more significant and you need faster performance for software development and compatibility, testing, then FPGA prototyping might serve your needs better. Although it may take much longer to set up, FPGA prototyping is unarguably much faster than emulation.
Given these speed differences, the point of performance/testing crossover between these two solutions is strikingly short (even with FPGA prototyping's long set up time) and the performance gap grows dramatically thereafter. The difference in performance is particularly steep when prototype replicates (copies) are used in parallel. The cost advantage that FPGA-based prototypes enjoy – typically 5 to 1 – allows multiple platforms to be deployed, thereby accelerating overall performance. Therefore, you can complete exponentially more tests in a shorter amount of time when using FPGA prototyping.
A simplistic view is that emulation is expensive when compared to FPGA prototyping. However, a deeper analysis of this idea is merited. Most companies can afford to implement a few emulators for early design verification, but when implementing for a large number of replicates for software development and compatibility testing, the costs of emulation soar. As mentioned in the answer to question 2, the cost advantage of FPGA prototyping is 5 to 1 compared to emulation for even faster and more cost-effective performance.
There's no arguing against the tried-and-true methodology of emulation. The inherent strengths of emulators are well-suited to system integration efforts and rigorous verification testing. In fact, the direct results of performing emulation are designs that stabilize and mature more quickly. This in turn precipitates a shift from verifying hardware elements to validating software components.
When this change in focus occurs, FPGA-based prototypes become the natural platform to pick up the pace of validation and further drive software development. Performance crossover analysis serves as an aid in determining when to make that shift, and why. Ultimately, this is a powerful demonstration of how emulation and FPGA-based prototypes are complementary tools – not despite a performance crossover, but because of it.