Mavos Detailed Specifications

Java Support

• Full support for the CLDC virtual machine and class librairies
• Complete adherence to the java virtual machine specification
• Exception, Error, and Throwable handling is also fully supported, including "finally" clauses
• Floating point support is optional, depending upon the processor's floating point capabilities
• The built-in native method support can be extended to third-party applications in a platform-specific manner

An advanced process and threading model allows for complete separation of groups of threads into distinct memory spaces. All resources allocated by an application are released when all threads of the application have terminated or have been forcibly terminated. Such resources include the class table, string tables and static memory. Static intializers are separately run for a class regardless of whether it has already been loaded by a separate application, and there are no shared event-handling threads, or sharing resources of any sort. This allows the VM to remain active indefinitely without the continuous growth in memory required by most conventional java virtual machines. It also allows the system to terminate an application immediately without corruption of the system as a whole.

Java thread stacks can be configured to be of fixed length or growable, whichever is optimal for the platform. Growable stacks require larger stack frames and stack-checking.

The garbage collector is a high-performance, exact, mark and sweep collector. The collector can be configured to run in its own thread concurrently with other threads (with priority and CPU time share specified), or whenever the processor is idle. In both configurations the garbage collector will additionally step in seamlessly when there is a shortage of free memory.

• numerous bytecodes are substituted by faster counterparts as the byte-code is executed - invokestatic, invokeinterface, invokevirtual, invokespecial, return, ireturn, areturn, lreturn, getstatic, putstatic, getfield, putfield, instanceof, checkcast, new, newarray, anewarray, multianewarray
• several commonly used methods are substituted by bytecode counterparts the first time each such method is called, these include commonly used java.lang.String methods, java.lang.Math methods and java.util.Vector methods
• the constant pool of each class, stored in memory when the class is loaded, is further resolved when each constant pool entry is first accessed
• each class that implements an interface has interface implementation tables that make for fast interface method lookup
• each loaded class and its associated structures can be stored in a single contiguous block of memory
• virtual method arrays make for fast virtual method lookup
• separation of primitive data types from object references provide faster garbage collection
• java registers (program counter, stack pointer, frame pointer and local variable pointer) are configurable as global variables, local variables inside the instruction loop, or machine registers, whichever is optimal for the platform
• direct threading and token threading platform-specific optimizations are optional