With the Code Morphing software handling x86 compatibility, Transmeta's designers created a very simple, high-performance, VLIW hardware engine with two integer units, a floating-point unit, a memory control unit and a branch unit. Transmeta's Crusoe processor uses VLIW's, Very Long Instruction Word's, which are called a 'molecule', and can be 64 bits or 128 bits long and contain up to four RISC-like instructions, called 'atoms'. All atoms within a molecule are executed in parallel, and the molecule format directly determines how atoms get routed to functional units within the processor. This format-dependent routing greatly simplifies the decode and dispatch hardware, as it does away with complex out-of-order hardware.
Current superscalar x86 processors, such as the Intel Pentium III, also have multiple functional units that can execute RISC-like operations in parallel; however due to the out-of-order execution a separate piece of hardware is needed to re-construct the sequence of the original x86 instructions and make sure that they execute in order. As a result, this type of processor is much more complex than the Crusoe processor's VLIW engine.
As mentioned above, due to a conventional x86 processor's out-of-order execution, it requires additional hardware to make sure that x86 instructions are executed in the correct order. In contrast, Code Morphing can translate an entire group of x86 instructions at once, whereas a conventional x86 processor translates each instruction separately. Also, the Code Morphing software translates instructions once and stores the result in a 'translation cache'; the next time the same code is executed, the processor can immediately run the existing instruction from the translation cache.
This software translation opens up new possibilities, since a conventional out-of-order processor has to re-translate and schedule an instruction each time it executes, very quickly. With Code Morphing, the translation process can be optimized by looking at the generated code and minimizing the number of instructions executed. In other words, Code Morphing can speed up execution plus reduce power consumption. However, performance might not be at its peak after the first iteration of the optimization process. It will probably require multiple passes because the code optimization is done in steps. All code is first recompiled quickly, but not necessarily efficiently, to keep the program and the processor running. Then, when a section of code is run again, it moves up in the hierarchy and is scheduled for optimization, sections that only occur once usually don't get optimized. As a result, that section might take several passes to get fully optimized.
In essence it is no different than programming in a higher language, for example C++. After you've compiled and executed your program one of the things you're keen on determining is where the performance bottlenecks are. Then you subsequently use assembly to speed up just those sections, and thus optimize the program's overall execution. Programming in C++ gets your program running faster than programming it all in assembly, but the extra performance gained by using assembly where needed can really speed up processing.
Discuss This Article (1 Comments) - If you have any questions, comments or suggestions about the article and/or its contents please leave your comments here and we'll do our best to address any concerns.