Today, developers are using software to implement an increasingly large portion of electronics systems. This shift in focus means that the software component of electronic systems now dominates the cost and the schedule—especially the schedule risk— of every project.
The challenge lies in the fact that software code must be meticulously tested during the debugging and test phases of development, preferably on an accurate version of the hardware it eventually will be run on. But testing on the appropriate hardware isn’t always a viable option. For instance, the hardware might not exist yet. So, software developers have turned to three main approaches when developing and testing code.
The first method involves running the software on a PC on top of specially created test scaffolding. The hope is that the software for a MIPS-based set-top box, for example, will run the same on the real hardware functioning with a real-time operating system as it will on an x86 processor with different operating-system calls. The imprecision of this method becomes evident when the hardware/software system integration phase drags out unacceptably long and the system is late to market.
The second approach entails running the software under development on either the real hardware or some approximation of it, usually involving FPGAs. The major challenge to this method is that, at the very least, the hardware design must have progressed far enough that there is a reference design that can be used to program the FPGAs.
This approach is expensive and unwieldy. Large system companies have rooms full of racks of test equipment costing tens, if not hundreds, of millions of dollars. Furthermore, maintaining and upgrading the hardware to reflect real-system networks means that large companies must continue to allocate a tremendous annual budget to capital expenses.
More and more, developers are turning to a third method as the most effective means to debug and test software. Virtualized software development enables developers to build a software model of the hardware that can run on any other host hardware. Now, software developers can use virtualized software development on a commodity-level PC in place of unmanageable and unaffordable hardware.
The concept is to create a virtual model of the whole system using component models of the processors and devices that are used in the hardware. These models are so accurate that the software is unable to detect that it is running on a software model and not on the real hardware. Developers can model the device registers just like the real hardware, and the device driver software will run unchanged.
Recent improvements in the technology underlying virtualized software development make performance high enough to satisfy the most demanding software developers. The most obvious benefit of virtualized software development is the ability to develop software before physical hardware is available. With virtualized software development, all engineers can develop on their own simulated system.
But even once physical hardware shows up, virtualized software development has compelling advantages in test and debug productivity that continue to shorten time-to-market and improve product quality. By integrating the entire system early and often, the unpredictable system-integration phase of development becomes short and simple.
The most compelling benefits to virtualized software development are the increased quality, performance, and reliability of the end product. During the test and debug cycle, developers using virtualized software development have complete, non-intrusive control and visibility of their software running on a simulated model. They can inject arbitrary faults into the system and test, save, and recreate any scenario. This ability to control every aspect of testing and debugging ensures a high-quality end product for the consumer. Developers can even run time backward, making it easy to find the deepest and subtlest bugs.
Software must move into a virtual environment where everything is deterministic, everything can be seen, everything can be controlled, and unusual stresses can be imposed. Virtualized software development successfully and simultaneously delivers unheralded benefits for all three major factors affecting end-product value—cost efficiency, time-to-market reductions, and higher product quality—to deliver solid code with low schedule risk.