A look at using end-to-end prototyping to ease architecture development, hardware/software integration, and system validation in SoC designs
The growing influence of software in end applications is changing SoC design, impacting the software development, architectural exploration and IP bring-up processes, because of a number of mutual dependencies:
- Software is increasingly dependent on the underlying hardware, so its developers need an embedded-software development target that accurately represents the final device to work with.
- Complex IP depends on software, which needs to be available during IP integration and test.
- SoC architects need embedded software to explore trade-offs between power and performance in a variety of use cases.
- Semiconductor companies need to give OEMs something that enables them to get started on software development before the chips are ready.
- OEMs need to offer semiconductor companies insights into their application’s software workload, power and performance requirements, as part of the spec for a new SoC.
Types of prototyping
There are various approaches to prototyping that can help bring forward the moment when software developers can start work, and reduce the impact of the dependencies listed above on the overall design and validation time for an SoC project. These include:
- Virtual prototypes, which are fast, executable models of the SoC, usually created from models delivered by semiconductor IP companies and extended with models created for the SoC in development. Different types of virtual prototypes are created for architecture design and software development.
- Physical prototypes, using FPGA-based systems and tools, to execute RTL at high enough speeds to be useful for system-validation and software-development purposes.
- Hybrid prototypes, which combine virtual and physical prototypes to give users a way to optimize their prototyping set-up based on model and RTL availability, and expected use cases.
- All three are usually developed by a dedicated team that specializes in providing prototypes to end users.
Application to SoC design
These three approaches can be applied at various stages of SoC design, although the biggest impact comes when prototyping is applied throughout the process.
Architect teams often work on the next-plus-one (n+2) design in a series while the current (n) SoC design is in development. They can make the most of their previous experience by using virtual prototyping to explore how their decisions affect a design’s performance and power consumption.
To do this, SoC architects need performance models, power models, and software scenarios.
- Performance models describe critical components of the SoC, such as the interconnect and memory subsystems, with enough accuracy to enable the architect to make critical design decisions based on the latency and throughput data they provide when simulated.
- Power models are needed to analyze the expected power consumption of the main functions on the SoC, and rely on a combination of power-modeling standards, power consumption data from IP datasheets, and measurements derived previous projects.
- Software scenarios, often described at an abstract level as an application model (also called task graph), help architect understand the impact of the code that will run on the SoC. Virtual prototyping can either, automatically extract the task graphs from software execution on a prior prototype for CPU software, or be used by the architect to manually capture task graphs for GPU, DSP or accelerators.
Using these three forms of models enables architects to explore more alternatives, with greater accuracy than a static spreadsheet allows.
Software development and testing
Prototyping can have the greatest impact on the software-development schedule, because it enables teams to start work on software earlier in the design process, and exposes dependencies between hardware and software much sooner.
The advent of large commercial FPGA-based physical prototyping systems that integrate both hardware and software tools is helping to deliver physical prototypes more quickly.
The availability of larger FPGAs is making it possible to physically prototype much larger portions of the SoC, including GPUs, which also helps accelerate the software development process.
Virtual prototypes, based on high-level models, don’t rely on the availability of RTL and so can help shift software development much earlier in the design cycle. Using such models can give much better debug visibility than is possible with physical prototypes, and enables detailed fault injection scenarios to test how the system will react. They can also scale more easily, to enable massively parallel testing and therefore better software quality.
Hybrid prototypes, combining virtual and physical prototyping environments, are useful for developing IP-specific software. Using early models for new processor cores in a virtual prototyping environment, linked to IP mapped onto an FPGA in a physical prototyping environment, can offer an early and functionally complete environment in which to develop IP-specific software, test it and undertake hardware/software integration.
Figure 1 Example DesignWare hybrid IP prototyping kit (Source: Synopsys)
Hardware/software integration usually starts at the subsystem level on an FPGA-based prototype, when relatively stable RTL IP blocks or subsystems are integrated with firmware or drivers. This can be done more quickly if virtual or hybrid prototypes have been used during software development, so that it is more or less functionally complete by the time of the hardware/software integration step.
Finding a hardware bug during integration is hard, and is typically influenced by the ability to capture many hardware signals during execution, analyze the hardware signals in a hardware debugger, then fix a bug and rapidly turn around a prototype for the next test run.
Integrated FPGA- based prototyping systems have trace buffers and supporting tools that enable users to specify which signals should be collected from across a multi-board prototype.
Performing hardware/software integration from the bottom up, subsystem by subsystem, is the best way to parallelize the effort and to save time and cost before the top level integration is attempted.
System validation explores how an SoC, with its software stack, will work in its target environment, by plugging a physical prototype into a real-world environment. Examples include testing whether a networking SoC works in an actual networking device when running at tens of megahertz; or validating the implementation of interface protocols, such as USB, on an application processor SoC.
System validation ensures that standards are met, and can also be used to check whether the real SoC will meet its performance goals. System validation also gives the design team the opportunity to run millions of cycles of a design and opens up opportunity for the real world I/O to trigger behavior within the SoC hardware or software that would otherwise have been overlooked.
How do you choose which approach to prototyping will offer the greatest advantages in your situation?
If prototyping is meant to speed up the overall design process, than the amount of time it takes to build the prototype is obviously critical to the whole endeavour. This means considering the effectiveness of the tools needed to build the prototype, and the availability of ready-to-use models or pre-prototyped RTL IP. Some IP vendors are now providing pre-validated IP prototyping kits to help users get started.
It’s also useful to have tools that provide control and visibility into the prototype and the software running on it, to cut debug time.
To return to our original premise, one of the most important reasons for using prototyping is to make it easier to start work on the software sooner, and therefore reduce the impact of its central role in modern SoC development processes. Building an end-to-end prototyping strategy can help enable a number of useful links between subtasks, as follows:
Architecture design vs software development
Architects need accurate application data to develop the next-plus-one (n+2) version of an SoC currently in development. This data can be derived from a virtual prototype based on a functional model that is being used for software development of the n and n+1 generation devices. The ability to derive a task graph from the application software and then apply it to the development of the n+2 device creates extra value from an end-to-end prototyping approach that uses virtual prototyping for both software development and architecture exploration.
Figure 2 Task graph generation from software (Source: Synopsys)
The ability to perform architecture exploration using transaction-level models and application data from existing software also enables better collaboration between the semiconductor vendor and their OEMs. OEMs can use a virtual prototype to simulate their application and provide feedback to the SoC vendor, as a task graph that provides real application data without exposing details of the code.
Another important gain from end-to-end prototyping is the opportunity to use IP power models in both the virtual prototypes for architecture design and software development. Power models combined with performance models enable power and performance optimizations to be done as part of architecture design. Used with fast functional models, they can accelerate power-aware development and the bring-up of power-management software.
Software development and testing vs hardware/software integration
It is easier and quicker to integrate hardware and software when the software has already been developed and tested using virtual, physical or hybrid prototypes. Parallelizing hardware and software development so that they are only integrated when they reach the right level of maturity saves time and effort compared to an approach that brings new software to a full SoC design – which introduces too many unknowns at once and is much harder to debug.
Software development and testing vs system validation prototyping
System validation is critical to ensure that an SoC and its software is tested in its target environment, and is best done using FPGA-based prototypes. Using virtual prototypes to start software development even earlier also helps accelerate the overall development process. Therefore, combining the two approaches in a hybrid-prototyping strategy should lead to greater product quality.
A hybrid prototype offers the opportunity to use the virtual-prototype portion of the set-up as an early target with superior debug control and visibility, alongside the real-world I/O capabilities of a physical prototype, to speed up both software development and system validation.
Hybrid prototypes can also be used to integrate legacy or hard-to-model components, such as a GPU, into a virtual prototype as a new subsystem, so that the entire hardware-dependent software stack necessary to validate the system and release a new SoC can be exercised.
Combining these prototyping technologies, and the synergies between them discussed here, in an end-to- end prototyping solution can help cut overall design time and improve the quality of the final product through earlier, and more effective, co-optimization of hardware and software. Applying these techniques can help development teams address shrinking development cycles even as the software content of SoCs rises rapidly.
Tom De Schutter, director, product marketing, is responsible for driving the physical prototyping business at Synopsys. He joined Synopsys through the acquisition of CoWare where he was the product marketing manager for transaction-level models. He was the editor for the Better Software. Faster! Best Practices in Virtual Prototyping book. Tom has over 15 years of experience in prototyping through different marketing and engineering roles.