WO2000022492A2 - System and method for automatically and selectively promoting object variables to method fields and variables in a digital computer system - Google Patents
System and method for automatically and selectively promoting object variables to method fields and variables in a digital computer system Download PDFInfo
- Publication number
- WO2000022492A2 WO2000022492A2 PCT/US1999/023834 US9923834W WO0022492A2 WO 2000022492 A2 WO2000022492 A2 WO 2000022492A2 US 9923834 W US9923834 W US 9923834W WO 0022492 A2 WO0022492 A2 WO 0022492A2
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- code
- variable
- instantiated
- program
- computer
- Prior art date
Links
- 238000000034 method Methods 0.000 title claims abstract description 127
- 230000001737 promoting effect Effects 0.000 title description 8
- 238000012545 processing Methods 0.000 claims abstract description 25
- 230000004044 response Effects 0.000 claims abstract description 15
- 238000004590 computer program Methods 0.000 claims 7
- 238000001514 detection method Methods 0.000 claims 4
- 230000007246 mechanism Effects 0.000 description 6
- 230000008901 benefit Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 238000004891 communication Methods 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 230000008569 process Effects 0.000 description 2
- 238000012546 transfer Methods 0.000 description 2
- 239000011800 void material Substances 0.000 description 2
- 239000002131 composite material Substances 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000008030 elimination Effects 0.000 description 1
- 238000003379 elimination reaction Methods 0.000 description 1
- 230000007774 longterm Effects 0.000 description 1
- 238000013519 translation Methods 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
- 239000002699 waste material Substances 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/43—Checking; Contextual analysis
- G06F8/433—Dependency analysis; Data or control flow analysis
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/44—Encoding
- G06F8/443—Optimisation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4488—Object-oriented
Definitions
- the invention relates generally to the field of digital computer systems, and more particularly to systems and methods for automatically and selectively promoting obj ect variables to method fields or variables in a digital computer system.
- Java programming language has been developed to facilitate the development of programs that can be executed on a wide variety of computers, independent of the computers' particular system or processor architecture.
- the Java programming language is generally object- oriented, and a program developer generates a Java program in the form of one or more classes.
- a Java compiler (“javac") compiles the program into Java byte code (“JBC") for distribution.
- JBC Java byte code
- the Java bye code can be executed in an interpretive manner by a Java "virtual machine" which is provided on the computer.
- the Java byte code can be compiled to the native instruction code of the computer on which the Java program is to be executed by, for example, a "just-in-time" (“JIT”) compiler.
- the just-in-time compiler provides the compiled code to the Java virtual machine for execution.
- the Java virtual machine provides a number of services, including interfacing with the computer's operating system to, for example, obtain data (“input”) for processing and provide processed data (“output”) for storage, display to an operator and so forth.
- the Java programming language generally lacks the "struct" ("structure") concept.
- structure In programming languages such as “C” , the structure concept allows a programmer to define a new data type comprising a collection of one or more variables identified by a data type identifier. After the structure has been defined, the programmer can easily establish, or "declare” a new variable having the data type's structure by referencing the identifier for the structure in the variable's declaration.
- a program (more specifically, a process or thread) has memory structures including one or more stacks and a heap in which data can be stored, and in programming languages such as "C" the programmer can declare the new variable to be established on a stack or allocate space for it in the program's heap.
- Java programming language lacks the concept of a "structure.”
- a Java programmer in order to achieve a similar effect as that provided by a "structure” in "C,” a Java programmer must resort to usage of a degenerate class that contains fields, but no methods.
- a Java program may use a degenerate class, which is also referred to as a "degenerate container class,” by enabling an object to be created therefor by use of a "new" operator.
- An example of the use of the "new" operator will be clear from Code Segments 1 A and IB
- a degenerate container class aPoint is defined, which is used in Code Segment IB.
- the degenerate container class aPoint defines variables aPoint.x, aPoint.y and aPoint.zplane and two methods, namely, a method Scale and a method add.
- a class "body” is defined having a single method body .UsePoint which makes use of the degenerate container class aPoint to define a new variable "pt" having components aPoint.x (established as pt.x) and aPoint.y (established as pt.y).
- a new object for the degenerate container class aPoint is established on the heap for the program which is using body .UsePoint.
- the variable aPoint.zplane in the degenerate container class aPoint is not used in body .UsePoint, but it would be instantiated as part of the object aPoint in response to the "new" operator in body.UsePoint.
- the object includes not only room for the aPoint variables, but also object header information, which can require a fairly extensive amount of storage.
- the programmer explicitly deallocates space on the heap that is allocated to variable which will no longer be needed. Such explicit deallocation is not performed in connection with programs written in the Java programming language. Instead, the Java virtual machine contains a "garbage collection" mechanism which monitors the usage of variables and other objects for which space is allocated in the heap and, if it determines that an object is not likely to be used in the future, it will deallocate the space automatically.
- Garbage collection is not needed in connection with variables, termed "method variables” or “method fields,” which are allocated on the stack, since, when the method which uses the variables returns, the entire portion of the stack (the “stack frame") used during execution of the method, which will include the variables which were used during the execution of the method, will automatically be eliminated without requiring intervention of the garbage collection mechanism.
- method variables or “method fields”
- the entire portion of the stack which will include the variables which were used during the execution of the method, will automatically be eliminated without requiring intervention of the garbage collection mechanism.
- method variables or “method fields”
- Garbage collection requires use of the computer's processor, which takes resources that it (that is, the processor) might otherwise devote to other operations, and typically the larger the heap, the more resources the processor will need to devote to garbage collection.
- the object variables that are declared in a degenerate container class will be instantiated as part of an object even if they are not used in the method for which the object is instantiated, which can waste storage space in the heap
- the invention provides a new and improved system and method for automatically and selectively promoting object variables to method fields or variables in a digital computer system.
- the invention provides a code generating system for generating, from code in a program, native code that is executable by a computer system.
- the computer system includes a memory subsystem including a heap in which objects are stored and a stack in which method variables are stored.
- the code generating system may be included in a just-in-time compiler used to generate native code that is executable by a computer system, from a program in Java Byte Code form, and specifically determines, in response to Java Byte Code representative of an operator for enabling instantiation of a new object, whether the object to be instantiated contains a variable to be used in processing of the received program code portion which can be promoted to a method variable, and, if so, generates native code to enable said variable to be instantiated on the stack.
- a just-in-time compiler used to generate native code that is executable by a computer system, from a program in Java Byte Code form, and specifically determines, in response to Java Byte Code representative of an operator for enabling instantiation of a new object, whether the object to be instantiated contains a variable to be used in processing of the received program code portion which can be promoted to a method variable, and, if so, generates native code to enable said variable to be instantiated on the stack.
- FIG. 1 depicts an illustrative digital computer system including an arrangement for automatically and selectively promoting object variables to method fields or variables in a digital computer system, constructed in accordance with the invention
- FIG. 2 is a functional block diagram of an arrangement constructed in accordance with the invention.
- FIG. 3 is a flow diagram depicting operations performed in connection with the invention.
- FIG. 1 depicts an illustrative computer system 10 including an arrangement for automatically and selectively promoting obj ect variables to method fields or variables in a digital computer system, constructed in accordance with the invention.
- the computer system 10 in one embodiment includes a processor module 11 and operator interface elements comprising operator input components such as a keyboard 12A and/or a mouse 12B (generally identified as operator input element(s) 12) and operator output components such as a video display device 13 with integral speakers 15.
- the illustrative computer system 10 is of the conventional stored-program computer architecture.
- the processor module 11 includes, for example, processor, memory and mass storage devices such as disk and/or tape storage elements (not separately shown) which perform processing and storage operations in connection with digital data provided thereto.
- the mass storage subsystems may include such devices as disk or tape subsystems, optical disk storage devices and CD-ROM devices in which information may be stored and/or from which information may be retrieved.
- One or more of the mass storage subsystems may utilize removable storage media which may be removed and installed by an operator, which may allow the operator to load programs and data into the digital computer system 10 and obtain processed data therefrom. Under control of control information provided thereto by the processor, information stored in the mass storage subsystems may be transferred to the memory for storage. After the information is stored in the memory, the processor may retrieve it from the memory for processing. After the processed data is generated, the processor may also enable the mass storage subsystems to retrieve the processed data from the memory for relatively long-term storage.
- the operator input element(s) 12 are provided to permit an operator to input information for processing and/or control of the digital computer system 10.
- the video display device 13 and speakers 15 are provided to, respectively, display visual output information on a screen 14, and audio output information, which are generated by the processor module 11, which may include data that the operator may input for processing, information that the operator may input to control processing, as well as information generated during processing.
- the processor module 11 generates information for display by the video display device 13 using a so-called “graphical user interface” ("GUI”), in which information for various applications programs is displayed using various "windows.”
- GUI graphical user interface
- the computer system 10 is shown as comprising particular components, such as the keyboard 12 A and mouse 12B for receiving input information from an operator, and a video display device 13 for displaying output information to the operator, it will be appreciated that the computer system 10 may include a variety of components in addition to or instead of those depicted in FIG. 1.
- the processor module 11 may include one or more network or communication ports, generally identified by reference numeral 15, which can be connected to communication links to connect the computer system 10 in a computer network, or to other computer systems (not shown) over, for example, the public telephony system. The ports enable the computer system 10 to transmit information to, and receive information from, other computer systems and other devices in the network.
- the invention provides an arrangement, which will be described below in connection with FIG.2, for automatically and selectively promoting object variables to method fields or variables in a digital computer system.
- the arrangement makes use of two general portions, including a Java program development portion 20 and a Java program execution portion 21.
- the Java program development portion 20 includes elements that a Java program developer uses to develop a program for distribution
- the Java program execution portion 21 includes elements that enable the Java program to be executed.
- the Java program development portion 20 and the Java program execution portion 21 may both form part of the same computer system, such as computer system 10.
- the Java program development portion 20 and the Java program execution portion 21 can form part of separate computer systems, and the Java program developed on one computer system (that is, the computer system including the Java program development portion 20) can be provided to the computer system on which the Java program is to be executed (that is, the computer system that includes the Java program execution portion 21) using any conventional mechanism suitable for distributing Java programs, including, for example, magnetic or optical disks, transfers over networks such as the Internet or the like.
- the Java program development portion 20 includes elements that a Java program developer uses to generate a Java program in a form that can be distributed, including, for example, elements of the computer system as described above that enable the input of information to the computer, the information that is input being in the form of Java program source code 22.
- the Java program source code 22 input by the program developer is, in turn, compiled by a Java compiler ("javac") 23 to generate Java byte code ("JBC") 24, which can be distributed as described above for execution.
- the Java program execution portion 21 includes elements that enable the Java byte code 24 to be executed by the computer system 10.
- the Java program execution portion includes a Java just- in-time (“JIT”) compiler 25 and a Java virtual machine 26, both of which operate under control of a control module 27.
- JIT Java just- in-time
- the control module 27 may include, for example, elements of the operating system (not separately shown) which controls the computer system 10.
- the Java just-in-time compiler 25 receives the Java bye code 24 and generates therefrom native code for the computer system 10, which is provided to the Java virtual machine 26 for execution.
- the Java just-in-time compiler 25 generally generates the native code in a conventional manner, except as described below.
- the Java virtual machine includes a number of elements, including one or more stacks generally identified by reference numeral 30, a heap 31, a garbage collector and a virtual machine control module 33.
- the virtual machine control module 33 essentially controls the execution of the native code provided to the Java virtual machine 26 by the Java just-in-time compiler 26.
- the virtual machine control module 33 controls the establishment of the stack(s) 30 and the creation of method variables on the respective stacks, and in addition controls the creation of object variables on the heap 31.
- the Java programming language provides for execution of multiple threads of execution within the single Java virtual machine 26, and one stack 30 will be associated with one thread.
- each stack 30 includes a series of storage locations, and the virtual machine control module 33 can push variables onto, and pop variables off of, the respective stack in response to instructions therefor in the native code received from the Java just-in-time compiler 25.
- the variables that are pushed onto a respective stack 30 may be popped off the stack for processing, also in accordance with native code instructions received from the Java just-in-time compiler 25, and the results may be pushed back onto the respective stack or stored elsewhere, such as in the heap 31.
- the instructions in the native code enable method variables, that is, variables that are declared and used in connection with a particular method, and not referenced by or used in other methods, to be pushed onto a respective stack 30.
- the portion of the stack onto which a variable or variables are pushed for a respective method is typically referred to as the method's stack frame.
- the method's stack frame When processing of the method is completed and it "returns" to the method which called it, if any, the method's method variables are removed from the respective stack 30. More specifically in connection with removal of a method's method variables from the respective stack 30, as is conventional each stack 30 is provided with a stack pointer that identifies the next storage location in the stack into which a variable may be stored.
- the stack pointer is reset to identify the first storage location in the respective stack 30 that was used for the returning method's stack frame, in which case, when method variables are pushed onto the respective stack 30 for another method, the method variables are stored in storage locations that had been used for the previous method.
- the virtual machine control module 33 need not actually remove or over- write the storage location(s) in the respective stack 30 in which the method's method variable(s) is (are) stored.
- the heap 31 includes a plurality of storage locations in which the virtual machine control module 33 can store objects including object variables.
- Each object as stored in the heap 31 includes an object header and space for one or more variables associated with the respective object.
- the objects that are stored on the heap 31 may be retrieved therefrom for processing, also in accordance with native code instructions received from the Java just-in-time compiler 25, and the results may be stored in the same or other object on the heap 31 or elsewhere, such as pushed onto a stack 30.
- the instructions in the native code enable objects to be established in the heap 31 if they may be used in connection not only with the particular method in which they are declared, but also if they may be referenced by or used in other methods.
- the garbage collector 32 is provided to scan the heap 31 to identify objects which are on the heap and will not be used subsequently, and to remove them from the heap 31 thereby to free the storage locations used thereby. After the storage locations have been freed, they may be used for other objects.
- the Java just-in-time compiler 25 in response to Java byte code enabling instantiation of an object, generates native code that enables space to be allocated in the heap 31 for the object and its variables and other information relevant thereto, including the object header.
- Java just-in-time compiler 25 determines that native code is to be generated to enable space for the object to be created on the heap 31 (reference item (i) above), operations in connection with the object will proceed in a conventional manner, including allocation of the space on the heap 31 by the virtual machine control module 33, processing of the object's variables, and processing of the object by the garbage collector 32 to determine whether it (that is, the object) is to be removed and to free the storage locations in the heap 31 occupied by the object.
- the virtual machine control module 33 will push the variables onto the respective stack 30 from which they are available for processing in connection with instructions related to the method for which the respective variables were pushed onto the stack. Since the object variables were created on the respective stack 30, instead of on the heap 31 , when the processing of the method is completed and the method returns, the object variables will be removed from the respective stack 30 as described above, without requiring use of the garbage collector 32. Thus, by pushing the object variables onto the respective stack 30, instead of instantiating them in the heap 31, the load on the garbage collector 32 can be reduced. In addition, since the object variables on the respective stack 30 do not require the object header, the amount of storage required therefor will be reduced.
- the Java just-in-time compiler 25 selectively generates native code for enabling space to be allocated on the heap 31 for an object and its variables, or for enabling an object's variables to be pushed on the respective stack 30, after making determinations in connection with certain characteristics in connection with the object.
- the determinations made by the Java just-in-time compiler 25 include, for example (a) determining whether the lifetime of the object to be instantiated is shorter than the lifetime of the method for which the object is to be instantiated; that is, the object must not persist after processing of the method has completed and the method returns;
- the method for which the object is instantiated may store a reference to the instantiated object in a storage location which is not appropriate for a method variable (reference item (c) above) if, for example, it (that is, the method)
- (III) stores a reference to the object in a global location (such as in the heap 31) or adds it to a linked list that is rooted in a global location.
- item (c) is provided to avoid “in-pointers,” that is, pointers that refer to the object in storage locations which are accessible by methods other than the method for which the object was instantiated, which would point to storage locations, such as those in the stack frame for the method for which the object was instantiated, which will be removed when that method returns.
- in-pointers may confuse the garbage collector 32, since, if the method returns the in-pointers will be stale and can result in potentially fatal memory corruption.
- the native code instructions generated by the Java just-in-time compiler 25 will need to enable the object to be instantiated on the heap because the object may be referenced by at least one method other than the method for which the object is instantiated. This follows because the object may persist after the method for which the object is instantiated returns (item (a) above) or the lifetime of the object cannot be determined by the Java just-in-time compiler 25 (item (b) above), or because the method for which the object is instantiated stores a reference to the object in a storage location which is not appropriate for the method's method variables (item (c) above).
- the native code instructions generated by the Java just-in-time compiler 25 may enable the object variables to be pushed on the respective stack 30 because the object will not be referenced by any method other than the method for which the object is instantiated. This follows because the lifetime of the object can be determined by the Java just-in- time compiler 25 (item (b) above) and the object will not persist after the method for which the object is instantiated returns (item (a) above), and further because the method for which the object is instantiated does not store a reference to the object in a storage location which is not appropriate for the method's method variables (item (c) above).
- Code Segment 2 public int UsePoint ( int x, int y, int Q )
- Code Segment 2 depicts code, in the form of source code in the Java programming language, that is, in turn, representative of the native code that would be generated for both Code Segments 1 A and IB above if the Javajust-in-time compiler 25 determines that the variables pt.x and pt.y of the object aPoint.x and aPoint.y can be treated as method variables instead of object variables (as in Code Segment IB).
- Code Segment 2 on the one hand, and Code Segments 1 A and IB, on the other hand, is that, while the variables pt.x and pt.y in Code Segment IB are object variables, which would be instantiated in the heap 31, the variables pt_x and pt_y, used in Code Segment 2 would be, like method variables, on a stack 30. Since no object is instantiated in the heap 31 for the respective variables, as would be the case with Code Segments 1 A and IB, the variables can be more efficiently stored since (1) no object header is required and (2) variables which are not used in the method will not be assigned storage locations. In addition, the garbage collector 32 will not need to operate in connection therewith to free the storage locations which are allocated to the respective variables, since the storage locations will be recovered from the respective stack 30 when the method returns.
- Java just-in-time compiler 25 retrieves a portion of the Java byte code for compilation (step 100) and determines whether the portion includes an element, such as the "new" operator, enabling instantiation of a new object (step 101). If the Javajust-in-time compiler makes a negative determination in step 101, it proceeds to generate native code from the portion in a conventional manner for provision to the Java virtual machine 26 for execution (step 102).
- the Javajust-in-time compiler makes a positive determination in step 101, it proceeds to determine whether the lifetime of the object to be instantiated is shorter than the lifetime of the method for which the object is to be instantiated (step 103). If the Javajust-in-time compiler 25 makes a negative determination in step 103, it proceeds to generate native code enabling the object to be instantiated on the heap 31 (step 104).
- step 103 if the Javajust-in-time compiler makes a positive determination in that step, it proceeds to determine whether the operator that enables instantiation of the object can be executed a determinate number of times (step 105). If the Javajust-in-time compiler 25 makes a negative determination in step 105, it sequences to step 104 to generate native code enabling the object to be instantiated on the heap 31.
- step 105 if the Javajust-in-time compiler makes apositive determination in that step, it proceeds to determine whether the method for which the object is instantiated stores a reference to the instantiated object in a storage location appropriate for a method variable (step 106). If the Javajust-in-time compiler 25 makes a negative determination in step 106, it sequences to step 104 to generate native code enabling the object to be instantiated on the heap 31.
- step 106 if the Javajust-in-time compiler makes apositive determination in that step, it proceeds to generate native code enabling the object variables which will be used in the method to be pushed on the respective stack 30 (step 107).
- step 107 or following step 104 if the Java just-in-time compiler 25 generates native code enabling the object to be instantiated on the heap 31, or following step 102, it (that is, the Javajust-in-time compiler 25) will determine whether there is additional Java byte code to be compiled (step 108). If the Javajust-in-time compiler makes a positive determination in step 108, it can return to step 100 to compile the next Java byte code portion. On the other hand, if the Java just-in-time compiler makes a negative determination in step 108, it may exit (step 109).
- the invention provides a number of benefits.
- the invention provides an arrangement for automatically and selectively promoting obj ect variables to method fields or method variables in a digital computer system, so that the promoted object variables will be allocated on the appropriate stack, similar to method fields or variables, instead of on the heap.
- a computer system executes references to variables on the stack faster than references to objects in the heap.
- the method's stack frame, in which the promoted object variable was allocated will be automatically eliminated from the stack, thereby reducing the load on the garbage collection mechanism.
- the virtual machine since the object variables have been promoted to method fields or method variable, when they are referenced the virtual machine does not need to make an implicit NULL object check, which would otherwise be performed if the object were allocated on the heap. Elimination of the implicit NULL object check also reduces the load on the computer system's processor, freeing it to perform other operations.
- Java just-in-time compiler 25 has been described in connection as performing operations in steps 103, 105 and 107 in the order described above in connection with FIG. 3, the operations may be performed in any order. In addition, under particular circumstances it will be that the some of the operations may not need to be performed, or other operations than those described may need to be performed.
- a system in accordance with the invention can be constructed in whole or in part from special purpose hardware or a general purpose computer system, or any combination thereof, any portion of which may be controlled by a suitable program.
- Any program may in whole or in part comprise part of or be stored on the system in a conventional manner, or it may in whole or in part be provided in to the system over a network or other mechanism for transferring information in a conventional manner.
- the system may be operated and/or otherwise controlled by means of information provided by an operator using operator input elements (not shown) which may be connected directly to the system or which may transfer the information to the system over a network or other mechanism for transferring information in a conventional manner.
Abstract
Description
Claims
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
AU64288/99A AU6428899A (en) | 1998-10-14 | 1999-10-14 | System and method for automatically and selectively promoting object variables to method fields and variables in a digital computer system |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US09/172,153 | 1998-10-14 | ||
US09/172,153 US6308315B1 (en) | 1998-10-14 | 1998-10-14 | System and method for automatically and selectively promoting object variables to method fields and variables in a digital computer system |
Publications (2)
Publication Number | Publication Date |
---|---|
WO2000022492A2 true WO2000022492A2 (en) | 2000-04-20 |
WO2000022492A3 WO2000022492A3 (en) | 2000-07-06 |
Family
ID=22626582
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/US1999/023834 WO2000022492A2 (en) | 1998-10-14 | 1999-10-14 | System and method for automatically and selectively promoting object variables to method fields and variables in a digital computer system |
Country Status (3)
Country | Link |
---|---|
US (1) | US6308315B1 (en) |
AU (1) | AU6428899A (en) |
WO (1) | WO2000022492A2 (en) |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP2254045A1 (en) * | 2009-05-12 | 2010-11-24 | Oracle International Corporation | System and method for using partial software object dematerialization in a virtual machine |
Families Citing this family (28)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
GB2345160B (en) * | 1998-12-23 | 2003-08-20 | Ibm | Virtual machine memory management |
GB2345159B (en) * | 1998-12-23 | 2003-08-20 | Ibm | Virtual machine memory management |
US6654778B1 (en) * | 1999-01-29 | 2003-11-25 | International Business Machines Corporation | Method and apparatus for avoiding function activation and interpretation overhead for calls to selected java methods in a java virtual machine interpreter |
US6434738B1 (en) * | 1999-04-22 | 2002-08-13 | David Arnow | System and method for testing computer software |
US6968438B1 (en) | 1999-09-20 | 2005-11-22 | Texas Instruments Incorporated | Application programming interface with inverted memory protocol for embedded software systems |
US6691298B1 (en) * | 1999-09-20 | 2004-02-10 | Texas Instruments Incorporated | Memory management in embedded system with design time object instantiation |
US6546477B1 (en) | 1999-09-20 | 2003-04-08 | Texas Instruments Incorporated | Memory management in embedded systems with dynamic object instantiation |
US7343594B1 (en) * | 2000-08-07 | 2008-03-11 | Altera Corporation | Software-to-hardware compiler with symbol set inference analysis |
US6671875B1 (en) * | 2000-09-21 | 2003-12-30 | International Business Machines Corporation | Manipulation of an object-oriented user interface process to provide rollback of object-oriented scripts from a procedural business logic debugger |
CA2376327C (en) * | 2002-03-12 | 2009-04-28 | Ibm Canada Limited-Ibm Canada Limitee | Executing native code in place of non-native code |
EP1502196A4 (en) * | 2002-05-02 | 2008-04-02 | Sarvega Inc | System and method for transformation of xml documents using stylesheets |
US7707544B2 (en) * | 2002-12-05 | 2010-04-27 | Bea Systems, Inc. | System and method for generating and reusing software application code with source definition files |
US7210121B2 (en) * | 2003-02-07 | 2007-04-24 | Sun Microsystems, Inc. | Method and system for generating first class citizen application implementing native software application wrapper |
US7340493B2 (en) * | 2003-07-02 | 2008-03-04 | International Business Machines Corporation | System and method for reducing memory leaks in virtual machine programs |
US7594234B1 (en) | 2004-06-04 | 2009-09-22 | Sun Microsystems, Inc. | Adaptive spin-then-block mutual exclusion in multi-threaded processing |
US7644409B2 (en) * | 2004-06-04 | 2010-01-05 | Sun Microsystems, Inc. | Techniques for accessing a shared resource using an improved synchronization mechanism |
US7475397B1 (en) | 2004-07-28 | 2009-01-06 | Sun Microsystems, Inc. | Methods and apparatus for providing a remote serialization guarantee |
US8176153B2 (en) * | 2006-05-02 | 2012-05-08 | Cisco Technology, Inc. | Virtual server cloning |
US8909758B2 (en) * | 2006-05-02 | 2014-12-09 | Cisco Technology, Inc. | Physical server discovery and correlation |
US8442958B2 (en) * | 2006-06-26 | 2013-05-14 | Cisco Technology, Inc. | Server change management |
US7706303B2 (en) | 2006-06-26 | 2010-04-27 | Cisco Technology, Inc. | Port pooling |
US7774389B2 (en) * | 2007-01-17 | 2010-08-10 | Microsoft Corporation | Optimized garbage collection techniques |
JP2009037546A (en) * | 2007-08-03 | 2009-02-19 | Hitachi Ltd | Memory management method utilizing thread-inherent area and computer using same method |
US8782622B2 (en) * | 2008-11-07 | 2014-07-15 | Advanced Micro Devices, Inc. | Optimistic selection of best performing generated code of multiple ISA systems |
US8713426B2 (en) | 2009-06-25 | 2014-04-29 | Oracle International Corporation | Technique for skipping irrelevant portions of documents during streaming XPath evaluation |
US9165086B2 (en) * | 2010-01-20 | 2015-10-20 | Oracle International Corporation | Hybrid binary XML storage model for efficient XML processing |
US8646050B2 (en) * | 2011-01-18 | 2014-02-04 | Apple Inc. | System and method for supporting JIT in a secure system with randomly allocated memory ranges |
US11809839B2 (en) | 2022-01-18 | 2023-11-07 | Robert Lyden | Computer language and code for application development and electronic and optical communication |
Family Cites Families (18)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6151703A (en) * | 1996-05-20 | 2000-11-21 | Inprise Corporation | Development system with methods for just-in-time compilation of programs |
US5907707A (en) * | 1997-01-14 | 1999-05-25 | International Business Machines Corporation | Object model for Java |
US5913065A (en) * | 1997-01-31 | 1999-06-15 | Sun Microsystems, Inc. | System, method and article of manufacture for creating hierarchical folder components for use in a java application or applet |
US5905895A (en) * | 1997-03-07 | 1999-05-18 | International Business Machines Corporation | Method and system for optimizing non-native bytecodes before bytecode interpretation |
US5898850A (en) * | 1997-03-31 | 1999-04-27 | International Business Machines Corporation | Method and system for executing a non-native mode-sensitive instruction within a computer system |
US5898885A (en) * | 1997-03-31 | 1999-04-27 | International Business Machines Corporation | Method and system for executing a non-native stack-based instruction within a computer system |
US6182274B1 (en) * | 1997-05-01 | 2001-01-30 | International Business Machines Corporation | Reusing code in object-oriented program development |
US5943496A (en) * | 1997-05-17 | 1999-08-24 | Intertop Corporation | Methods for developing and instantiating object classes using a java virtual machine extension |
CA2211515C (en) * | 1997-07-25 | 2001-12-11 | Kevin Alexander Stoodley | System and method of local data alignment for stack memory |
US5974256A (en) * | 1997-09-29 | 1999-10-26 | International Business Machines Corporation | Method for translating graphical user interface (GUI) resource data into native java code |
US6081665A (en) * | 1997-12-19 | 2000-06-27 | Newmonics Inc. | Method for efficient soft real-time execution of portable byte code computer programs |
US6106571A (en) * | 1998-01-29 | 2000-08-22 | Applied Microsystems Corporation | Relocatable instrumentation tags for testing and debugging a computer program |
US6074432A (en) * | 1998-03-19 | 2000-06-13 | Xilinx, Inc. | Method for generating a software class compatible with two or more interpreters |
US6011918A (en) * | 1998-04-22 | 2000-01-04 | International Business Machines Corporation | Methods, systems and computer program products for generating client/server applications |
US6075942A (en) * | 1998-05-04 | 2000-06-13 | Sun Microsystems, Inc. | Encoding machine-specific optimization in generic byte code by using local variables as pseudo-registers |
US6158048A (en) * | 1998-05-29 | 2000-12-05 | Intel Corporation | Method for eliminating common subexpressions from java byte codes |
US6131187A (en) * | 1998-08-17 | 2000-10-10 | International Business Machines Corporation | Method and system for translating exception handling semantics of a bytecode class file |
US6141794A (en) * | 1998-10-16 | 2000-10-31 | Sun Microsystems, Inc. | System and method for synchronizing access to shared variables in a virtual machine in a digital computer system |
-
1998
- 1998-10-14 US US09/172,153 patent/US6308315B1/en not_active Expired - Lifetime
-
1999
- 1999-10-14 WO PCT/US1999/023834 patent/WO2000022492A2/en active Application Filing
- 1999-10-14 AU AU64288/99A patent/AU6428899A/en not_active Abandoned
Non-Patent Citations (4)
Title |
---|
ADL-TABATABAI A -R ET AL.: "FAST, EFFECTIVE CODE GENERATION IN A JUST-IN-TIME JAVA COMPILER" ACM SIGPLAN NOTICES, [Online] vol. 33, no. 5, May 1998 (1998-05), pages 280-290, XP000766277 ACM, NEW YORK, US ISSN: 0362-1340 ACM Digital Library Retrieved from the Internet: <URL:http://www.acm.org/pubs/articles/proc eedings/pldi/277650/p280-adl-tabatabai/p28 0-adl-tabatabai.pdf> [retrieved on 2000-03-31] * |
BRUNO BLANCHET: "Escape analysis: correctness proof, implementation and experimental results" PROCEEDINGS OF THE 25TH ACM SIGPLAN-SIGACT SYMPOSIUM ON PRINCIPLES OF PROGRAMMING LANGUAGES POPL 98, SAN DIEGO, CA USA, [Online] 19 - 21 January 1998, pages 25-37, XP002134656 ASM, USA ACM Digital Library Retrieved from the Internet: <URL:http://www.acm.org/pubs/articles/proc eedings/plan/268946/p25-blanchet/p25-blanc het.pdf> [retrieved on 2000-03-30] * |
BURKE M G ET AL: "The Jalapeno dynamic optimizing compiler for Java/sup TM/" PROCEEDINGS OF THE ACM 1999 JAVA GRANDE CONFERENCE, PROCEEDINGS OF THE 1999 ASSOCIATION FOR COMPUTING MACHINERY CONFERENCE ON JAVA GRANDE, SAN FRANCISCO, CA, USA, [Online] 12 - 14 June 1999, pages 129-141, XP002134655 New York, NY, USA, ACM, USA ISBN: 1-58113-161-5 ACM Digital Library Retrieved from the Internet: <URL:http://www.acm.org/pubs/articles/proc eedings/plan/304065/p129-burke/p129-burke. pdf> [retrieved on 2000-03-30] * |
SERRANO M ET AL: "STORAGE USE ANALYSIS AND ITS APPLICATION" PROCEEDINGS OF THE ACM SIGPLAN INTERNATIONAL CONFERENCE ON FUNCTIONAL PROGRAMMING (ICFP),US,NEW YORK, ACM, [Online] vol. CONF. 1, 1996, pages 50-61, XP000643120 ISBN: 0-89791-770-7 ACM Digital Library Retrieved from the Internet: <URL:http://www.acm.org/pubs/articles/proc eedings/fp/232627/p50-serrano/p50-serrano. pdf> [retrieved on 2000-03-31] * |
Cited By (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP2254045A1 (en) * | 2009-05-12 | 2010-11-24 | Oracle International Corporation | System and method for using partial software object dematerialization in a virtual machine |
US8826246B2 (en) | 2009-05-12 | 2014-09-02 | Oracle International Corporation | System and method for using partial software object dematerialization in a virtual machine |
Also Published As
Publication number | Publication date |
---|---|
US6308315B1 (en) | 2001-10-23 |
AU6428899A (en) | 2000-05-01 |
WO2000022492A3 (en) | 2000-07-06 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US6308315B1 (en) | System and method for automatically and selectively promoting object variables to method fields and variables in a digital computer system | |
US6163880A (en) | Object model for Java™ | |
US6651080B1 (en) | Techniques for implementing pluggable virtual machines | |
US6463581B1 (en) | Method for determining reachable methods in object-oriented applications that use class libraries | |
US6141794A (en) | System and method for synchronizing access to shared variables in a virtual machine in a digital computer system | |
JP4880121B2 (en) | Method and apparatus for translating and executing native code in a virtual machine environment | |
US6513156B2 (en) | Interpreting functions utilizing a hybrid of virtual and native machine instructions | |
US6567974B1 (en) | Small memory footprint system and method for separating applications within a single virtual machine | |
US6041179A (en) | Object oriented dispatch optimization | |
KR970008530B1 (en) | Language neutral objects | |
US6381737B1 (en) | Automatic adapter/stub generator | |
KR950007883B1 (en) | Method and system for managing a set of class | |
US6526570B1 (en) | File portability techniques | |
US6651248B1 (en) | Method and apparatus for efficient interface method dispatch | |
US7765527B2 (en) | Per thread buffering for storing profiling data | |
EP0546794A2 (en) | Object oriented data processing system | |
US6877163B1 (en) | Method and system for dynamic proxy classes | |
EP1178404A2 (en) | Method and system for compiling multiple languages | |
US6557023B1 (en) | Method and apparatus for avoiding array class creation in virtual machines | |
US20010013117A1 (en) | Method and apparatus for finding bugs related to garbage collection in a virtual machine | |
US20020099930A1 (en) | Data processor having translator and interpreter that execute non-native instructions | |
WO2001063405A2 (en) | System and method for minimizing inter-application interference among static synchronized methods | |
US6901586B1 (en) | Safe language static variables initialization in a multitasking system | |
US6119206A (en) | Design of tags for lookup of non-volatile registers | |
EP0619544A2 (en) | Object system with derived metaclasses |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
ENP | Entry into the national phase |
Ref country code: AU Ref document number: 1999 64288 Kind code of ref document: A Format of ref document f/p: F |
|
AK | Designated states |
Kind code of ref document: A2 Designated state(s): AE AL AM AT AU AZ BA BB BG BR BY CA CH CN CR CU CZ DE DK DM EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT TZ UA UG UZ VN YU ZA |
|
AL | Designated countries for regional patents |
Kind code of ref document: A2 Designated state(s): GH GM KE LS MW SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
AK | Designated states |
Kind code of ref document: A3 Designated state(s): AE AL AM AT AU AZ BA BB BG BR BY CA CH CN CR CU CZ DE DK DM EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT TZ UA UG UZ VN YU ZA |
|
AL | Designated countries for regional patents |
Kind code of ref document: A3 Designated state(s): GH GM KE LS MW SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
DFPE | Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101) | ||
REG | Reference to national code |
Ref country code: DE Ref legal event code: 8642 |
|
122 | Ep: pct application non-entry in european phase |