US20020174261A1 - Lightweight native method invocation interface for Java computing environments - Google Patents
Lightweight native method invocation interface for Java computing environments Download PDFInfo
- Publication number
- US20020174261A1 US20020174261A1 US09/858,252 US85825201A US2002174261A1 US 20020174261 A1 US20020174261 A1 US 20020174261A1 US 85825201 A US85825201 A US 85825201A US 2002174261 A1 US2002174261 A1 US 2002174261A1
- Authority
- US
- United States
- Prior art keywords
- java
- native
- parameter
- recited
- programming language
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Classifications
-
- 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
- G06F9/449—Object-oriented method invocation or resolution
Definitions
- the present invention relates generally to object-based high level programming environments, and more particularly, to techniques for invoking native methods in Java computing environments.
- Java programming language is a language that is designed to be portable enough to be executed on a wide range of computers ranging from small devices (e.g., pagers, cell phones and smart cards) up to supercomputers.
- Computer programs written in the Java programming language (and other languages) may be compiled into Java Byte-code instructions that are suitable for execution by a Java virtual machine implementation.
- Java virtual machine is commonly implemented in software by means of an interpreter for the Java virtual machine instruction set but, in general, may be software, hardware, or both.
- interpreter for the Java virtual machine instruction set
- Java virtual machine implementation and corresponding support libraries together constitute a Java runtime environment.
- Computer programs in the Java programming language are arranged in one or more classes or interfaces (referred to herein jointly as classes or class files). Such programs are generally platform, i.e., hardware and operating system, independent. As such, these computer programs may be executed without modification on any computer that is able to run an implementation of the Java runtime environment.
- class file format Object-oriented classes written in the Java programming language are compiled to a particular binary format called the “class file format.”
- the class file includes various components associated with a single class. These components can be, for example, methods and/or interfaces associated with the class.
- the class file format can include a significant amount of ancillary information that is associated with the class.
- the class file format (as well as the general operation of the Java virtual machine) is described in some detail in The Java Virtual Machine Specification, Second Edition , by Tim Lindholm and Frank Yellin, which is hereby incorporated herein by reference.
- a virtual machine operating in a Java computing environment allows for execution of native methods (functions or procedures) written in platform specific programming languages (native languages).
- the Java programming language allows invocation of native methods written in other programming languages (e.g., C, C++, etc.). This means that the processing of the native method is performed by a section of code written in the native programming language. Accordingly, there is a need to convert the parameters (e.g., Java primitive data types, Java reference objects) from Java programming language to parameters suitable for the native language.
- parameters e.g., Java primitive data types, Java reference objects
- Java Native Interface has been developed as an interface between the Java program and the native methods written in programming languages other than Java (e.g., C, C++, etc.).
- Java Native Interface Java Native Interface
- native methods are provided a reference (environment parameter). More particularly, every invocation of a native method passes a reference to a table of functions that are used to facilitate the conversion of parameters from Java to the native language.
- the Java Native Interface UNI does not give direct access to Java parameters (e.g., Java primitive data types, Java reference objects). Instead, these parameters are accessed and indirectly through various Java Native Interface (JNI) methods which perform the conversation. More details about the Java Native Interface (JNI) are provided in Core Java 2. Volume II - Advanced Features , by Cay S. Horstmann and Gary Cornell, which is incorporated by reference herein for all purposes.
- Java Native Interface provides a useful tool for invocation of native programs in Java computing environments
- JNI Java Native Interface
- JNI Java Native Interface
- JNI Java Native Interface
- using the Java Native Interface UNI can have adverse effects on the performance of virtual machines, especially those operating with relatively less memory and/or computing power (e.g., embedded systems).
- the present invention relates to improved techniques for invocation of native methods in Java computing environments. These techniques can be implemented in Java computing environments to facilitate use of methods (functions or subroutines) written in programming languages other than Java (e.g., C, C++, etc.). As will be appreciated, these techniques are highly suitable for use by virtual machines operating with relatively less memory and/or computing power (e.g., embedded systems).
- a lightweight native method invocation interface provides direct access to Java parameters on the execution stack.
- the lightweight native method invocation can include macro instructions that operate efficiently to convert the Java parameters into native parameters.
- the lightweight native method invocation can significantly reduce the overhead associated with conventional Java native method invocation techniques. As a result, performance of virtual machines, especially those operating with relatively less memory and/or computing power, can be improved.
- the invention can be implemented in numerous ways, including as a method, an apparatus, a computer readable medium, and a database system. Several embodiments of the invention are discussed below.
- one embodiment of the invention includes the acts of: providing a reference to one or more Java parameters on a Java execution stack, the one or more Java parameters being parameters associated with the native method; and accessing at least one of the one or more Java parameters based on the reference.
- one embodiment of the invention includes the acts of: providing a reference to one or more Java parameters associated with the native method on a Java execution stack; accessing at least one of the one or more Java parameters based on the reference; converting at least one Java parameter to a native parameter suitable for the native programming language. The converting is performed by a set of macro instructions written in the native programming language.
- one embodiment of the invention includes a native method invocation instruction operating to invoke a native method written in a programming language other than Java.
- the method invocation instruction operates to provide a reference to an entry on an execution stack.
- the entry is a reference to at least one parameter associated with the method invocation instruction; and the reference is provided directly to a set of macro instructions.
- one embodiment of the invention includes computer program code for a lightweight native Java method invocation interface operating in a Java computing environment to facilitate invocation of native methods written in a programming language other than Java.
- the computer program code includes code for a set of macro instructions.
- a reference to an execution stack is provided to a set of macro instructions. The reference provides a reference to at least one parameter associated with the method invocation instruction which is on the execution stack.
- FIG. 1 represents a Java programming environment in accordance with one embodiment of the invention.
- FIG. 2 represents a Java computing environment including a Java execution stack and a native execution stack.
- FIG. 3 illustrates a method for invocation of Java native methods in accordance with one embodiment of the invention.
- the present invention pertains to improved techniques for invocations of native methods in Java computing environments. These techniques can be implemented in Java computing environments to facilitate use of methods (functions or subroutines) written in programming languages other than Java (e.g., C, C++, etc.). As will be appreciated, these techniques are highly suitable for use by virtual machines operating with relatively less memory and/or computing power (e.g., embedded systems).
- a lightweight native method invocation interface provides direct access to Java parameters on the execution stack.
- the lightweight native method invocation can include macro instructions that operate efficiently to convert the Java parameters into native parameters.
- the lightweight native method invocation can significantly reduce the overhead associated with conventional Java native method invocation techniques. As a result, performance of virtual machines, especially those operating with relatively less memory and/or computing power, can be improved.
- FIG. 1 represents a Java programming environment 100 in accordance with one embodiment of the invention.
- the Java programming environment 100 can be implemented by a virtual machine operating in a Java computing environment.
- a Java application program (or applet) 102 uses a lightweight native method invocation interface 104 to access one or more native methods 106 written in a non-Java programming language (e.g., C, C++, etc.).
- a non-Java programming language e.g., C, C++, etc.
- the lightweight native method invocation interface 104 includes a native macro portion 108 which provides the native methods 106 with access to the Java application program (or applet) 102 .
- the native macro portion 108 represents computer instructions typically written in the same programming language as the native methods 106 .
- the macro instructions provided in native macro portion 108 operate to access, and if necessary, convert the Java parameters (e.g., Java primitive data types, Java reference objects). Accordingly, the native macro portion 108 operates to provide access and convert the parameters very efficiently.
- the native macro portion 108 can insulate the native methods 106 from the virtual machine internals.
- the lightweight native method invocation interface 104 can access the Java parameters directly. In comparison to conventional techniques, the lightweight native method invocation interface 104 can significantly reduce the overhead associated with invocation of native methods in Java programming environments.
- the lightweight native method invocation interface 104 provides access to the Java parameters stored on the execution stack.
- FIG. 2 depicts a Java computing environment 200 in accordance to one embodiment of the invention.
- the Java computing environment 200 includes a Java execution stack 202 and a native execution stack 204 .
- the stack frame associated with the method is placed on the execution stack 202 .
- the stack frame can include parameters of the native method which represent one or more Java data types. Accordingly, parameter 1, parameter 2, . . . parameter N, shown in FIG. 2, represent Java parameters associated with the native method. These parameters are converted into native parameter 1, native parameter 2, . . . native parameter M which are placed on the native execution stack 204 to perform the processing of the native method written in another programming language.
- the lightweight Java native method invocation interface 206 accesses parameter reference 208 .
- the parameter reference 208 is a reference to the parameter portion of the stack frame for the native method. Accordingly, parameter 1, parameter 2, . . . parameter N of the native method can quickly be referenced by using the parameter reference 208 (i.e., use parameter reference [i] to access the i th parameters). Using the parameter reference 208 , these parameters can be accessed and converted by the lightweight Java method invocation interface 206 to an appropriate set of native parameters which are, in turn, placed on the native execution stack 204 (native parameter 1, native parameter 2, . . . native parameter M). It should be noted that native parameter 1, native parameter 2, . . . native parameter M are suitable for use by the native method written in a native programming language.
- FIG. 3 illustrates a method for invocation of Java native methods in accordance with one embodiment of the invention.
- one or more Java parameters associated with a Java native method are placed on a Java execution stack.
- a reference is provided to the one more or more Java parameters on the Java execution stack.
- the reference can be provided, for example, to one or more macros written in a native programming language (i.e., a programming language other than Java).
- at operation 306 at least one of the parameters on the Java execution stack is accessed using the provided reference.
- the accessed parameter is converted to a native parameter.
- the native parameter is placed on the native execution stack at operation 310 .
- the native method is executed using the native parameter on the native execution stack.
Abstract
Description
- The present invention relates generally to object-based high level programming environments, and more particularly, to techniques for invoking native methods in Java computing environments.
- Recently, the Java programming environment has become quite popular. The Java programming language is a language that is designed to be portable enough to be executed on a wide range of computers ranging from small devices (e.g., pagers, cell phones and smart cards) up to supercomputers. Computer programs written in the Java programming language (and other languages) may be compiled into Java Byte-code instructions that are suitable for execution by a Java virtual machine implementation.
- The Java virtual machine is commonly implemented in software by means of an interpreter for the Java virtual machine instruction set but, in general, may be software, hardware, or both. A particular Java virtual machine implementation and corresponding support libraries together constitute a Java runtime environment.
- Computer programs in the Java programming language are arranged in one or more classes or interfaces (referred to herein jointly as classes or class files). Such programs are generally platform, i.e., hardware and operating system, independent. As such, these computer programs may be executed without modification on any computer that is able to run an implementation of the Java runtime environment.
- Object-oriented classes written in the Java programming language are compiled to a particular binary format called the “class file format.” The class file includes various components associated with a single class. These components can be, for example, methods and/or interfaces associated with the class. In addition, the class file format can include a significant amount of ancillary information that is associated with the class. The class file format (as well as the general operation of the Java virtual machine) is described in some detail inThe Java Virtual Machine Specification, Second Edition, by Tim Lindholm and Frank Yellin, which is hereby incorporated herein by reference. A virtual machine operating in a Java computing environment allows for execution of native methods (functions or procedures) written in platform specific programming languages (native languages). In other words, the Java programming language allows invocation of native methods written in other programming languages (e.g., C, C++, etc.). This means that the processing of the native method is performed by a section of code written in the native programming language. Accordingly, there is a need to convert the parameters (e.g., Java primitive data types, Java reference objects) from Java programming language to parameters suitable for the native language.
- To achieve this, recently, Java Native Interface (JNI) has been developed as an interface between the Java program and the native methods written in programming languages other than Java (e.g., C, C++, etc.). Using Java Native Interface (JNI), native methods are provided a reference (environment parameter). More particularly, every invocation of a native method passes a reference to a table of functions that are used to facilitate the conversion of parameters from Java to the native language. Thus, the Java Native Interface UNI) does not give direct access to Java parameters (e.g., Java primitive data types, Java reference objects). Instead, these parameters are accessed and indirectly through various Java Native Interface (JNI) methods which perform the conversation. More details about the Java Native Interface (JNI) are provided inCore Java 2. Volume II-Advanced Features, by Cay S. Horstmann and Gary Cornell, which is incorporated by reference herein for all purposes.
- Although the Java Native Interface (JNI) provides a useful tool for invocation of native programs in Java computing environments, there is a significant cost associated with using the Java Native Interface (JNI). In other words, there is a significant amount of memory and runtime overhead associated with the use of the methods of the Java Native Interface (JNI). As a result, using the Java Native Interface UNI) can have adverse effects on the performance of virtual machines, especially those operating with relatively less memory and/or computing power (e.g., embedded systems).
- In view of the foregoing, there is a need for alternative techniques for invocation of native methods in Java computing environments.
- Broadly speaking, the present invention relates to improved techniques for invocation of native methods in Java computing environments. These techniques can be implemented in Java computing environments to facilitate use of methods (functions or subroutines) written in programming languages other than Java (e.g., C, C++, etc.). As will be appreciated, these techniques are highly suitable for use by virtual machines operating with relatively less memory and/or computing power (e.g., embedded systems).
- In accordance with one aspect of the invention, a lightweight native method invocation interface is disclosed. In one embodiment, the lightweight native method invocation provides direct access to Java parameters on the execution stack. In addition, the lightweight native method invocation can include macro instructions that operate efficiently to convert the Java parameters into native parameters. Thus, the lightweight native method invocation can significantly reduce the overhead associated with conventional Java native method invocation techniques. As a result, performance of virtual machines, especially those operating with relatively less memory and/or computing power, can be improved.
- The invention can be implemented in numerous ways, including as a method, an apparatus, a computer readable medium, and a database system. Several embodiments of the invention are discussed below.
- As a method for invoking a native method written in a programming language other than Java, one embodiment of the invention includes the acts of: providing a reference to one or more Java parameters on a Java execution stack, the one or more Java parameters being parameters associated with the native method; and accessing at least one of the one or more Java parameters based on the reference.
- As a method for invoking a native method written in a native programming language other than Java, one embodiment of the invention includes the acts of: providing a reference to one or more Java parameters associated with the native method on a Java execution stack; accessing at least one of the one or more Java parameters based on the reference; converting at least one Java parameter to a native parameter suitable for the native programming language. The converting is performed by a set of macro instructions written in the native programming language.
- As a Java program, one embodiment of the invention includes a native method invocation instruction operating to invoke a native method written in a programming language other than Java. The method invocation instruction operates to provide a reference to an entry on an execution stack. The entry is a reference to at least one parameter associated with the method invocation instruction; and the reference is provided directly to a set of macro instructions.
- As a computer readable media, one embodiment of the invention includes computer program code for a lightweight native Java method invocation interface operating in a Java computing environment to facilitate invocation of native methods written in a programming language other than Java. The computer program code includes code for a set of macro instructions. In addition, a reference to an execution stack is provided to a set of macro instructions. The reference provides a reference to at least one parameter associated with the method invocation instruction which is on the execution stack.
- These and other aspects and advantages of the present invention will become more apparent when the detailed description below is read in conjunction with the accompanying drawings.
- The present invention will be readily understood by the following detailed description in conjunction with the accompanying drawings, wherein like reference numerals designate like structural elements, and in which:
- FIG. 1 represents a Java programming environment in accordance with one embodiment of the invention.
- FIG. 2 represents a Java computing environment including a Java execution stack and a native execution stack.
- FIG. 3 illustrates a method for invocation of Java native methods in accordance with one embodiment of the invention.
- The present invention pertains to improved techniques for invocations of native methods in Java computing environments. These techniques can be implemented in Java computing environments to facilitate use of methods (functions or subroutines) written in programming languages other than Java (e.g., C, C++, etc.). As will be appreciated, these techniques are highly suitable for use by virtual machines operating with relatively less memory and/or computing power (e.g., embedded systems).
- In accordance with one aspect of the invention, a lightweight native method invocation interface is disclosed. In one embodiment, the lightweight native method invocation provides direct access to Java parameters on the execution stack. In addition, the lightweight native method invocation can include macro instructions that operate efficiently to convert the Java parameters into native parameters. Thus, the lightweight native method invocation can significantly reduce the overhead associated with conventional Java native method invocation techniques. As a result, performance of virtual machines, especially those operating with relatively less memory and/or computing power, can be improved.
- Embodiments of the invention are discussed below with reference to FIGS.1-3. However, those skilled in the art will readily appreciate that the detailed description given herein with respect to these figures is for explanatory purposes only as the invention extends beyond these limited embodiments.
- FIG. 1 represents a
Java programming environment 100 in accordance with one embodiment of the invention. TheJava programming environment 100 can be implemented by a virtual machine operating in a Java computing environment. As shown in FIG. 1, a Java application program (or applet) 102 uses a lightweight nativemethod invocation interface 104 to access one or morenative methods 106 written in a non-Java programming language (e.g., C, C++, etc.). - In the described embodiment, the lightweight native
method invocation interface 104 includes a nativemacro portion 108 which provides thenative methods 106 with access to the Java application program (or applet) 102. The nativemacro portion 108 represents computer instructions typically written in the same programming language as thenative methods 106. The macro instructions provided in nativemacro portion 108 operate to access, and if necessary, convert the Java parameters (e.g., Java primitive data types, Java reference objects). Accordingly, the nativemacro portion 108 operates to provide access and convert the parameters very efficiently. In addition, the nativemacro portion 108 can insulate thenative methods 106 from the virtual machine internals. - As will appreciated by those skilled in the art, the lightweight native
method invocation interface 104 can access the Java parameters directly. In comparison to conventional techniques, the lightweight nativemethod invocation interface 104 can significantly reduce the overhead associated with invocation of native methods in Java programming environments. - In one preferred embodiment, the lightweight native
method invocation interface 104 provides access to the Java parameters stored on the execution stack. To illustrate, FIG. 2 depicts aJava computing environment 200 in accordance to one embodiment of the invention. TheJava computing environment 200 includes aJava execution stack 202 and anative execution stack 204. It should be noted that to invoke a native method, the stack frame associated with the method is placed on theexecution stack 202. The stack frame can include parameters of the native method which represent one or more Java data types. Accordingly,parameter 1,parameter 2, . . . parameter N, shown in FIG. 2, represent Java parameters associated with the native method. These parameters are converted intonative parameter 1,native parameter 2, . . . native parameter M which are placed on thenative execution stack 204 to perform the processing of the native method written in another programming language. - As illustrated in FIG. 2, the lightweight Java native
method invocation interface 206 accessesparameter reference 208. Theparameter reference 208 is a reference to the parameter portion of the stack frame for the native method. Accordingly,parameter 1,parameter 2, . . . parameter N of the native method can quickly be referenced by using the parameter reference 208 (i.e., use parameter reference [i] to access the ith parameters). Using theparameter reference 208, these parameters can be accessed and converted by the lightweight Javamethod invocation interface 206 to an appropriate set of native parameters which are, in turn, placed on the native execution stack 204 (native parameter 1,native parameter 2, . . . native parameter M). It should be noted thatnative parameter 1,native parameter 2, . . . native parameter M are suitable for use by the native method written in a native programming language. - FIG. 3 illustrates a method for invocation of Java native methods in accordance with one embodiment of the invention. Initially, at
operation 302, one or more Java parameters associated with a Java native method are placed on a Java execution stack. Next, atoperation 304, a reference is provided to the one more or more Java parameters on the Java execution stack. The reference can be provided, for example, to one or more macros written in a native programming language (i.e., a programming language other than Java). Thereafter, atoperation 306, at least one of the parameters on the Java execution stack is accessed using the provided reference. After the parameter has been accessed, atoperation 308 the accessed parameter is converted to a native parameter. Thereafter, the native parameter is placed on the native execution stack atoperation 310. Finally, atoperation 312, the native method is executed using the native parameter on the native execution stack. - The many features and advantages of the present invention are apparent from the written description, and thus, it is intended by the appended claims to cover all such features and advantages of the invention. Further, since numerous modifications and changes will readily occur to those skilled in the art, it is not desired to limit the invention to the exact construction and operation as illustrated and described. Hence, all suitable modifications and equivalents may be resorted to as falling within the scope of the invention.
Claims (20)
Priority Applications (4)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US09/858,252 US6934946B2 (en) | 2001-05-15 | 2001-05-15 | Lightweight native method invocation interface for java computing environments |
GB0320725A GB2388689B (en) | 2001-05-15 | 2002-05-09 | Lightweight native method invocation interface for java computing environments |
AU2002303688A AU2002303688A1 (en) | 2001-05-15 | 2002-05-09 | Lightweight native method invocation interface for java computing environments |
PCT/US2002/014615 WO2002093366A2 (en) | 2001-05-15 | 2002-05-09 | Lightweight native method invocation interface for java computing environments |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US09/858,252 US6934946B2 (en) | 2001-05-15 | 2001-05-15 | Lightweight native method invocation interface for java computing environments |
Publications (2)
Publication Number | Publication Date |
---|---|
US20020174261A1 true US20020174261A1 (en) | 2002-11-21 |
US6934946B2 US6934946B2 (en) | 2005-08-23 |
Family
ID=25327866
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/858,252 Expired - Lifetime US6934946B2 (en) | 2001-05-15 | 2001-05-15 | Lightweight native method invocation interface for java computing environments |
Country Status (4)
Country | Link |
---|---|
US (1) | US6934946B2 (en) |
AU (1) | AU2002303688A1 (en) |
GB (1) | GB2388689B (en) |
WO (1) | WO2002093366A2 (en) |
Cited By (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20050222979A1 (en) * | 2004-03-31 | 2005-10-06 | Gansha Wu | Querying method information |
CN103093136A (en) * | 2012-12-27 | 2013-05-08 | 飞天诚信科技股份有限公司 | Method enabling java application to access to intelligent secret key device |
US20200117501A1 (en) * | 2018-10-15 | 2020-04-16 | Ca, Inc. | Customizing jvm native services |
Families Citing this family (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8296745B2 (en) * | 2007-12-31 | 2012-10-23 | Oracle America, Inc. | Method and apparatus for portable stub generation |
US8943472B1 (en) * | 2008-07-30 | 2015-01-27 | Dulles Research LLC | System and method for directly accessing SAS datasets from a JAVA program |
US8776033B2 (en) | 2010-12-23 | 2014-07-08 | International Business Machines Corporation | Batch dispatch of java native interface calls |
US11809839B2 (en) | 2022-01-18 | 2023-11-07 | Robert Lyden | Computer language and code for application development and electronic and optical communication |
Citations (6)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6167565A (en) * | 1998-01-08 | 2000-12-26 | Microsoft Corporation | Method and system of custom marshaling of inter-language parameters |
US6282702B1 (en) * | 1998-08-13 | 2001-08-28 | Sun Microsystems, Inc. | Method and apparatus of translating and executing native code in a virtual machine environment |
US6314445B1 (en) * | 1998-08-03 | 2001-11-06 | International Business Machines Coproration | Native function calling |
US6381734B1 (en) * | 1998-06-03 | 2002-04-30 | Microsoft Corporation | Method, software and apparatus for referencing a method in object-based programming |
US6481006B1 (en) * | 1999-05-06 | 2002-11-12 | International Business Machines Corporation | Method and apparatus for efficient invocation of Java methods from native codes |
US6651248B1 (en) * | 2000-09-01 | 2003-11-18 | International Business Machines Corporation | Method and apparatus for efficient interface method dispatch |
Family Cites Families (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5911069A (en) * | 1996-09-30 | 1999-06-08 | Apple Computer, Inc. | Exception handling techniques for native methods bound to SOM classes |
US6067577A (en) * | 1996-09-30 | 2000-05-23 | Apple Computer, Inc. | Dynamic method resolution for native methods in a dynamic object-oriented programming language |
US5875335A (en) * | 1996-09-30 | 1999-02-23 | Apple Computer, Inc. | Parameter marshaling techniques for dynamic object-oriented programming languages |
US6327606B1 (en) * | 1998-06-24 | 2001-12-04 | Oracle Corp. | Memory management of complex objects returned from procedure calls |
US6519605B1 (en) * | 1999-04-27 | 2003-02-11 | International Business Machines Corporation | Run-time translation of legacy emulator high level language application programming interface (EHLLAPI) calls to object-based calls |
-
2001
- 2001-05-15 US US09/858,252 patent/US6934946B2/en not_active Expired - Lifetime
-
2002
- 2002-05-09 AU AU2002303688A patent/AU2002303688A1/en not_active Abandoned
- 2002-05-09 GB GB0320725A patent/GB2388689B/en not_active Expired - Lifetime
- 2002-05-09 WO PCT/US2002/014615 patent/WO2002093366A2/en not_active Application Discontinuation
Patent Citations (6)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6167565A (en) * | 1998-01-08 | 2000-12-26 | Microsoft Corporation | Method and system of custom marshaling of inter-language parameters |
US6381734B1 (en) * | 1998-06-03 | 2002-04-30 | Microsoft Corporation | Method, software and apparatus for referencing a method in object-based programming |
US6314445B1 (en) * | 1998-08-03 | 2001-11-06 | International Business Machines Coproration | Native function calling |
US6282702B1 (en) * | 1998-08-13 | 2001-08-28 | Sun Microsystems, Inc. | Method and apparatus of translating and executing native code in a virtual machine environment |
US6481006B1 (en) * | 1999-05-06 | 2002-11-12 | International Business Machines Corporation | Method and apparatus for efficient invocation of Java methods from native codes |
US6651248B1 (en) * | 2000-09-01 | 2003-11-18 | International Business Machines Corporation | Method and apparatus for efficient interface method dispatch |
Cited By (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20050222979A1 (en) * | 2004-03-31 | 2005-10-06 | Gansha Wu | Querying method information |
CN103093136A (en) * | 2012-12-27 | 2013-05-08 | 飞天诚信科技股份有限公司 | Method enabling java application to access to intelligent secret key device |
US20200117501A1 (en) * | 2018-10-15 | 2020-04-16 | Ca, Inc. | Customizing jvm native services |
Also Published As
Publication number | Publication date |
---|---|
AU2002303688A1 (en) | 2002-11-25 |
US6934946B2 (en) | 2005-08-23 |
GB0320725D0 (en) | 2003-10-08 |
GB2388689B (en) | 2005-07-20 |
WO2002093366A2 (en) | 2002-11-21 |
WO2002093366A3 (en) | 2004-10-14 |
GB2388689A (en) | 2003-11-19 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
EP4099152B1 (en) | Extending a virtual machine instruction set architecture | |
US7941802B2 (en) | Reduced instruction set for java virtual machines | |
US20030041317A1 (en) | Frameworks for generation of java macro instructions for storing values into local variables | |
US7003778B2 (en) | Exception handling in java computing environments | |
US7020874B2 (en) | Techniques for loading class files into virtual machines | |
US6964033B2 (en) | Object band customization of Java runtime environments | |
US6959430B2 (en) | Specialized heaps for creation of objects in object-oriented environments | |
US6934946B2 (en) | Lightweight native method invocation interface for java computing environments | |
US6901591B1 (en) | Frameworks for invoking methods in virtual machines | |
US6804681B2 (en) | Identifying and tracking object references in a java programming environment | |
US6957428B2 (en) | Enhanced virtual machine instructions | |
US7036120B2 (en) | Two tier clusters for representation of objects in Java programming environments | |
US7065747B2 (en) | Identifying references to objects during bytecode verification | |
US7181724B2 (en) | Representation of Java® data types in virtual machines | |
US6918109B2 (en) | Execution of synchronized Java methods in Java computing environments | |
US6934726B2 (en) | Storing and retrieving of field descriptors in Java computing environments | |
US6751790B2 (en) | Frameworks for efficient representation of string objects in Java programming environments | |
US20030041322A1 (en) | Frameworks for generation of java macro instructions for instantiating java objects | |
US7082597B2 (en) | Representation of objects in a Java programming environment | |
US20030005170A1 (en) | Java bytecode instruction for determining hashcode values |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: SUN MICROSYSTEMS, IMC., CALIFORNIA Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:SOKOLOV, STEPAN;WALLMAN, DAVID;REEL/FRAME:011816/0594 Effective date: 20010514 |
|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
CC | Certificate of correction | ||
FPAY | Fee payment |
Year of fee payment: 4 |
|
FPAY | Fee payment |
Year of fee payment: 8 |
|
AS | Assignment |
Owner name: ORACLE AMERICA, INC., CALIFORNIA Free format text: MERGER AND CHANGE OF NAME;ASSIGNORS:ORACLE USA, INC.;SUN MICROSYSTEMS, INC.;ORACLE AMERICA, INC.;REEL/FRAME:039604/0471 Effective date: 20100212 |
|
FPAY | Fee payment |
Year of fee payment: 12 |