Specifications

Java Support

• Full support for the CLDC virtual machine and class librairies
• Complete adherence to the java virtual machine specification
• 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

Advanced Process Model

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

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.

Garbage Collection

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.

JVM Performance Optimizations

• 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
• specialized bytecodes are used for some commonly used methods
• each loaded class and its associated structures can be stored in a single contiguous block of memory
• 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

 
   

Expansion of JVM for Further Optimization

Common methods of JVM expansion for platform-specific performance improvement have been accounted for in the design.

Hardware Acceleration

A processor whose native instructions mirror java instructions may execute some of the java bytecode directly. Supported hardware instructions can be transferred from the JVM software instruction loop to the hardware by a processor specific mechanism. In the reverse direction, the processor may jump to the kernel's JVM instruction handlers for bytecode instructions supported by software.

Just-in-Time Compilers (JIT)

Bundling in a native compiler with the JVM can enable JIT support. In a manner similar to hardware acceleration, byte code execution can be transferred between the compiled code and the built-in interpreter.

Driver Development and O/S Peripherals

Any number of drivers may be added to the kernel in a straightforward manner, allowing for the specific and diverse requirements of an embedded or wireless system. High performance and responsiveness of the JVM can be obtained due to the tight coupling of the JVM with the kernel. In particular, java I/O classes can be primarily written in either native or java code.

Romizing

Support for romizing is built-in, so that the base java class libraries (as well as any other self-contained java packages) can be romized, allowing for fast start-up times and reduced RAM requirements.