Virtualized system development to help developers

BANGALORE, INDIA: The shift in hardware to multi-core processors and multiprocessor systems calls for new software and systems development tools to help developers transform their code into parallel applications and gain performance increases.

Developers now have to know how to create software and architect systems that can use parallel hardware efficiently.

Future systems will be comprised of software stacks running on small (or large) shared-memory nodes, communicating with other nodes over various types of interconnects, and building a system-level software abstraction on top of the multi-core and distributed hardware.

Note that a software structure such as this can be used within a single multi-core hardware device.

The trends toward virtualization and hypervisors in multi-core hardware make it possible to have several isolated groups of cores run their own shared-memory abstraction, looking at other groups of cores as remote network nodes, even if they physically exist within the same silicon package.

Virtualized Systems Development

A virtual platform provides benefits such as freedom from physical constraints, arbitrary configurability, check-pointing and restarting at any point, superior convenience and stability, access to the target long before prototype hardware, and the ability to test faults and boundary cases with complete control and precision.

Virtualized systems development is a development methodology where the actual hardware of a system is augmented by a Wind River Simics virtual platform, a simulation model of the hardware running on a workstation or a PC.

The virtual platform can run the same binary software as the physical hardware, fast enough to be used as an alternative and augment physical hardware for software development.

Doing multi-core hardware right is not easy, but it is certainly easier than doing multi-core software right. There are three main problems:

* Ensuring existing software keeps working (without taking advantage of multi-core)

* Parallelizing existing software to get the performance and power consumption benefits of multi-core parallel execution

* Creating new software that is parallel from the beginning

{#PageBreak#}

Virtual Platform Debugging Benefits

Traditional debugging techniques and debugging tools do not work very well on an inherently nondeterministic system such as a hardware multiprocessor or multi-core processor.

A key benefit of a virtual platform is repeatability and reversibility. A problem in finding and fixing software bugs in parallel software is the lack of determinism in the execution of the software system.

This complicates debugging greatly because the very act of debugging a parallel program makes timing-sensitive bugs such as race conditions disappear or appear in a different place. A virtual platform provides determinism and repeatability.

The simulator has explicit control over the execution of instructions and propagation of information between processors and can therefore impose a repeatable behavior on the software running on a multi-core processor.

When running the same software from the same initial state with the same sequence of asynchronous inputs, the same execution sequence is seen, unless something is changed.

When the same intentionally buggy program is run several times on two different simulated multi-core machines, each run gets a different result because it is run from different initial states. The simulator can go back and reproduce each run precisely, which is not possible on physical hardware.

Another benefit of a virtual platform for multi-core debugging is that the simulator can stop the execution of the entire system at any point in time.

This means that it is possible to single-step code where processors communicate with each other without changing the behavior of the code and that code running on other processors cannot swamp a stopped processor with data to process.

It is also possible to build extra statistics into the virtual platform, to assess fairness and accessibility and catch starvation of different parts of the system.

Conclusion

Building reliable and high-performance systems out of multi-core processors and parallel software is a tough problem for systems developers across the globe.

Virtualized systems development offers a key tool to help make this simpler, faster, and less risky.

More information and insight into the system workings can be obtained, debugging can be faster, and system and software architectures can be explored by using virtual platforms to augment physical hardware.