WO2010086155A1 - Application of platform dependent routines in virtual machines by embedding native code in class files - Google Patents
Application of platform dependent routines in virtual machines by embedding native code in class files Download PDFInfo
- Publication number
- WO2010086155A1 WO2010086155A1 PCT/EP2010/000493 EP2010000493W WO2010086155A1 WO 2010086155 A1 WO2010086155 A1 WO 2010086155A1 EP 2010000493 W EP2010000493 W EP 2010000493W WO 2010086155 A1 WO2010086155 A1 WO 2010086155A1
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- virtual machine
- file
- native
- application file
- application
- Prior art date
Links
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/44—Encoding
- G06F8/443—Optimisation
-
- 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/445—Exploiting fine grain parallelism, i.e. parallelism at instruction level
-
- 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/445—Program loading or initiating
- G06F9/44552—Conflict resolution, i.e. enabling coexistence of conflicting executables
Definitions
- the present disclosure generally relates techniques for operating an electronic device comprising at least a central processing unit on the basis of platform independent software, wherein the platform is provided by a virtual machine that simulates a standard hardware environment.
- a CPU may be operated on the basis of a dedicated byte code or machine code, which may result in a corresponding change of state of hardware components, such as registers, I/O (input/output) terminals and the like in accordance with the sequence of machine code instructions.
- hardware components such as registers, I/O (input/output) terminals and the like.
- the corresponding sequence of byte code instructions has to be executed by the CPU, thereby providing the desired results in the form of register contents and the like.
- the development of a corresponding more or less complex sequence of machine code instructions may be extremely time consuming and may also require specific skills in "translating" a corresponding problem or object to be solved by a specified application in to a sequence of machine code instructions.
- object oriented programming has become a frequently used technique in which it is attempted to map everyday life situations more conveniently into a computer programme. That is, according to the object oriented approach, specific objects or classes may be defined so as to have basic features which may respond to certain events in a predefined manner. In this way, very complex applications may be created, wherein respective objects may repeatedly be used in different applications in a very convenient manner, thereby avoiding the repeated development of the same software.
- a steadily increasing amount of computer systems may be connectible by any appropriate network, such as the internet, based on wireless and cable based network channels so that applications may be conveyed to a user via the network, wherein the hardware configuration of a specific target system may not be known in advance.
- any appropriate network such as the internet, based on wireless and cable based network channels so that applications may be conveyed to a user via the network, wherein the hardware configuration of a specific target system may not be known in advance.
- the concept of providing platform independent applications is actually based on the introduction of a "virtual" computer system or virtual machine which may be operated on a specific virtual byte code that is provided by the platform independent application.
- the virtual machine actually simulates a hardware configuration and thus acts as an interface between the platform independent application and the specific hardware configuration.
- a plurality of virtual machines may be available that provide the standard form executed "platform independent" applications while interfacing with dedicated hardware configurations in combination with associated operating systems. Consequently, when an appropriate virtual machine is installed in a computer system, or any other electronic device, an application may be developed and may be executed by the virtual machine independent of the hardware configuration.
- the programming language JAVA of Sun Microsystems represents an object oriented language in which applications may efficiently be programmed without requiring an adaptation to different operating systems of the specific computer platforms. If a user starts a JAVA programme the JAVA virtual machine is automatically started and loads corresponding class files, which may then be interpreted to generate the "machine code" of the virtual machine. If further classes may be required for forming the application under consideration, these classes may be loaded on demand during run time and may also be interpreted as required. For example, many classes are available for the virtual machine and may be implemented in a corresponding library.
- the actual CPU executes the machine code responding to the virtual machine thereby requiring memory for storing the state of the processor, for instance in the form of IRQ (interrupt request) addresses and the like.
- the processor, the machine code and the state memory define the virtual machine.
- the virtual machine executes the application corresponding to the compiled programme of the application thereby also requiring a dedicated state memory in which any specific information of the virtual machine may be stored. For example, a table of each version of classes that simultaneously exists in the virtual machine, may be stored.
- the virtual machine, the programme loaded therein and the respective virtual specific state memory thus realize the actual application.
- the format of any input is specified, ie.
- the desired platform independent functionality of JAVA applications are realized in the following manner.
- the input for the JAVA virtual machine or class files may contain any information about the desired application.
- the class files have a specific structure which is realized by a plurality of sections which contain required information, such as constant pool entries, method and field descriptions, code and debug information and the like. Consequently, upon loading and interpreting a corresponding class file, the information contained in these standard sections may be used for verifying and preparing the class file for being executed by the virtual machine.
- a class may be understood as representation of a plurality of similar objects which may have attributes and methods.
- An attribute may be considered as a constant or a variable having a specific type.
- a method may be understood as a "function" which may thus represent a sequence of process steps represented by a table of byte codes, ie. machine instructions of the virtual machine that have to be executed in order to define a specified programme sequence.
- the byte code of the virtual machine may represent a similar level of abstraction as an assembler instruction, previously explained. Thus, for each method corresponding local variables may have to be stored in combination with additional information with respect to the maximum amount of memory space required and the like.
- the virtual machine comprises a class loader that is responsible for "converting" the class information externally stored in class files into channel run time structures.
- the class loader may verify the consistency of the class under consideration, for instance in view of verifying that each part of the file is accessible via the programme and the like. When the verification is completed without identifying any errors the class loader loads the information into the virtual machine and initiates the byte code executor of the virtual machine.
- the virtual machine executor is responsible for executing methods on the basis of byte codes, as described above. If an instruction for generating a version of a respective class is encountered, the byte code executing unit detects whether or not this class has already been loaded. Consequently, corresponding class files may be loaded into the virtual machine upon request during run time, where corresponding class files may be provided by any appropriate source, such as a local storage platform under consideration, a remote computer and the like.
- the class file may include a reference to a "native method”, which is to be understood as a platform specific set of instructions appropriate for performing a certain sequence of programme steps with high efficiency on the basis of platform internal resources.
- Native methods may typically be provided in the form of appropriate libraries, such as dynamic link libraries (DLL) used in the .
- the present disclosure relates to systems and methods in which native methods may efficiently be used in an otherwise platform independent application, while avoiding or at least reducing the effects of one or more of the problems identified above.
- the present disclosure relates to techniques and systems in which native code may efficiently be used in an application file that has to be executed by a virtual machine.
- a mechanism may be applied in which native code may be embedded into the application file, such as a JAVA class file, which may be used as a library when a request for a native method may be detected in the application file.
- the embedded native code may appropriately be "hidden" within the class file so as to be ignored by the virtual machine when executing the virtual machine specific byte code of the application file.
- the otherwise "hidden" embedded native code possibly in combination with additional information for managing the embedded native code and the like may be used as a basis for surfacing any request for a native method detected in the actual virtual machine .
- the embedded native code may be copied to storage available for the virtual machine and may be used for any further library finding operations or the application file under consideration. Consequently, respective high efforts for adding dependencies with respect to native methods to the virtual machine's file path, for instance to the class path of a JAVA virtual machine, and also to augment the application's library path to ensure that the address native code library is also available to the virtual machine. Additionally, other alternative, such as the copying of the native code library under consideration to some directory that is considered as being known to be currently a path may be avoided so that any risk of libraries clashing in this limited named space along the library path may also be avoided.
- a user-friendly mechanism may be provided in which the degree of platform independence, which may be restricted to a certain degree by a necessity of platforms specifically taking care of the availability of a native code library, may be re-established by providing the native code segment or library, possibly in combination with additional information, within a class file and providing for the possibility of identifying reference to a native method and using embedded native code for resolving corresponding requests.
- One illustrative electronic device disclosed herein comprises a hardware system comprising a central processing unit (CPU), a storage and a bus system connecting the central processing unit and the storage. Furthermore, a virtual machine instruction set implemented in the hardware system is provided and is configured to provide a virtual machine for interpreting application specific instructions into virtual machine specific byte code and executing the virtual machine specific byte code. Furthermore, the electronic device comprises an application file containing a set of application specific instructions to be interpreted into the virtual machine specific byte code, wherein the set of application specific instructions contains a request for a native method. Furthermore, the application file further contains an embedded native code segment that is used for servicing the request upon executing the application file in the virtual machine.
- One illustrative method disclosed herein relates to executing instructions in a virtual machine implemented in a hardware system comprising at least a central processing unit.
- the method comprises providing an application file containing platform independent instructions interpretable into virtual machine specific byte code that is executable by the virtual machine, wherein the application file further contains embedded native code configured to enable execution of native methods in said hardware system.
- the method comprises searching for a request for a native method in the platform independent instructions and surfacing the request on the basis of the embedded native code when the embedded native code comprises an implementation of the native method for the hardware system.
- One illustrative storage medium disclosed herein comprises an application file based on computer readable information.
- the application file comprises a set of platform independent instructions interpretable into byte code that is executable by a virtual machine installed on a hardware system comprising a CPU, wherein the set of platform independent instructions comprises a request for a native method to be executed on the basis of a hardware system specific instruction set.
- the application file of said storage medium comprises a native code library including at least one implementation of the native method.
- One further illustrative storage medium disclosed herein comprises a data file based on computer readable information.
- the data file comprises a set of platform independent instructions interpretable into byte code that is executable by a virtual machine installed on a hardware system comprising a CPU, wherein the set of platform independent instructions causes the virtual machine to perform the following acts: finding an application file requested by the virtual machine, loading the application file into the virtual machine and searching for a request for a native method contained in a platform independent instruction set provided in the application file and searching for an embedded native code library in the application file upon finding the request for the native method.
- FIG. 1a schematically illustrates a diagram of a hardware configuration which may represent an electronic device, a computer system and the like in which a virtual machine is installed including a mechanism for handling the request for native methods on the basis of native code embedded into an application file according to illustrative embodiments;
- Fig 1b schematically illustrates an example of a file structure including embedded native code segments according to illustrative embodiments
- Fig 1c schematically illustrates a portion of a virtual machine that is appropriately configured for handling embedded native code segments, for instance in the form of a modified class loader in a JAVA environment;
- Fig 1d schematically illustrates a mechanism implemented in the virtual machine for handling requests for native methods, for instance on the basis of the modified class loader of Fig 1c, according to still further illustrative embodiments.
- the present disclosure addresses the problem of handling a request for native methods to be performed in an otherwise platform independent virtual machine by embedding native code or libraries into the application file, which may not be "visible" for the virtual machine during run time, ie. after interpreting the application file, but may be used during preparing application files for being executed in the virtual machine.
- the platform independent instructions of the application file may be searched for any reference to a native method, for instance upon verifying consistency and other features of the application file and, if corresponding reference is found, searching for embedded native code, which may be readable for the virtual machine prior to the actual run time of the application file under consideration.
- the embedded native code may be associated with appropriate additional "housekeeping" information so as to enable an appropriate response with respect to the request for a native method.
- the embedded code and/or the additional information may be searched for an appropriate implementation of the requested native method and may, if an appropriate implementation is detected, be copied to an appropriate storage place so as to be accessible for the virtual machine during run time of the application file.
- the corresponding copy of the native code segment may be used, thereby avoiding user initiated platform specific operations in ensuring availability of a native code library during run time of the application file.
- platform specific features may be incorporated into the platform independent application thereby extending the resources and thus performance of the platform independent application without requiring specific knowledge of the hardware system under consideration.
- the feature of platform independence may be extended to a certain degree by simplifying the incorporation of native methods.
- the systems and mechanisms described herein may be highly advantageous in combination with a JAVA virtual machine since here efficient tools may be available for implementing the mechanism since, for instance, the class file structure for a JAVA virtual machine may allow the incorporation of additional sections, which may be ignored by the virtual machine upon run time, as long as the standard class sections meet the requirements in view of security, consistency and the like. Additionally, in JAVA a part of the virtual machine responsible for "preparing" the class files or execution by the virtual machine may readily be modified so as to enable access to additional information provided in the class file, which may then appropriately be used for providing native codes or libraries during run time of the class file under consideration.
- Fig 1a schematically illustrates an electronic device 150 which may represent a computer system of any type, such as a mobile computer, for instance in the form of a handheld PDA (personal digital assistant), a laptop and the like, a stationary computer system and the like.
- the electronic device 150 may represent any device, such as a mobile phone, an electronic circuitry including sensor elements and the like, which may comprise appropriate computational resources for establishing a virtual machine.
- the electronic device 150 may comprise a platform 100, which is to be understood as a hardware configuration providing for the resources required for implementing a virtual machine, wherein the hardware configuration may be operated in combination with a dedicated operating system, as may typically be used in computer systems.
- the platform 106 may comprise at least a central processing unit 101 , such as any type of microprocessor, microcontroller and the like, in which electronic circuitry may provide the required hardware components, such as a CPU core, buffer memories, internal signal buses, supply voltage sources and the like.
- the CPU 101 may not necessarily be provided as a single chip component but may comprise a plurality of individual semiconductor chips so as to obtain the desired functionality, depending on the overall complexity of the platform 100.
- a storage 102 may be provided and may have any appropriate configuration, for instance the storage 102 may comprise non-volatile memories, such as a hard disk, flash memories and the like and/or volatile memory devices in the form of RAM (random access memory) devices and the like.
- the CPU 101 and the storage 102 may be connected by a bus system 103 so as to enable data exchange between the CPU 101 and the storage 102.
- a bus system 103 so as to enable data exchange between the CPU 101 and the storage 102.
- any further components such as voltage sources, I/O components and the like may be provided in accordance with the configuration of the platform 100, wherein these components are not shown.
- the platform 100 may comprise an operating system (OS) 104, which may be understood as an appropriate set of instruction executed in the CPU 101 during operation of the device 150, thereby providing an interface between platform specific applications and the CPU 101.
- OS operating system
- the operating system 104 may coordinate the processing of one or more platform specific applications and may also provide the plurality of defined applications, which may be referred to as libraries 104a and which may be available for corresponding platform specific applications in order to enhance the overall performance. It should be appreciated that an application that may directly be supplied to the operating system 104 may be referred herein as platform specific applications, since this type of application have to be developed by taking into consideration at least specific features of the operating system 104, while also in many cases hardware specific features of the CPU 101 , the storage 102 and/or the bus system 103 may have to be taken into consideration.
- the electronic device 150 may comprise a virtual machine, which may be understood as a platform dependent application for the platform 100, ie. the virtual machine 110 may represent a plurality of platform specific instructions which, when executed by the platform 100, may simulate a platform having well defined standard characteristics with respect to an application executed by the virtual machine 110.
- the virtual machine 110 may represent, with respect to the platform 100, a platform specific application that in turn represents a standard operating environment for any application dedicated for the virtual machine 110.
- an application for the virtual machine 110 irrespective of the configuration of the platform 100, may be referred to a platform independent application.
- the virtual machine may comprise a byte code execution unit 111 and a loading unit 112, which is indicated as a class loader when the virtual machine represents a JAVA virtual machine (JVM).
- the electronic device 150 may comprise one or more sources of application files such as a database 113, which may be associated with the application representing the virtual machine 110, applications provided from a remote computer system or any other file supplier, for instance via any appropriate network, such as the internet, as indicated by 114, application specific files 115, which may locally be stored in the platform 100 and the like.
- At least one of the file sources 113, 114 and 115 may contain an application file 120, which may maintain a request for native code so as to take advantage of platform specific libraries, such as the libraries 104a.
- a corresponding application file may contribute to a certain degree of platform dependency, since respective methods are required for ensuring availability of corresponding native code resources during run time of the application file in the virtual machine 110.
- the application file 120 which may also be referred to as class file when the virtual machine represents a JAVA environment, may contain native code 125 in addition to platform independent instructions that may be processed by the byte code execution unit 111.
- the native code or library 125 may represent an instruction set appropriate for executing a native method, which may directly be processed by the platform 100 on the basis of an appropriate interface system (not shown), thereby providing for enhanced performance of an application or part thereof corresponding to the file 120.
- the native code 125 may be embedded such that the operation of the unit 111 may not be affected by the presence of the native code 125 so that the corresponding platform independent instructions 121 may be processed without interference.
- the native code 125 may efficiently be used upon "preparing" the application file 120 by the unit 112 so as to enable access to the native code or a copy thereof during the actual run time of the application file 120.
- the unit 112 such as a JAVA class loader, may basically service a request for an application file, such as a class file issued by the unit 111.
- the servicing of a corresponding request for an application file may include the search for a corresponding application file, for instance the various sources 113, 114 and 115 may be searched and may include verification of specific features of class files, such as consistency with language specific format requirements, security aspects and the like.
- the application file may be resolved, ie. the file may be completely prepared for execution.
- the activity of the unit 112 may include operations such as converting the platform independent instruction set contained in the data 121 into a run time format to be used by the unit 111. Additionally, the unit 112 may detect requests for a native method in the platform independent instructions and may, upon detection, search for an appropriate implementation of the native method within the native code segment 125. If an appropriate implementation is identified in the segment 125, preparation of the application file 120 may be continued by ensuring accessibility of the appropriate implementation, for instance by copying at least a portion of the segment 125 into a dedicated memory space and using the corresponding memory space for further library link operations that may be required in the application file 120.
- Fig 1b schematically illustrates a schematic view of the application file 120 according to one illustrative embodiment.
- the application file 120 may represent a class file for a JAVA environment, wherein the "standard" JAVA information contents 121 may have to be provided in a specific format determined by the JAVA language specifications, which are well known in the art. For example, a plurality of sections, here indicated in a simplified manner as magic number, version, constant pool, access, class, interface, fields, method and attribute may have to be used so as to be consistent with the JAVA language.
- consistency of the sections of the contents 121 may be verified, while during this phase any additional sections which are indicated as "lib 1", “lib 2", ..., "lib information" may be ignored with respect to consistency with corresponding language specifications.
- the additional sections which may also be indicated as sections 125a 125n may be "invisible" during verifying consistency of the sections of the portion 121 by, for instance, providing an appropriate section header that does not interfere with the language specifications indicating the sections 125a, ..., 125n as non-standard sections. It should be appreciated that one of the sections 125n may comprise any additional information for appropriately using the native code segments, while in other cases each of the sections 125a 125n may comprise the corresponding "housekeeping" information, for instance for identifying respective native methods for which an implementation is provided and for which corresponding implementations are relevant.
- corresponding application files may be provided with a certain degree of platform independence by incorporating a plurality of platform specific features for different types of platform, thereby significantly enhancing performance and user-friendliness of the corresponding applications.
- a certain basic application would be enhanced in performance by incorporating platform specific characteristics, wherein basically the same application may be dedicated to different platforms by incorporating the different platform specific information.
- Fig 1c schematically illustrates a structure of the unit 112, which may itself by implemented in the form of an application executable by a virtual machine 110.
- JAVA represents an object oriented language in which certain properties of basic or parent classes may be inherited by the child classes, wherein some of these properties, that is, methods, may be overwritten so as to extend various capabilities of the parent class.
- a standard class loader of the JAVA environment may represent the parent class and a modified class loader may be defined by implementing the capability of handling the native code segment 125 of the application file 120 (cf. Fig 1b) so as to appropriately service the request for native methods.
- the loader unit 112 may comprise a plurality of methods which may be inherited by the parent class loader and which may not be changed since these methods may be indicated as "final", as indicated by reference sign 114.
- the load class method of the parent class loader may be extended so as to include handling of the native code segment, thereby obtaining a corresponding method 113.
- Fig 1d schematically illustrates an illustrative mechanism for implementing the required functionality of handling native code segments while nevertheless providing for the possibility of verifying consistency of the standard information content, such as the portion 121 (cf. Fig 2e).
- the load class method 113 may comprise a first step 113a in order to identify a request for a native method in the corresponding platform independent instruction 121 of the class file 120, as shown in Fig 2b. If a corresponding request for a native method may not be detected in step 113a, the load class method may continue with a default behaviour, as indicated by step 113b. In this case, verification of consistency and the like may be performed in the usual manner.
- step 113a When a request for a native method is detected in step 113a, the mechanism may continue to step 113c, in which it is searched for any embedded native code in the application file.
- the load class method may appropriately be configured so as to identify respective additional sections or any other information provided in the additional sections
- 125a 125n so that the presence of the embedded native code may be detected and also further information with respect to the request for a native method may be assessed. For example, based on the additional information that may be obtained in the sections 125a 125n of Fig 2b, it may be assessed whether or not an appropriate implementation for the requested native method is available. If the corresponding embedded native code is not detected or an appropriate implementation is not available within the embedded native code, the mechanism may advance to step 113b and apply a default behaviour.
- the associated native code segment, or a portion thereof, such as a specific DLL or shared library may be copied to a dedicated memory space and may be used for further library find operations of the class file under consideration. Thereafter, further required methods may be performed by the class loader 112, in which the class file under consideration may then be prepared for being executed by the unit 111 (cf. Fig 1a), for instance by applying the methods 114 of Fig 1c.
- the embedded native code segment 125 (cf. Fig 1c) may remain invisible and may thus not interfere with the execution of the instructions in the portion 121 (cf. Fig 1d).
- the present disclosure provides electronic devices that may be operated on the basis of a virtual machine and application files having an embedded native code segment for providing the possibility of efficiently using platform specific features without requiring user interaction.
- the specific application files may be provided by any source, such as by a remote computer system via any appropriate network, or by any other appropriate storage medium that may be accessed by the target platform.
- the virtual machine may have implemented therein an appropriate mechanism for detecting a request for native methods, in which case the respective application file may be searched for embedded native code segments, which may then be used for any library incorporations required by the application file.
- a modified class loader may be provided, for instance on the basis of any computer readable storage medium and may be incorporated into the virtual machine mechanism so as to provide for the extended functionality.
- JAVA applications which may require native methods
- enhanced versions of native methods for specific platforms may be packaged in a highly efficient manner, which may then be efficiently "resolved" by the virtual machine, for instance the class loader, for instance by any appropriate technique, such as pattern matching mechanisms and the like, so as to select an optimum implementation during run time.
- multiple versions of one or more classes may be loaded into the vertical machine at the same time, even if different native methods may be requested by the various versions since a conflict of libraries may efficiently be avoided by the mechanisms described above.
Abstract
Description
Claims
Priority Applications (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
CN201080013818.7A CN102388363B (en) | 2009-01-30 | 2010-01-27 | Electron device and perform the method for instruction in virtual machine |
JP2011546708A JP5401561B2 (en) | 2009-01-30 | 2010-01-27 | Application of platform-dependent routines within a virtual mechanism by embedding native code in a class file |
Applications Claiming Priority (4)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
DE102009006882A DE102009006882A1 (en) | 2009-01-30 | 2009-01-30 | Application of platform-dependent routines in virtual machines by embedding a native encoding in class files |
DE102009006882.1 | 2009-01-30 | ||
US12/693,810 US8510725B2 (en) | 2009-01-30 | 2010-01-26 | Application of platform dependent routines in virtual machines by embedding native code in class files |
US12/693,810 | 2010-01-26 |
Publications (1)
Publication Number | Publication Date |
---|---|
WO2010086155A1 true WO2010086155A1 (en) | 2010-08-05 |
Family
ID=42017906
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/EP2010/000493 WO2010086155A1 (en) | 2009-01-30 | 2010-01-27 | Application of platform dependent routines in virtual machines by embedding native code in class files |
Country Status (1)
Country | Link |
---|---|
WO (1) | WO2010086155A1 (en) |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN103136004A (en) * | 2011-11-25 | 2013-06-05 | 联想(北京)有限公司 | Method of application program hardware architecture display and device |
Citations (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6295638B1 (en) * | 1998-07-30 | 2001-09-25 | International Business Machines Corporation | Method and apparatus for loading native object code in data processing system |
US6542887B1 (en) * | 1999-10-29 | 2003-04-01 | International Business Machines Corporation | Incorporating native code in Java archive files |
US6571388B1 (en) * | 1999-03-09 | 2003-05-27 | Hewlett-Packard Development Company, L.P. | Building a custom software environment including pre-loaded classes |
US6862683B1 (en) * | 2000-03-24 | 2005-03-01 | Novell, Inc. | Method and system for protecting native libraries |
WO2006038103A1 (en) * | 2004-10-09 | 2006-04-13 | Axalto S.A | System and method for post-issuance code update employing embedded native code. |
-
2010
- 2010-01-27 WO PCT/EP2010/000493 patent/WO2010086155A1/en active Application Filing
Patent Citations (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6295638B1 (en) * | 1998-07-30 | 2001-09-25 | International Business Machines Corporation | Method and apparatus for loading native object code in data processing system |
US6571388B1 (en) * | 1999-03-09 | 2003-05-27 | Hewlett-Packard Development Company, L.P. | Building a custom software environment including pre-loaded classes |
US6542887B1 (en) * | 1999-10-29 | 2003-04-01 | International Business Machines Corporation | Incorporating native code in Java archive files |
US6862683B1 (en) * | 2000-03-24 | 2005-03-01 | Novell, Inc. | Method and system for protecting native libraries |
WO2006038103A1 (en) * | 2004-10-09 | 2006-04-13 | Axalto S.A | System and method for post-issuance code update employing embedded native code. |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN103136004A (en) * | 2011-11-25 | 2013-06-05 | 联想(北京)有限公司 | Method of application program hardware architecture display and device |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US7337434B2 (en) | Off-device class/resource loading methods, systems and computer program products for debugging a Java application in a Java micro device | |
US7614051B2 (en) | Creating file systems within a file in a storage technology-abstracted manner | |
US7181610B2 (en) | Method and system to encapsulate a driver written for an operating system (OS) runtime environment in an OS independent environment firmware extension | |
US8510725B2 (en) | Application of platform dependent routines in virtual machines by embedding native code in class files | |
US10140119B2 (en) | Modular serialization | |
CN107924326B (en) | Overriding migration methods of updated types | |
US10789047B2 (en) | Returning a runtime type loaded from an archive in a module system | |
US10417024B2 (en) | Generating verification metadata and verifying a runtime type based on verification metadata | |
JPH10228381A (en) | Method and device for loading library to built-in system | |
US9235389B2 (en) | Method of providing embedded software development tool for supporting embedded software development environment based on native building, and apparatus thereof | |
US20080005727A1 (en) | Methods, systems, and computer program products for enabling cross language access to an addressable entity | |
US11687388B2 (en) | Implementing optional specialization when executing code | |
US20080141219A1 (en) | Multiple inheritance facility for java script language | |
US10387142B2 (en) | Using annotation processors defined by modules with annotation processors defined by non-module code | |
WO2010086155A1 (en) | Application of platform dependent routines in virtual machines by embedding native code in class files | |
KR100478463B1 (en) | Dynamic Linking Method for Application Program | |
Mukherjee et al. | Develop once deploy anywhere achieving adaptivity with a runtime linker/loader framework | |
CN115878197A (en) | Starting optimization method, system, chip, device and medium based on device tree | |
JP2004246413A (en) | Computer system | |
CN115186017A (en) | Method, device and storage medium for reading and writing waveform file in target waveform format | |
CN116931947A (en) | Method for optimizing wasm byte code, execution method, computer equipment and storage medium | |
Hachiya | Java use in mobile information devices: Introducing JTRON | |
Mukherjee et al. | Develop once deploy anywhere | |
KR20050016256A (en) | Creating file systems within a file in a storage technology-abstracted manner |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
WWE | Wipo information: entry into national phase |
Ref document number: 201080013818.7 Country of ref document: CN |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application |
Ref document number: 10702602 Country of ref document: EP Kind code of ref document: A1 |
|
WWE | Wipo information: entry into national phase |
Ref document number: 2011546708 Country of ref document: JP Ref document number: 5838/DELNP/2011 Country of ref document: IN |
|
NENP | Non-entry into the national phase |
Ref country code: DE |
|
ENP | Entry into the national phase |
Ref document number: 1113449 Country of ref document: GB Kind code of ref document: A Free format text: PCT FILING DATE = 20100127 |
|
WWE | Wipo information: entry into national phase |
Ref document number: 1113449.1 Country of ref document: GB |
|
ENP | Entry into the national phase |
Ref document number: 20117020212 Country of ref document: KR Kind code of ref document: A |
|
122 | Ep: pct application non-entry in european phase |
Ref document number: 10702602 Country of ref document: EP Kind code of ref document: A1 |