...in the certain event that it gets slashdotted.
"Dynamite allows software that has been compiled for one processor/operating system to be run on another processor/operating system without any source code or binary changes. To do this, Dynamite provides a hardware virtualization technology that consists of four key components. First, an integration "FUSE" allows Dynamite to be easily integrated into the target system. Second, a dynamic binary translator tackles the challenge of moving from one instruction set architecture to another. Third, an operating system mapper translates operating system calls from the source system to the target system in situations where the source and target operating systems are different. Finally, a graphics subsystem mapper translates graphics system calls from the source to the target system in situations where the source and target graphics systems are different.
Integration FUSE. Dynamite is integrated with the operating system of the target system and runs like any other application. Unlike static translators that translate an application's binary once before run time, Dynamite translates instructions and operating system calls while an application is running. When a foreign application is started, the operating system recognizes that the application needs translation and automatically starts Dynamite. Depending on the requirements for the integration, Dynamite can be configured with a wide range of options, including the ability to build "bridges" between translated code and code running native on the target platform. This feature has been used, for example, to allow translated applications to call a native accelerated graphics library for the graphics chipset in the target platform, delivering higher quality and speed than other solutions. Integration options also provide for different optimization schedules and the ability to reconfigure the use of the translation code cache to better match performance to customer needs.
Dynamic Binary Translation. The dynamic binary translator in Dynamite is a breakthrough technology that uses a modular architecture consisting of three key components. The front-end decoder reads blocks of instructions from the foreign application's binary and decodes them into an intermediate representation. The intermediate representation allows Dynamite to understand the higher-level semantics and intent of the code.
The optimizing kernel reads the intermediate representation and optimizes the code. At first, simple optimizations are performed. In most applications, however, a 90/10 rules holds where 10% of the code is executed 90% of the time. The optimizing kernel looks for blocks of code that are executed often, spends increasing amounts of time improving the optimization of this code, and then stores this optimized code in memory. Each time a frequently used block of code needs to be executed, the highly optimized code stored in memory is used instead of optimizing that block of code again. Because the blocks of code that are executed change frequently, the optimizing kernel flushes old optimized blocks and generates new ones. The optimizing kernel produces superior code optimization compared to static binary translators or compilers. It optimizes code based on how an individual user is using that application and does not need to optimize code for the general case.
The back-end code generator outputs code for the target processor. Different RISC, CISC and VLIW back-ends provide different ways of performing register allocation, instruction selection and operand addressing modes to take advantage of the distinct features available in a particular target processor.
Operating System Mapper. Dynamite supports operating system mapping between any two Unix/Linux-like operating systems, as well as mapping between mainframe and any Unix/Linux-like operating systems. Where similar operating system calls exist between the source and destination operating system, Dynamite maps calls between the two. Where an equivalent operating system call doesn't exist in the target environment, Dynamite maps to similar calls per the customer's guidance. Dynamite also monitors certain system calls, for example thread scheduling and memory mapping calls, to ensure that it can reproduce the complete behaviour of the program it is executing.
Graphics Mapper. Dynamite can be used to run binaries on systems that have very different graphics implementations by intercepting calls to the original graphics library and instead, calling library routines that are running native on the destination system. This substitution may involve transforming library parameters to the appropriate form, and dynamically constructing "trampoline" routines that allow source and destination routines to call each other in any combinations. The richness of these interfacing facilities means that arbitrary applications can be run with graphics performance as good as if the application were running natively."
