Abstract:
Exception detection is expedited in virtual machine interpreter (VMI) accelerator hardware ( 120 ) by dispatching fetched bytecodes along with instructions that cause a processor interrupt if the fetched bytecodes cause an exception to be thrown. The processor interrupt serves to indicate to the VMI ( 120 ) that an exception condition exists, thereby obviating the need to for the VMI ( 120 ) to wait for the result of an exception check to be sent from the CPU ( 110 ) to the VMI ( 120 ).

Description:
FIELD OF THE INVENTION  
         [0001]    The present invention relates generally to computer programming languages, and more particularly to the translation and execution of a virtual machine language.  
         BACKGROUND OF THE INVENTION  
         [0002]    Computer programming languages are used to create applications consisting of human-readable source code that represents instructions for a computer to perform. Before a computer can follow the instructions however, the source code must be translated into computer-readable binary machine code.  
           [0003]    A programming language such as C, C++, or COBOL typically uses a compiler to generate assembly language from the source code, and then to translate the assembly language into machine language which is converted to machine code. Thus, the final translation of the source code occurs before runtime. Different computers require different machine languages, so a program written in C++for example, can only run on the specific hardware platform for which the program was written.  
           [0004]    Interpreted programming languages are designed to create applications with source code that will run on multiple hardware platforms. Java™ is an interpreted programming language that accomplishes platform independence by generating source code that is converted before runtime to an intermediate language known as “bytecode” or “virtual machine language.” At runtime, a virtual machine translates bytecodes into platform-appropriate machine code. In essence, the virtual machine is not a physical structure, but rather is a self-contained operating environment (generated by interpreter software or a sequence of processor instructions) that interprets bytecodes for the hardware platform by selecting the corresponding native machine language instructions that are stored within the VM or in the CPU. The native instructions are then supplied to and consecutively executed in the CPU of the hardware platform. A typical virtual machine requires 20-60 cycles of processing time per bytecode (depending on the quality and complexity of the bytecode) to perform an FDD series of operations. To interpret each bytecode, a Java virtual machine performs a “fetch, decode, and dispatch” (FDD) series of operations. For each bytecode instruction the Java Virtual Machine (JVM) contains a corresponding execution program expressed in native central processing unit (CPU) instructions. The JVM causes the CPU to fetch or read a virtual machine instruction from memory, to decode the CPU address of the execution program for the bytecode instruction, and to dispatch by transferring control of the CPU to that execution program. The interpretation process can be time-consuming.  
           [0005]    Adding a preprocessor (a virtual machine interpreter (VMI)) between a memory and a CPU accelerates the processing of virtual machine instructions, as disclosed in PCT Patent Application No. WO9918484, which has the same inventor and assignee as the present invention. The VMI is a hardware module that interprets Java bytecodes by generating native CPU instructions “on-the-fly.” First, a VMI reads (fetches) a bytecode from memory. Next, the VMI looks up a number of properties of (decodes) the fetched bytecode. The properties accessed by the VMI determine how the bytecode will be processed into native instructions for dispatch to and execution in the CPU. Thus, the VMI can perform each FDD in hardware rather than in software. While the CPU is executing one instruction, the VMI fetches and processes the next bytecode into CPU instructions.  
           [0006]    While interpreting a sequence of bytecodes, a virtual machine may encounter a bytecode (or sequences of bytecodes) that causes an illegal operation, such as an instruction to access outside the bounds of an array. The performance of such an illegal operation causes an exception to be thrown which must be handled and cleared before subsequent functions can be called, unless the subsequent functions are exception-related such as ExceptionOccurred, ExceptionDescribe, and ExceptionClear. In processor-based exception checking procedures, an exception is pending until an exception check determines whether the operation called for by a bytecode will actually result in the performance of the illegal operation, because calling non-exception-related functions while an exception is pending may lead to unexpected results. However in Java, exceptions are not held in a pending state while the exception check is performed. Rather, exception conditions are explicitly checked through the execution of CPU instructions. Once an exceptional situation has been detected, an exception object is created according to the exception type, and exception-handling software is invoked.  
           [0007]    The virtual machine approach to exception checking is not optimal with respect to VMI implementations. For example, to interpret the IALoad bytecode, a virtual machine generates instructions that compare the index of an array access to the size of the array, an operation which can result in an out-of-bounds condition. The VMI reacts as if the potential out-of-bounds condition is a type of conditional branch, and thus suspends processing of bytecodes for a substantial amount of time while waiting for receipt of an exception check result from the CPU that indicates whether the out-of-bounds exception actually occurs. Therefore, this exception handling solution requires a substantial amount of overhead (i.e., a burden on processing time).  
           [0008]    There is a need for a method of processing virtual machine instructions with a virtual machine hardware accelerator (such as the Virtual Machine Interpreter) which reduces the processing time required to perform exception detection and checking.  
         SUMMARY OF THE INVENTION  
         [0009]    The present invention fulfills the needs described above by providing a system and method of detecting exceptions while processing virtual machine instructions that advantageously minimizes the processing delays incident to exception checking by obviating the need to wait for the return of an exception check result from the processor.  
           [0010]    More specifically, according to the system and method of the present invention a virtual machine hardware accelerator (such as the VMI) determines whether a bytecode will throw an exception by processing and dispatching native instructions that cause the CPU to generate an interrupt if the bytecode will result in an illegal operation.  
           [0011]    Briefly, an exemplary embodiment of the method of processing virtual machine instructions includes fetching a bytecode and incrementing a bytecode counter. The VMI processes the fetched bytecode into native instructions (i.e., the VMI “generates” a sequence of native instructions) executable by a processor (CPU) and the VMI dispatches the native instructions corresponding to the bytecode along with native instructions that will cause a processor interrupt if execution of native instructions called for by the bytecode results in an illegal operation (the “interrupt instructions”). The instruction set of most CPUs includes special interrupt functions, some of which are unconditional interrupt instructions such as TRAP, SYSCALL, or BREAK (for MIPs processors). However, when invoked unconditional interrupt instructions cause a CPU interrupt regardless of whether an exception exists. Thus, unconditional interrupt instructions are not used by the VMI to detect exceptions, because doing so would require the VMI to wait for receipt of the exception condition from the CPU before invoking an unconditional interrupt instruction. Rather, the VMI detects exceptions using conditional interrupt instructions.  
           [0012]    The conditional interrupt situation is created when the VMI generates instruction sequences that can cause an interrupt when the exception condition exists. The VMI generates a sequence of native instructions that cause a processor interrupt for example by creating an algorithm that performs computations on the exception indicator that result in a processor interrupt. Alternatively, the VMI generates individual conditional interrupt instructions from the CPU instruction set. Either type of interrupt instruction or instruction sequence is “generated” by the VMI as part of the sequence of native instructions dispatched to the CPU.  
           [0013]    The CPU executes the native instructions called for by the bytecode along with the interrupt instructions. If execution of the native instructions called for by the bytecode results in an illegal operation, the interrupt instructions cause a processor interrupt. Accordingly, there is no need to transfer an exception check result from the CPU to the VMI. Consequently, Java exception checking according the present invention is less time-consuming.  
           [0014]    When a processor interrupt occurs, the exemplary system can be programmed to handle the exception. In principle, for every operation that could result in an exception, the Java programmer must indicate an appropriate response (i.e. provide code to handle that exception). At the bytecode level therefore, every sequence of bytecodes that constitutes a method must contain extra sequences of bytecodes and a table that indicates a sequence of exception-handling bytecodes to be executed for every conceivable exceptional situation.  
           [0015]    The system of an exemplary embodiment of the present invention is an apparatus for processing bytecodes that includes a processor with a native instruction set that executes native instructions, and an instruction memory that stores bytecodes. A VMI fetches bytecodes from the instruction memory, processes the bytecodes into native CPU instructions and dispatches the bytecodes along with interrupt instructions that cause a processor interrupt if execution of the processed virtual machine instructions results in an illegal operation. A virtual machine instruction counter is incremented after each bytecode is processed. Alternatively, the VMI either retrieves the interrupt instructions from a CPU instruction set or generates the interrupt instructions.  
           [0016]    The present invention can be implemented in systems that execute Java™ bytecode using virtual machines, such as JVMs made by Sun Microsystems. However, the invention can also be implemented using other Java™ virtual machines such as the Microsoft Virtual Machine, and is also applicable to systems that execute other interpreted languages such as Visual Basic, dBASE, BASIC, and .NET.  
           [0017]    Additional objects, advantages and novel features of the invention will be set forth in part in the description which follows, and in part will become more apparent to those skilled in the art upon examination of the following, or may be learned by practice of the invention. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0018]    The accompanying drawings, which are incorporated in and form part of the specification, illustrate the present invention when viewed with reference to the description, wherein:  
         [0019]    [0019]FIG. 1 is a block diagram that shows the functional elements of an exemplary embodiment of the environment of the present invention.  
         [0020]    [0020]FIG. 2 is a flowchart that shows a method according to an exemplary embodiment of the present invention. 
     
    
     DESCRIPTION OF PREFERRED EMBODIMENTS  
       [0021]    As required, detailed embodiments of the present invention are disclosed herein; however, it is to be understood that the disclosed embodiments are merely exemplary of the invention that may be embodied in various and alternative forms. The figures are not necessarily to scale; some features may be exaggerated or minimized to show details of particular components. Therefore, specific structural and functional details disclosed herein are not to be interpreted as limiting, but merely as a basis for the claims and as a representative basis for teaching one skilled in the art to variously employ the present invention.  
         [0022]    Referring now in detail to an exemplary embodiment of the present invention, which is illustrated in the accompanying drawings in which like numerals designate like components, FIG. 1 is a block diagram of the exemplary embodiment of the environment of the present invention. The basic components of the environment are a hardware platform  100  that includes a processor  110 , a preprocessor  120 , and an instruction memory  150 , which are all connected by a system bus  160 . The preprocessor  120  includes a control register  130  and a translator  140 . A hardware platform  100  typically includes a central processing unit (CPU), basic peripherals, and an operating system (OS). The processor  110  of the present invention is a CPU such as MIPS, ARM, Intel×86, PowerPC, or SPARC type microprocessors, and contains and is configured to execute hardware-specific instructions, hereinafter referred to as native instructions. In the exemplary embodiment of the present invention, the translator  140  is a Java™ virtual machine (JVM), such as the KVM by Sun Microsystems. The instruction memory  150  contains virtual machine instructions, for example, Java™ bytecode  170 . The preprocessor  120  in the exemplary embodiment is the Virtual Machine Interpreter (VMI) disclosed in WO9918486, and is configured to fetch a virtual machine instruction (for example, a bytecode  170 ) from the instruction memory  150  and to translate the virtual machine instruction into a sequence of native CPU instructions. The VMI  120  is a peripheral on the bus  160  and may act as a memory-mapped peripheral, where a predetermined range of CPU addresses is allocated to the VMI  120 . The VMI  120  manages an independent virtual machine instruction pointer  180  (the “bytecode counter”) indicating the current (or next) virtual machine instruction in the instruction memory  150 .  
         [0023]    [0023]FIG. 2 is a flowchart that shows a method according to an exemplary embodiment of the present invention. Referring in detail to FIG. 2, in step  210  the VMI  120  increments the bytecode counter BCC  180  before proceeding in step  220  to fetch each bytecode  170  from the instruction memory  150 . In step  230 , the VMI  120  decodes each bytecode  170  by accessing the properties for the bytecode  170 . In step  240 , the VMI  120  retrieves a sequence of native instructions from the translation table  140  that includes the translation of the fetched bytecode  170 , the interrupt instructions that detect exception conditions when executed along with a fetched bytecode  170 , as well as other instructions that must be executed along with the fetched bytecode  170 . The interrupt instructions detect exception conditions by invoking a processor interrupt when the execution of instructions called for by the fetched bytecode  170  causes an illegal operation. These interrupt instructions are existing CPU commands (specified in the CPU instruction set  115 ) generated by the VMI  120  or instruction sequences (algorithms) generated by the VMI  120 .  
         [0024]    Interrupt instruction sequences can include any combination of native instructions that will induce a processor interrupt. According to an exemplary embodiment, the VMI generates computational instructions that operate on the exception indicator so as to cause an arithmetic overflow only if the exception will actually occur. For example, the bytecode processed by the VMI  120  can call for an array index check, wherein the corresponding native instructions will compare the index to the array bounds (such as by using SLTU). The outcome of this comparison (0=OK, 1=FAIL) is stored in a CPU register and becomes the exception indicator. This VMI-generated interrupt instruction sequence creates an interrupt if the comparison fails, by shifting the exception indicator  31  positions to the left and adding the exception indicator to itself as follows:  
         [0025]    SLTU $1, $bound, $idx  
         [0026]    SLL $1, $1, 31  
         [0027]    ADD $1, $1, $1 If the value of the shifted exception indicator is 1, the largest possible negative number (on a 31-bit machine) is obtained. The result of adding this number to itself is a number that causes an arithmetic overflow exception. Another possible initiator of CPU interrupt conditions is a divide-by-zero function.  
         [0028]    The VMI  120  (in step  250 ) dispatches (to the CPU  110 ) the sequence of native instructions that corresponds to the fetched bytecode  170  along with the interrupt instructions. Steps  260  and  270  occur within the CPU. The CPU  110  executes the sequence of native instructions and the interrupt instructions. If an exception is thrown in step  260 , a processor interrupt is caused by the interrupt instructions, and an exception-handling process is invoked in step  270 . For example, the VMI  120  can be programmed to dispatch exception-handling bytecode sequences along with each fetched bytecode sequence that constitutes a method. If no exception is thrown, the VMI  120  proceeds to process the next bytecode  170  from the instruction memory  150  by returning to step  210 .  
         [0029]    Although the present invention is described with respect to implementation in virtual machine interpreter accelerator hardware, implementation in conjunction with various other bytecode processing systems is possible as will be understood by those skilled in the art.  
         [0030]    In view of the foregoing, it will be appreciated that the present invention provides a system and a method for accurate and efficient detection of exceptions during processing of virtual machine instructions. Still, it should be understood that the foregoing relates only to the exemplary embodiments of the present invention, and that numerous changes may be made thereto without departing from the spirit and scope of the invention as defined by the following claims.