Object-oriented architectural support for a Java processor [chapter]

N. Vijaykrishnan, N. Ranganathan, R. Gadekarla
1998 Lecture Notes in Computer Science  
In this paper, we propose architectural support for object manipulation, stack processing and method invocation to enhance the execution speed of Java bytecodes. First, a virtual address object cache that supports efficient manipulation and relocation of objects is presented. The proposed scheme combines the serialized handle and object lookup into a single lookup. Next, the extended folding optimization that combines the execution of a sequence of bytecodes is proposed. This eliminates the
more » ... ndant loads and stores of local variables associated with stack architectures. Also, three cache-based schemes: hybrid cache, hybrid polymorphic cache and two-level hybrid cache to implement virtual method invocations are presented. These schemes utilize the receiver type locality at call sites and eliminate the need for creating dispatch tables used in current JVM implementations. This work was done when the author was at University of South Florida Object-Oriented Architectural Support for a Java Processor 331 2. A Just-in-time (JIT) compiler is an execution model which tries to speed up the execution of interpreted programs. It compiles a Java method into native instructions on the fly and caches the native sequence. On future references to the same method, the cached native method can be executed directly without the need for interpretation. JIT compilers have been released by many vendors like Borland, Symantec [26], Microsoft, and Softway [25]. Compiling during program execution, however, inhibits aggressive optimizations because compilation must only incur a small overhead. This constraint makes the JIT compilers intrinsically slower than direct-native code execution. Further, the quality of the generated code critically depends on the specific features of the target processor. Hence, porting these compilers requires a large amount of work. Another disadvantage of JIT compilers is the two to three times increase in the object code, which becomes critical in memory constrained embedded systems. There are many ongoing projects in developing JIT compilers that aim to achieve C++ like performance, such as CACAO [14]. Recently, performance analysis and tuning environments to improve the performance of JIT compilers on specific-platforms like Intelbased systems have been developed. 3. Off-line bytecode compilers can be classified into two types: those that generate native code and those that generate an intermediate language like C. J2C [27], Jolt [28] Harissa [29], Turbo J [22] and Toba [24] are compilers that generate a C code from byte codes. The choice of C as the target language permits the reuse of extensive compilation technology available in different platforms to generate the native code. In bytecode compilers that generate native code directly like NET [13], Asymetrix SuperCede [23] portability becomes extremely difficult. In general, only applications that operate in a homogeneous environment and those that undergo infrequent changes benefit from this type of execution. 4. A Java processor is an execution model that implements the JVM directly on silicon. It not only avoids the overhead of translation of the byte codes to another processor's native language, but also provides support for Java runtime features. It can be optimized to deliver much better performance than a general purpose processor for Java applications by providing special support for stack processing, multi-threading, garbage collection, object addressing and symbolic resolution. It can also make efficient use of the processor resources like the cache and branch prediction unit unlike the interpreters. Java processors can be cost-effective to design and deploy in a wide range of embedded applications such as telephony and web tops. It is estimated that Java specific processors could capture half the total available micro controller market by 1999 [33]. The various features of Java that make it suitable for software applications also add performance overheads. The use of polymorphic methods, garbage collection, context switching, dynamic loading and symbolic resolution contribute to the slow execution speed of Java code. Implementations of other languages such as Smalltalk and Forth have attempted to reduce some of these overheads. Address Address Data Control Signals 32 32
doi:10.1007/bfb0054098 fatcat:7cyo4gvgdfdmpa2ssqvugtm4ie