Virtual platforms, especially those using Open Virtual Platforms (OVP), are valuable tools for hardware and software development. They provide an environment for running software earlier in the development cycle, or when using real hardware is not an option. They also provide more precise control and visibility into the target hardware, which allows for many other capabilities, including advanced debugging, and automated testing and verification.
Posedge Software posesses skills and knowledge needed to take full advantage of these virtual platforms and implement cutting-edge solutions, including:
- Modeling and simulation of hardware including processors, peripherals, and buses at various abstraction levels
- Embedded software, including compilation tools, debuggers, and target operating systems
- Electronic design automation tools and languages such as C/C++/SystemC (including TLM2.0), along with verification methodologies
Posedge Software provides a variety of services relating to Virtual Platforms
- Virtualizing Hardware
- Booting the target OS
- Running the target application
- Analyzing Software Execution
- Testing and Verification
There are many benefits to using virtual instead of real hardware. One of the big advantages is that software testing and other tasks can be done earlier in the development cycle, before hardware is available or even while the design is still being finalized. Even if hardware is available, with virtualization a development platform can be made available to more developers, at a lower cost. Implementing a virtual platform may require modeling of processors and peripherals, and combining these and other IP into a working platform. This can be done using APIs available with OVP, or by using languages such as SystemC and TLM2.
Once a platform is available, it may be necessary to run an operating system or other core software on it. This initial booting up of the system can be a time consuming process, often requiring patching and recompiling of the kernel. Virtualization eases this process by providing more visibility into the running system, even when fatal errors occur. Several mechanisms are available in the OVP models, such as callbacks and intercepts, to assist with this. Booting an operating system also requires execution of a significant amount of code. Having fast simulation models can significantly improve productivity.
At some point in the development cycle, testing is performed on the target application. This may be running individual unit tests on each module, or running the entire system-wide application. Having increased visibility into, and control of, the platform greatly assists with this. Assertions or other checks can be added to the platform to monitor for significant events without modifying the source code. If a problem is encountered, additional debugging capabilities are available that could not be done on real hardware, even with using JTAG or other mechanisms.
Tests are written to check that the software is giving the correct results. However, other metrics may be needed to verify the software is correct and sufficient testing has been done. Coverage, profiling, or other performance tests are often used. While it is usually difficult to gather this information without recompiling or making other changes to the software, with virtual platforms this can be done transparently, without making any modifications to the target software.
In the hardware world, a number of tools and languages have been developed specifically for testing verification. They provide features such as automated running of tests, constrained-random generation, and coverage-driven verification. With virtual platforms, some of these tools and methodologies can be used for software and the system as a whole. This includes techniques such as co-verification, where hardware and software are tested together to check that they are interacting correctly, which can test orner cases that would be difficult, if not impossible, to test otherwise. High performance virtual platforms also allow for system verification, where the complete stack of software can be executed, instead of just testing individual applications and sections of code. The combination of virtualization technology and hardware verification methodology results in a robust, flexible verification environment needed to handle the complexity of current and future software projects.