Michel Genard (01/07/2008 9:00 AM EST) 
Software development is a fascinating industry that has changed over the years as developers have continually adopted newer programming languages, from Fortran to Pascal to C++ and beyond. But although developers readily look to software itself to drive innovation, few have considered their development infrastructure a possible vehicle for change. With the advent of virtualization in the development process, that’s about to change.
When the first embedded devices appeared, software as we know it today simply did not exist; all functionality was built into hardware. With the introduction of the microprocessor, software content emerged but still comprised only a small part of the overall system. Over the past twenty years, the embedded industry has witnessed a complete shift as software has exploded in size and complexity. Today, software is the primary driver of increased functionality and innovation in embedded systems.
Although hardware design has enjoyed significant investments in tools and process development, software development processes have remained essentially static since the 1980s. The hardware industry is aided by well-defined standards and processes, but software development methods have not kept pace, leaving programmers to approach software development entirely ad hoc.
The consequences of this lack of an underlying software development infrastructure are all too familiar: cost overruns, missed schedules and poor-quality software. The current approach to software development sees two-thirds of projects late to market, one third over budget, and nearly half of embedded designs canceled. Even the allocation of additional resources to a job or the rescoping of a product’s features doesn’t keep software developers from consistently hitting walls.
Why does this staggering disconnect exist in the world of embedded programs? Why is software development stagnant even as designs grow more and more complex? This is an issue neither of people nor of components. Rather, it is caused by the absence of a strategic development infrastructure thoughtfully designed to aid software development.
An embedded device today is typically built from the ground up, starting in hardware and ending in software. The process is very sequential, beginning with hardware designed around certain expectations regarding memory, MIPS, interface, connectivity, and so on. Multiple components are pulled together to build up a hardware system, and it is on top of this that software is developed. This hardware-centric, bottom-up approach involves multiple steps and introduces multiple dependencies, and only after the system integration phase, when the software is actually running on the platform, can the system be understood from a performance point of view. (Contrast this with an SOA approach, which maps out necessary services before designing an infrastructure to support them.)
The chief weakness of a bottom-up development approach is that it treats software as an afterthought in the design process, even though an increasing amount of system functionality depends on software, not hardware. Integration occurs very late in the game, making it difficult to discover (much less fix) bugs introduced by the hardware, design or architecture. In many cases, developers are forced to rethink their designs to the detraction of both schedules and budgets.
As software complexity reaches new heights and solid programs prove the biggest hurdle to shipping, the inefficiency and impracticality of the hardware-centric approach is becoming increasingly evident. How can developers strategically rethink their development approach so that they are no longer at the mercy of hardware? How can software development at the system level begin earlier in the design process? This is where virtualization comes in.
Precursors of virtualization
Virtualization has been used in the development of embedded devices for several years both as a replacement for actual hardware and as a designing and debugging platform for complex systems. In the hardware design industry, simulation has been employed at both the socket and PCB level. Whether designing processors, PCBs or SOCs, hardware developers can use simulation tools from the likes of Mentor, Cadence and Synposys to model and predict the behavior of their systems without having to wait for the development of the actual physical systems.
Outside of the world of embedded devices, we’ve seen a number of industries successfully employ virtualization after hitting walls when using traditional approaches. Over the past two years, server virtualization has made great inroads by improving data center efficiency and lowering overall ownership costs. Virtualization has solved such persistent challenges as server proliferation, CPU underutilization and application isolation.
Simulation has also been employed by a number of industries, such as aerospace and defense, in their own software development. Often, these industries require such complex designs that waiting a year or more for hardware isn’t feasible. Simulations have been developed internally as point solutions, design complexity essentially mandating that these companies invest resources in internally developing virtualized software development solutions.
The embedded software development industry is now at a point where neither traditional, hardware-centric development approaches nor internal, one-off virtualized software development solutions can deliver the time-to-market, cost-saving and quality-assurance benefits that are a must in such a competitive market. The role of software content in embedded devices shows no signs of diminishing, and the proliferation of multicore devices adds an unprecedented complexity into the mix both in hardware and software. The inevitable move toward multicore designs has only highlighted the need for software development solutions that can harness the performance potential of multicore devices.
The current state of embedded software development has made it necessary for companies to strategically revisit and rethink their processes not only at the component level but at the process design level. We can learn from what the hardware industry, among others, did with simulation, but we need to take virtualization even a step further, implementing it across our own industry as a foundational, underlying infrastructure.
Virtualized software development (VSD) is a product-development strategy that frees software development from its dependence on the physical hardware on which applications will be deployed. Instead, VSD enables software developers to develop directly on the desktop, producing a true codevelopment strategy in which hardware and software development begin simultaneously. Software/hardware integration becomes a front-end priority, and not a back-end rush job
Virtualized software development lets developers create high-performance, functionally accurate models of hardware that enables them to begin debugging, testing and optimizing systems much earlier in the development process. Virtualization can be used in varying degrees of detail, from processors to boards to devices, at such a level of accuracy that binary code can run unchanged and unaccompanied by any divergence in behavior.
High-performance virtual platforms deliver degrees of control impossible when testing on physical hardware. Determinism, the inherent nature of software to always execute the same way when the same conditions apply, becomes a reality in virtual testing. As processor and hardware designs increase in complexity, determinism means nothing more than that changes in operation are caused not by traceable flaws in software but by arbitrary, often untraceable changes in hardware that create events known as “Heisenbugs,” states dependent on subtle timing interactions sometimes impossible to replicate even when the entire system is repeatedly rerun. The simulation infrastructure underlying a virtualization platform allows developers to single-step or stop systems to examine their internal states. Developers can reproduce an error repeatedly even when simulating multiple processor cores and multiple processes on each core, making multiprocessor debugging as easy as debugging a single program on a single processor.
VSD also sidesteps codeís inherent limitations, delivering a TiVo-like functionality by executing code in reverse when needed, without any code instrumentation or additional hardware. Virtualization lets developers wait for an error and then “rewind” the code’s execution to search for the culprit behind it. Rewinding code execution requires both the capacity to checkpoint an entire system inexpensively and the ability to simulate at very high speeds. Stepping back an instruction is actually accomplished by reverting to a checkpoint and stepping forward to a point one instruction prior to the point of rewinding, a process that appears almost instantaneous to users if the simulation speed is high enough. This reversible debugging environment works with multiprocessors and multicore processors, allowing developers to track down bugs such as race conditions, divide by zero errors, lock conflicts, deadlock and priority starvation, all of which will crop up even more often in multicore architectures.
The creation of virtual models also allows for rampant standardization by identifying a meaningful platform that both software and hardware teams can use, enhance and share. VSD can access an unlimited number of virtual targets, and the virtual platform (being a software representation of hardware) can be e-mailed around the world in seconds. Because the data produced by virtual models is not physically restricted, companies can share their VSD IP with partners and customers easily and effectively.
VSD was recently illustrated in the introduction of a similar platform, Google Android, although in the context of an SDK. Nevertheless, the concept is the same and consists of a simulated virtual platform enabling a top-down approach that makes hardware essentially irrelevant at the application level. The virtual platform provides all services necessary for design, allowing hardware to be thought of as a front-end, not a back-end, concern. Once software is developed, hardware is optimized for the software, not vice versa.
VSD in practice
Virtualized software development is spreading its benefits on a mainstream, commercial scale. A number of companies have already implemented this approach in their design processes, creating new and innovative infrastructures based on VSD.
IBM employed VSD in the development and testing of the complex software found in its powerful POWER6 platform. By using VSD, IBM’s development teams were able to rise to the challenge of developing complex firmware and hypervisors to boot and run multiple OSes on a virtual system model without the need for physical hardware. This, in turn, helped reduce the overall hardware expense. IBM quickly realized that it could use virtualized software development to optimize its entire product development life cycle as well as minimizing barriers between hardware and software design teams.
GE Aviation Systems (formerly Smiths Aerospace) employed virtualization to develop simulated models for its processing modules. GE modeled the final target system to provide significant benefits, when compared with a traditional development environment, that included reduced development and test costs, integration costs, acquisition and maintenance costs and cost of change. The deterministic capability of VSD also allowed GE’s developers to recreate performance issues at their leisure for in-depth inspection and diagnosis.
Wind River, the leader in DSO, has used VSD for some time to improve their OS development process (as in VxWorks SMP), consistently and publicly identifying VSD as a primary element in their development strategy.
Recently, Monta Vista Software, a provider of Linux for intelligent devices, took VSD a step further and made virtualization a key part of its software sales and evaluation process. Monta Vista allows its potential customers to evaluate Linux product offerings over the Web by using an evaluation service called TestDrive to connect users to a virtual board farm built and run on a virtualized software development platform. This is an excellent example of the way that VSD encourages new ways of thinking and doing business.
By: Michel Genard (mgenard@virtutech.com) is vice president of marketing at Virtutech Inc. (San Jose, Calif.). He is an industry veteran with more than 20 years of experience in the software and hardware embedded market.
For More info please visit us at: Website design company & BPO India
