Introduction to Elate® Virtual Processor Code

The performance and functionality of embedded devices is normally inhibited by such constraints as memory, CPU processing power, device portability and power consumption. Traditionally, such problems have been remedied by the use of such techniques as highly optimised assembler code. However, solutions of this kind are bedevilled by further difficulties, such as difficulty of maintaining the code base, and the lack of code portability. Tao's Elate operating system was conceived to remove these impediments. Elate's virtual processor code is fully portable across platforms, while its class based design allows for a more robust software engineering approach. Nonetheless Elate still retains the speed and memory efficiency of an assembler language.

Elate's streamlined binary code uses an optimised instruction set to maximise code density in store. Consequently, an application in VP code generally requires less storage space than the native code into which it will be translated, often by a ratio of 2:1. With fewer bytes to load for a VP code application than for a native code version, the load time is significantly reduced. VP was designed with a small number of basic operations, many of which can be combined into expression trees, thereby providing a powerful programming tool whilst permitting compact binaries.

The Virtual Processor (VP) language is founded upon the concept of a 'tool', a small re-usable piece of code, to build more complex applications. Many of the tools in Elate are in the order of a few hundred bytes in size. The small size of the tools has several advantages from a software engineering perspective; the small tools are easier to understand, test and debug compared to large monolithic applications. This naturally leads to more reliable code, and therefore smaller processor & RAM/ROM requirements, and lower manufacturing costs for customers.

Although Elate can be thought of as consisting of thousands of stand alone tools, these tools can be organised according to a class structure. Much of the Elate system involves creating objects of a particular class, for example, a device driver object, and then invoking methods on that object. Typically, the class methods are implemented as VP tools. This has the great advantage that for a given class only those methods (tools) actually required need to be loaded into memory. This approach obviously leads to efficient use of memory, important for portable device applications such as PDAs and mobile phones. This approach can also lead to significant bandwidth savings in client-server network and wireless applications, as only the method code actually required needs to be downloaded from the server.

Essentially Elate tools occupy a midpoint between the powerful but bulky objects used in object oriented programming and low-level assembler language. For example, polymorphism, usually regarded as being a defining characteristic of an object oriented system, has been excluded from Elate so as to permit a fine granularity of modular components. As a consequence of this, the overall footprint in terms of both static memory (ROM, flash etc.), and dynamic memory (RAM), is extremely small (typically smaller than 300 bytes), while a level of functionality comparable to object oriented languages remains available.

Copyright © 1999, 2000, 2001 Tao Group Ltd or Tao Systems Ltd. All Rights Reserved
Please read our copyright and trade marks notice