WO2007097881A1 - Adaptive compiled code - Google Patents

Adaptive compiled code Download PDF

Info

Publication number
WO2007097881A1
WO2007097881A1 PCT/US2007/002320 US2007002320W WO2007097881A1 WO 2007097881 A1 WO2007097881 A1 WO 2007097881A1 US 2007002320 W US2007002320 W US 2007002320W WO 2007097881 A1 WO2007097881 A1 WO 2007097881A1
Authority
WO
WIPO (PCT)
Prior art keywords
code
type
computer
module
compiled
Prior art date
Application number
PCT/US2007/002320
Other languages
French (fr)
Inventor
James S. Miller
Thomas E. Quinn
Original Assignee
Microsoft Corporation
Priority date (The priority date 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 date listed.)
Filing date
Publication date
Application filed by Microsoft Corporation filed Critical Microsoft Corporation
Priority to EP07717090A priority Critical patent/EP1999583A4/en
Priority to JP2008556331A priority patent/JP2009528589A/en
Publication of WO2007097881A1 publication Critical patent/WO2007097881A1/en

Links

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformation of program code
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements 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/44Arrangements for executing specific programs
    • G06F9/445Program loading or initiating
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00Error detection; Error correction; Monitoring
    • G06F11/36Preventing errors by testing or debugging software
    • G06F11/362Software debugging
    • G06F11/3624Software debugging by performing operations on the source code, e.g. via a compiler
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F17/00Digital computing or data processing equipment or methods, specially adapted for specific functions
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs

Definitions

  • FIG. 1 shows devices communicating over a network, with the devices implementing example technologies related to adaptive compiled code.
  • FIG. 2 shows an example of an execution environment for implementing example technologies related to adaptive compiled code.
  • FIG. 3 shows an example data structure for adaptive compiled code.
  • FIG. 4 shows an example data flow for implementing example technologies related to adaptive compiled code.
  • Tools, systems, and methodologies for compiling adaptive code and executing the adaptive compiled code are described herein. Further, the description pertaining to at least one of compiling and executing one or more applications, programs, functions, or other assemblage of code having at least one adaptive compiled module, may relate to tools, systems, processes, instructions, techniques, and routines that may be utilized to defer an error associated therewith. That is, the aforementioned tools, systems, processes, instructions, techniques, and routines may be utilized to defer one or more errors associated with a reference in the compiled code until a call to the reference is, at least, statistically inevitable. The aforementioned tools, systems, and processes may be implemented in one or more devices, or nodes, in a network environment. [0009] "Module,” as described herein, may refer to separate entities such as methods, classes, DLLs (dynamic link libraries), frameworks, etc., that may utilize common physical and/or logical resources.
  • FIG. 1 shows example network environment 100 in which example technologies may be implemented for compiling adaptive code and executing one or more applications, programs, functions, other code having at least one adaptive compiled module.
  • example technologies are not limited to network environments.
  • Such technologies may include, but are not limited to, tools, methodologies (e.g., techniques), and systems, associated with adaptive compiled code 1 20, as described herein.
  • tools, methodologies e.g., techniques
  • systems associated with adaptive compiled code 1 20, as described herein.
  • client device 105, server device 1 1 0, and “other” device 1 1 5 may be communicatively coupled to one another via network 1 25; and, further, at least one of client device 105, server device 1 10, and “other" device 1 1 5 may be capable of implementing the aforementioned technologies.
  • Client device 105 may represent at least one of a variety of known computing devices, including a desktop personal computer (PC), workstation, mainframe computer, Internet appliance, set-top box, or gaming console, that is able to implement example technologies for at least one of producing and utilizing adaptive compiled code
  • PC personal computer
  • mainframe computer mainframe computer
  • Internet appliance set-top box
  • gaming console that is able to implement example technologies for at least one of producing and utilizing adaptive compiled code
  • Client device 105 may further represent at least one device that is capable of being associated with network 1 25 by a wired and/or wireless link, including a mobile (i.e., cellular) telephone, personal digital assistant (PDA), laptop computer, etc. Further still, client device 1 05 may represent the client devices described above in various quantities and/or combinations thereof. "Other" device 1 1 5 may also be embodied by any of the above examples of client device 105.
  • Server device 1 10 may represent any device that is capable of providing any of a variety of data and/or functionality to client device 105 or "other" device 1 15 in accordance with at least one implementation for at least one of compiling and utilizing adaptive compiled code 120.
  • the data may be publicly available or alternatively restricted, e.g., restricted to only certain users or only if an appropriate subscription or licensing fee is paid.
  • Server device 1 10 may be at least one of a network server, an application server, a blade server, or any combination thereof.
  • I 1 0 may represent any device that may be a content source
  • client device 1 05 may represent any device that may receive such content either via network 125 or in an offline manner.
  • client device 105 and server device 1 10 may interchangeably be a sending node or a receiving node in network environment 1 00.
  • “Other” device 1 1 5 may also be embodied by any of the above examples of server device 1 10. [0014] "Other" device 1 1 5 may represent any further device that is capable of compiling and/or utilizing adaptive compiled code 1 20 according to one or more of the example technologies described herein.
  • “other" device 1 1 5 may represent a device that is capable of compiling code or receiving compiled code for which one or more errors associated with a reference in the compiled code may be deferred until a call to the reference is, at least, statistically inevitable.
  • “other” device 1 15 may be a computing or processing device having at least one of an operating system, an interpreter, converter, compiler, or runtime execution environment implemented thereon. These examples are not intended to be limiting in any way, and therefore should not be construed in that manner.
  • Network 125 may represent any of a variety of conventional network topologies and types, which may include wired and/or wireless networks.
  • Network 1 25 may further utilize any of a variety of conventional network protocols, including public and/or proprietary protocols.
  • Network 125 may include, for example, the Internet as well at least portions of one or more local area networks (also referred to, individually, as a "LAN”), such as an 802.1 1 system or, on a larger scale, a wide area network ⁇ i.e., WAN"); or a personal area network ⁇ i.e., PAN), such as Bluetooth.
  • LAN local area network
  • WAN wide area network
  • PAN personal area network
  • Computer architecture in at least one of devices 105, 1 10, and 1 1 5 has typically defined computing platforms in terms of hardware and software.
  • Software for computing devices has been categorized into groups, based on function, which may include: a hardware abstraction layer (alternatively referred to as a "HAL”), an operating system (alternatively referred to as "OS”), and applications.
  • HAL hardware abstraction layer
  • OS operating system
  • applications applications
  • a runtime execution environment may reside between an OS and an application, program, function, or other assemblage of code.
  • the runtime execution environment may serve as a space in which the application, program, function, or other assemblage of code may execute specific tasks on any one or more of processing devices 1 05, 1 1 0, and 1 1 5. More particularly, a runtime execution environment may enhance the reliability of the execution of an application, program, function, or other assemblage of code on a growing range of processing devices 1 05, 1 10, and 1 05, including servers, desktop computers, laptop computers, and mobile processing/communication devices by 5 providing a layer of abstraction and services for an application running on such devices, and by further providing the application, program, function, or other assemblage of code with capabilities including memory management and configuration thereof.
  • a runtime execution environment may serve as at least one of a programming and an execution platform.
  • a runtime i o execution environment may compile one or more targeted applications, programs, functions, or other assemblages of code, which may be written in one of multiple computing languages, into an intermediate language (hereafter "IL") or bytecode.
  • IL is typically independent of the platform, and the central processing unit (hereafter "CPU") executes IL.
  • CPU central processing unit
  • IL is a higher level language than many CPU machine languages.
  • a runtime execution environment may interpret compiled IL into native machine instructions.
  • a runtime execution environment may utilize either an interpreter or a compiler ⁇ e.g., "just-in-time,” alternatively “JIT,” compiler) to execute such instructions. Regardless, the native machine instructions may then be directly executed by the CPU. Since IL is CPU-independent, IL may execute on
  • any CPU platform as long as the OS running on that CPU platform hosts an appropriate runtime execution environment.
  • the precompiled portions are software modules that are distributed in an IL format (e.g., assemblies, methods, or types) rather than in a native platform execution format.
  • a source of such precompiled IL may be disposed in either of a non-managed execution environment or a separate implementation of a runtime execution environment on a same or separate one of devices 105, 1 10, and 1 1 5.
  • the source may deploy the precompiled IL during or before install time for the 5 application, program, method, function, or other assemblage of code to which the precompiled IL corresponds.
  • examples of runtime environments in which technologies for compiling and/or utilizing adaptive compiled code 1 20 may be implemented, include: Visual Basic runtime environment; Java ® Virtual Machine runtime environment that is io used to run, e. g., Java ® routines; or Common Language Runtime (CLR) to compile, e.g., Microsoft .NETTM applications into machine language before executing a calling routine.
  • Visual Basic runtime environment Java ® Virtual Machine runtime environment that is io used to run, e. g., Java ® routines
  • CLR Common Language Runtime
  • this listing of runtime environments provides examples only.
  • the example technologies described herein are not limited to just these managed execution environments. More particularly, the example implementations are not just limited to i s managed execution environments, for one or more examples may be implemented within testing environments and/or unmanaged execution environments.
  • An application, program, function, or other assemblage of code compiled into IL may be referred to as “managed code,” and that is why a runtime execution environment may be alternatively referred to as a "managed execution
  • code that does not utilize a runtime execution environment to execute may be referred to as a native code application.
  • FIG. 2 shows an example of runtime execution environment 200 in which example technologies may be implemented for compiling adaptive code 120 (see FIG. 1 ) and executing one or more applications, programs, functions, other code having at least
  • runtime execution environment 200 may facilitate execution of managed code for either of an application programming or application execution platform.
  • Managed code may be considered to be part of a core set of application-development technologies, and may further be regarded as code that is compiled for execution on runtime execution environment 200 to provide a corresponding service to the computing device platform.
  • runtime execution environment 200 may translate managed code at an interpretive level into instructions that may be proxied and then executed by a processor.
  • a framework for runtime execution environment 200 also provides class libraries, which may be regarded as software building blocks for managed applications.
  • runtime execution environment 200 may provide at least partial functionality that may otherwise be expected from a kernel, which may or may not be lacking from a computing device platform depending upon resource constraints for the particular one of device 105, 1 1 0, and 1 1 5.
  • runtime execution environment 200 may implement the following: input/output (hereafter "I/O") routine management, memory management, compilation, and service routine execution.
  • runtime execution environment 200 may include I/O module 205, compiler 210, loader 21 5, memory management component 220 (alternatively referred to as a virtual machine), and service routine manager 225.
  • I/O module 205 compiler 210, loader 21 5, memory management component 220 (alternatively referred to as a virtual machine), and service routine manager 225.
  • These components are to be described in further detail below, and are provided only as examples, and may be implemented in examples of runtime 5 execution environment 200 in various combinations and configurations thereof. The examples are not intended to be limiting to any particular implementation of a runtime execution environment, and no such inference should be made.
  • I/O module 205 of runtime execution environment 200 may provide asynchronous access to data sources ⁇ i.e., processor and peripherals) associated with
  • I/O module 205 may provide runtime execution environment 200 with robust system throughput and further streamline performance of code from which an I/O request originates.
  • Compiler 210 may refer to a module within runtime execution i s environment 200 that may interpret compiled IL into native machine instructions for execution in runtime execution environment 200 by, e.g., execution module 230 or, alternatively, for execution by a CPU in a non-managed execution environment.
  • Loader 21 5 may refer to an assembly manager that may be invoked to locate and read assemblies as needed. Loader 21 5 may be disposed in execution
  • loader 21 5 may garner precompiled IL during deployment or install time, for loading into runtime execution environment 200.
  • loader 21 5 may effectively serve as an entry point for
  • Memory management component 220 may be regarded as a "garbage collector.” Garbage collection may be regarded as a robust feature of managed code execution environments by which an object is automatically freed ⁇ i.e., de-allocated) if an object is no longer used by any applications, upon a sweep or scan of a memory heap.
  • a sweep of free memory heap may be implemented as a linear search. Such implementation may be well-suited for an example of a computing device platform for which memory size is constrained and for which a delay in completion of a sweep may be perceived by a user of a corresponding device.
  • memory management component 220 may include: managing one or more contiguous blocks of finite volatile RAM ⁇ i.e., memory heap) storage or a set of contiguous blocks of memory amongst the tasks running on the computing device platform; allocating memory to at least one application running on the computing device platform; freeing at least portions of memory on request by at least one of the applications; and preventing any of the applications from intrusively accessing memory space that has been allocated to any of the other applications.
  • Administrator 225 may refer to a module within runtime execution • environment 200 that serves to receive, verify, and administer execution of at least a portion of an application, program, method, function, or other assemblage of code in runtime execution environment 200.
  • administrator 225 may control the behavior of the application, program, method, function, or other assemblage code in runtime execution environment 220 without touching or affecting any executable portion thereof, at compile time, initial runtime, or at any time thereafter during execution of an application. More particularly, administrator 225 may enforce type matching for code compiled by compiler 210 or loaded by loader 21 5.
  • administrator 225 may compare types or members of types requested by at least a portion of the code to the types or members of types used to satisfy those requests, in searching of satisfying matches. In the event that such a 5 match does not exist for a respective request, administrator 225 may instruct execution module 230 to proceed with execution of the code compiled by compiler 210 or loaded by loader 21 5 until a request for the missing type or member of the missing type is at least statistically inevitable.
  • Execution module 230 may enable execution of managed code (i.e.,
  • Execution module 230 may be regarded as a module in which execution of the code compiled by compiler 210 or loaded by loader 21 5 may be implemented in runtime execution environment 200, and in which runtime services (e.g., device access and memory management) may be provided.
  • runtime services e.g., device access and memory management
  • FIG. 3 shows example data structure 300 in accordance with one or i s more example technologies associated with adaptive compiled code 120 (see FIG. 1). More particularly, data structure 300 may represent at least a portion of compiled code corresponding to an application, program, or function that includes a reference to a type or member of a type that is missing. According to implementations of adaptive compiled code 1 20, an error associated with the missing type, or missing type member, may be
  • Module 305 may refer to one or more modules of executable instructions corresponding to an application, program, function, or other assemblage of code being executable in accordance with, e.g., execution component 230 in runtime execution environment 200 (see FIG. 2). More particularly, module 305 may refer to an 5 entity such as methods, classes, DLLs (dynamic link libraries), frameworks, etc. Module 305 may be compiled by compiler 210 or loaded into runtime execution environment 200 by loader 21 5. That is, module 305 may be native code ⁇ i.e., machine-readable code).
  • module 305 is not limited to the examples of native code only. i o Rather, alternative implementations of the technologies described herein may be application to code that is not compiled, and therefore be relevant to intermediate language code or other code written in any one of a variety of known languages for which at least one of multiple syntactic characteristics and construct properties may be sampled. i s [0037] Module 31 0 may refer to a reference that is associated with module 305.
  • module 310 may be to a type or a member of a type that is not included in the application, program, function, or assemblage of code to which data structure 300 corresponds.
  • the reference of module 310 may be to a type or a member of a type that is not included in the application, program, function, or assemblage of code to which data structure 300 corresponds.
  • it may be
  • the referenced types, or members thereof may be, but are by no means limited to, an integer, a floating point, a string, logical, or binary.
  • FIG. 4 shows example data flow 400 for producing and utilizing at least
  • FIG. 25 one example implementation of compiling and/or utilizing adaptive compiled code 1 20 (see FIG. 1 ).
  • various operations will be described as being performed on or for one or more modules of data structure 300 (see FIG. 3) by components associated with runtime execution environment 200 (see FIG. 2).
  • the operations that are described with respect to any particular one of these components may be carried out by the component itself, in combination with other components associated with the tool, or by the particular component in cooperation with one or more components of runtime execution environment 200.
  • the operations may be executed by a processor or processors and implemented as hardware, firmware, or software, either singularly or in various combinations together.
  • the operations may occur, typically though by no means exclusively, when the application, program, function, or other assemblage of code to which data structure 300 corresponds attempts to run on a different version of the platform on which it is generated, and is subjected to a verification process at compile time, initial runtime, or at any time thereafter during execution of the application, program, function, or assemblage of code to which data structure 300 corresponds.
  • Block 405 may refer to the compiling of code that results in data structure 300.
  • Environment 410 may be a managed execution environment, and block 405 may refer to a compiler interpreting IL into native machine instructions for execution in the managed execution environment or, alternatively, for execution by a CPU in a non- managed execution environment.
  • Environment 410 may, alternatively, refer to block 405 may refer to the compiling of at least a portion of an application, program, function, or other assemblage of code that is then loaded as one or more native image files in the aforementioned managed execution environment, thus circumventing CPU consumption required for compilation.
  • Data structure 300 as described above, may represent at least a portion of compiled code corresponding to an application, program, or function that includes a reference to a type or member of a type that is missing.
  • Module 305 may refer to one or more modules of executable instructions corresponding to an application, program, function, or other assemblage of code being executable in accordance with a managed execution environment. Module
  • 305 may refer to an entity such as methods, classes, DLLs (dynamic link libraries), frameworks, etc.
  • Module 310 may refer to a reference to a type or a member of a type that is not included in the application, program, function, or assemblage of code to which data structure 300 corresponds.
  • Block 410 may refer to execution module 230 of runtime ⁇ i.e., managed) execution environment 200 executing executable code 305 corresponding to data structure 300.
  • Decision 41 5 may refer to administrator 225 implementing a verification process with regard to the application, program, function, or assemblage of code to which data structure 300 corresponds. More particularly, administrator 225 may compare the types and members of types that may be requested during execution of executable code 305 to determine whether such requests are to be satisfied by the types and members of types found in the application, program, function, or assemblage of code to which data structure 300 corresponds.
  • the verification process implemented by administrator 225 may take place at compile time, initial runtime, or at any time thereafter during execution of the application, program, function, or assemblage of code to which data structure 300 corresponds. Therefore, at least portions of the functionality of administrator may occur at any point during data flow 400, and thus data flow 400, " as depicted in FIC. 4 and described herein, is provided as an example only. That is, alternative implementations of data flow 400 are not beholden to the order shown and described here.
  • reference 310 may be flagged or otherwise noted without requiring an interruption to the execution of the application, program, function, or assemblage of code to which data structure 300 corresponds.
  • administrator 225 may statistically determine a likelihood or probability that reference i o 310 to the missing type or type member may be called as other modules of executable code are executed.
  • Negative decision 420 may result in the continued execution of executable code 305 and other executable code modules associated with the application, program, function, or assemblage of code to which data structure 300 corresponds. That
  • reference 310 is to a type or member of a type that is not present in the application, program, function, or assemblage of code to which data structure 300 corresponds, reference 310 does not cause an error according to implementations of technologies associated with adaptive compiled code 120.
  • Positive decision 425 may result as a statistical inevitability, as
  • the managed execution environment may cause an error.
  • the managed execution environment may cause an error simply when reference 310 to a missing type or type member is called.
  • a non-limiting example of such error may be throwing an exception.
  • T O adaptive compiled code 120 may be implemented by various combinations of the features described with reference to FIGS. 2 - 4.
  • the computer environment for any of the examples and implementations described above may include a computing device having, for example, one or more processors or processing units, a system memory, and a system bus to
  • the computing device may include a variety of computer readable media, including both volatile and non-volatile media, removable and non-removable media.
  • the system memory may include computer readable media in the form of volatile memory, such as random access memory (RAM); and/or non-volatile memory, such as
  • ROM read only memory
  • flash RAM flash random access memories
  • RAM read only memories
  • ROM electric erasable programmable read-only memory
  • EEPROM electrically erasable programmable read-only memory
  • code module initialization may be implemented without one or more of the specific details, or with other methods, resources, materials, etc.
  • well known structures, resources, or operations have not been shown or described in detail merely to avoid obscuring aspects of the invention.

Abstract

In a managed execution environment, an error may be deferred until execution of the application, program, function, or other assemblage of code reaches a point at which calling the reference to a module associated with a missing type or type member becomes inevitable.

Description

ADAPTIVE COMPILED CODE
BACKGROUND
[0001 ] Applications, programs, functions, and other assemblages of programmable and executable code are typically written for third party {i.e., "customer") usage. Therefore, effective code is written in such a manner that third party usage scenarios are enabled and meet third party expectations. However, such expectations may be difficult to meet when an application, program, function, or other assemblage of code that has been designed to run on an existing platform attempts to run on an older, or otherwise different, version of the platform.
SUMMARY
[0002] When an application, program, function, or other assemblage of code attempts to run on an older, or otherwise different, version of the platform on which it was generated, an error associated with a missing type or type member may be deferred until execution of the application, program, function, or other assemblage of code reaches a point at which calling a reference to the missing type or type member becomes inevitable.
DESCRIPTION OF THE DRAWINGS
[0003] The present description references the following figures. [0004] FIG. 1 shows devices communicating over a network, with the devices implementing example technologies related to adaptive compiled code.
[0005] FIG. 2 shows an example of an execution environment for implementing example technologies related to adaptive compiled code.
[0006] FIG. 3 shows an example data structure for adaptive compiled code. [0007] FIG. 4 shows an example data flow for implementing example technologies related to adaptive compiled code.
DETAILED DESCRIPTION
[0008] Tools, systems, and methodologies for compiling adaptive code and executing the adaptive compiled code are described herein. Further, the description pertaining to at least one of compiling and executing one or more applications, programs, functions, or other assemblage of code having at least one adaptive compiled module, may relate to tools, systems, processes, instructions, techniques, and routines that may be utilized to defer an error associated therewith. That is, the aforementioned tools, systems, processes, instructions, techniques, and routines may be utilized to defer one or more errors associated with a reference in the compiled code until a call to the reference is, at least, statistically inevitable. The aforementioned tools, systems, and processes may be implemented in one or more devices, or nodes, in a network environment. [0009] "Module," as described herein, may refer to separate entities such as methods, classes, DLLs (dynamic link libraries), frameworks, etc., that may utilize common physical and/or logical resources.
[0010] "Assemblage," as described herein, may refer to a unit of deployment for code. [001 1 ] FIG. 1 shows example network environment 100 in which example technologies may be implemented for compiling adaptive code and executing one or more applications, programs, functions, other code having at least one adaptive compiled module. However, such example technologies are not limited to network environments. Such technologies may include, but are not limited to, tools, methodologies (e.g., techniques), and systems, associated with adaptive compiled code 1 20, as described herein. In FIG. 1 , client device 105, server device 1 1 0, and "other" device 1 1 5 may be communicatively coupled to one another via network 1 25; and, further, at least one of client device 105, server device 1 10, and "other" device 1 1 5 may be capable of implementing the aforementioned technologies.
[001 2] Client device 105 may represent at least one of a variety of known computing devices, including a desktop personal computer (PC), workstation, mainframe computer, Internet appliance, set-top box, or gaming console, that is able to implement example technologies for at least one of producing and utilizing adaptive compiled code
I 20. Client device 105 may further represent at least one device that is capable of being associated with network 1 25 by a wired and/or wireless link, including a mobile (i.e., cellular) telephone, personal digital assistant (PDA), laptop computer, etc. Further still, client device 1 05 may represent the client devices described above in various quantities and/or combinations thereof. "Other" device 1 1 5 may also be embodied by any of the above examples of client device 105.
[001 3] Server device 1 10 may represent any device that is capable of providing any of a variety of data and/or functionality to client device 105 or "other" device 1 15 in accordance with at least one implementation for at least one of compiling and utilizing adaptive compiled code 120. The data may be publicly available or alternatively restricted, e.g., restricted to only certain users or only if an appropriate subscription or licensing fee is paid. Server device 1 10 may be at least one of a network server, an application server, a blade server, or any combination thereof. Typically, server device
I 1 0 may represent any device that may be a content source, and client device 1 05 may represent any device that may receive such content either via network 125 or in an offline manner. However, according to the example implementations described herein, client device 105 and server device 1 10 may interchangeably be a sending node or a receiving node in network environment 1 00. "Other" device 1 1 5 may also be embodied by any of the above examples of server device 1 10. [0014] "Other" device 1 1 5 may represent any further device that is capable of compiling and/or utilizing adaptive compiled code 1 20 according to one or more of the example technologies described herein. That is, "other" device 1 1 5 may represent a device that is capable of compiling code or receiving compiled code for which one or more errors associated with a reference in the compiled code may be deferred until a call to the reference is, at least, statistically inevitable. Thus, "other" device 1 15 may be a computing or processing device having at least one of an operating system, an interpreter, converter, compiler, or runtime execution environment implemented thereon. These examples are not intended to be limiting in any way, and therefore should not be construed in that manner.
[001 5] Network 125 may represent any of a variety of conventional network topologies and types, which may include wired and/or wireless networks. Network 1 25 may further utilize any of a variety of conventional network protocols, including public and/or proprietary protocols. Network 125 may include, for example, the Internet as well at least portions of one or more local area networks (also referred to, individually, as a "LAN"), such as an 802.1 1 system or, on a larger scale, a wide area network {i.e., WAN"); or a personal area network {i.e., PAN), such as Bluetooth.
[0016] Computer architecture in at least one of devices 105, 1 10, and 1 1 5 has typically defined computing platforms in terms of hardware and software. Software for computing devices has been categorized into groups, based on function, which may include: a hardware abstraction layer (alternatively referred to as a "HAL"), an operating system (alternatively referred to as "OS"), and applications.
[001 7] A runtime execution environment may reside between an OS and an application, program, function, or other assemblage of code. The runtime execution environment may serve as a space in which the application, program, function, or other assemblage of code may execute specific tasks on any one or more of processing devices 1 05, 1 1 0, and 1 1 5. More particularly, a runtime execution environment may enhance the reliability of the execution of an application, program, function, or other assemblage of code on a growing range of processing devices 1 05, 1 10, and 1 05, including servers, desktop computers, laptop computers, and mobile processing/communication devices by 5 providing a layer of abstraction and services for an application running on such devices, and by further providing the application, program, function, or other assemblage of code with capabilities including memory management and configuration thereof.
[001 8] A runtime execution environment may serve as at least one of a programming and an execution platform. As a programming platform, a runtime i o execution environment may compile one or more targeted applications, programs, functions, or other assemblages of code, which may be written in one of multiple computing languages, into an intermediate language (hereafter "IL") or bytecode. IL is typically independent of the platform, and the central processing unit (hereafter "CPU") executes IL. In fact, IL is a higher level language than many CPU machine languages. i s [0019] As an execution platform, a runtime execution environment may interpret compiled IL into native machine instructions. A runtime execution environment may utilize either an interpreter or a compiler {e.g., "just-in-time," alternatively "JIT," compiler) to execute such instructions. Regardless, the native machine instructions may then be directly executed by the CPU. Since IL is CPU-independent, IL may execute on
20 any CPU platform as long as the OS running on that CPU platform hosts an appropriate runtime execution environment.
[0020] Alternatively, at least portions of applications, programs, functions, or other assemblages of code may be precompiled and loaded as one or more native image files in the runtime execution environment, thus circumventing CPU consumption
25 required for compilation. Effectively, the precompiled portions are software modules that are distributed in an IL format (e.g., assemblies, methods, or types) rather than in a native platform execution format. A source of such precompiled IL may be disposed in either of a non-managed execution environment or a separate implementation of a runtime execution environment on a same or separate one of devices 105, 1 10, and 1 1 5. The source may deploy the precompiled IL during or before install time for the 5 application, program, method, function, or other assemblage of code to which the precompiled IL corresponds.
[0021 ] Regardless, examples of runtime environments, in which technologies for compiling and/or utilizing adaptive compiled code 1 20 may be implemented, include: Visual Basic runtime environment; Java® Virtual Machine runtime environment that is io used to run, e. g., Java® routines; or Common Language Runtime (CLR) to compile, e.g., Microsoft .NET™ applications into machine language before executing a calling routine. However, this listing of runtime environments provides examples only. The example technologies described herein are not limited to just these managed execution environments. More particularly, the example implementations are not just limited to i s managed execution environments, for one or more examples may be implemented within testing environments and/or unmanaged execution environments.
[0022] An application, program, function, or other assemblage of code compiled into IL may be referred to as "managed code," and that is why a runtime execution environment may be alternatively referred to as a "managed execution
20 environment."^ It is noted that code that does not utilize a runtime execution environment to execute may be referred to as a native code application.
[0023] FIG. 2 shows an example of runtime execution environment 200 in which example technologies may be implemented for compiling adaptive code 120 (see FIG. 1 ) and executing one or more applications, programs, functions, other code having at least
25 one adaptive compiled module. [0024] In the description of the modules of FIG. 2, which may also be referred to by the descriptions of FIGS. 3 and 4, various operations may be described as being performed by different components of runtime execution environment 200. The operations that are described with respect to a particular component may be carried out by the particular components itself, by the particular component in cooperation with another of the components of runtime execution environment 200, or by the particular components in cooperation with a processing component from an unmanaged execution environment. Thus, the descriptions provided herein pertain to example implementations, and are not intended to be limiting in any manner. [0025] Accordingly, runtime execution environment 200 may facilitate execution of managed code for either of an application programming or application execution platform. Managed code may be considered to be part of a core set of application-development technologies, and may further be regarded as code that is compiled for execution on runtime execution environment 200 to provide a corresponding service to the computing device platform. In addition, runtime execution environment 200 may translate managed code at an interpretive level into instructions that may be proxied and then executed by a processor. A framework for runtime execution environment 200 also provides class libraries, which may be regarded as software building blocks for managed applications. [0026] According to a further example implementation, runtime execution environment 200 may provide at least partial functionality that may otherwise be expected from a kernel, which may or may not be lacking from a computing device platform depending upon resource constraints for the particular one of device 105, 1 1 0, and 1 1 5. Thus, at least one example of runtime execution environment 200 may implement the following: input/output (hereafter "I/O") routine management, memory management, compilation, and service routine execution. Thus, runtime execution environment 200 may include I/O module 205, compiler 210, loader 21 5, memory management component 220 (alternatively referred to as a virtual machine), and service routine manager 225. These components are to be described in further detail below, and are provided only as examples, and may be implemented in examples of runtime 5 execution environment 200 in various combinations and configurations thereof. The examples are not intended to be limiting to any particular implementation of a runtime execution environment, and no such inference should be made.
[0027] I/O module 205 of runtime execution environment 200 may provide asynchronous access to data sources {i.e., processor and peripherals) associated with
10 either of an application programming or application execution platform. More particularly, I/O module 205 may provide runtime execution environment 200 with robust system throughput and further streamline performance of code from which an I/O request originates.
[0028] Compiler 210 may refer to a module within runtime execution i s environment 200 that may interpret compiled IL into native machine instructions for execution in runtime execution environment 200 by, e.g., execution module 230 or, alternatively, for execution by a CPU in a non-managed execution environment.
[0029] Loader 21 5 may refer to an assembly manager that may be invoked to locate and read assemblies as needed. Loader 21 5 may be disposed in execution
20 environment 200, although at least one implementation of an unmanaged execution environment {i.e., OS) may include loader 21 5 therein. Loader 21 5 may garner precompiled IL during deployment or install time, for loading into runtime execution environment 200. Thus, according to at least one alternative implementation of runtime execution environment 200, loader 21 5 may effectively serve as an entry point for
25 precompiled IL into runtime execution environment 200. [0030] Memory management component 220 may be regarded as a "garbage collector." Garbage collection may be regarded as a robust feature of managed code execution environments by which an object is automatically freed {i.e., de-allocated) if an object is no longer used by any applications, upon a sweep or scan of a memory heap. In at least one example of memory management component 210, a sweep of free memory heap may be implemented as a linear search. Such implementation may be well-suited for an example of a computing device platform for which memory size is constrained and for which a delay in completion of a sweep may be perceived by a user of a corresponding device. [0031] Further functions implemented by memory management component 220 may include: managing one or more contiguous blocks of finite volatile RAM {i.e., memory heap) storage or a set of contiguous blocks of memory amongst the tasks running on the computing device platform; allocating memory to at least one application running on the computing device platform; freeing at least portions of memory on request by at least one of the applications; and preventing any of the applications from intrusively accessing memory space that has been allocated to any of the other applications.
[0032] Administrator 225 may refer to a module within runtime execution • environment 200 that serves to receive, verify, and administer execution of at least a portion of an application, program, method, function, or other assemblage of code in runtime execution environment 200. In accordance with at least one example implementation of technologies associated with compiled adaptive code 120, administrator 225 may control the behavior of the application, program, method, function, or other assemblage code in runtime execution environment 220 without touching or affecting any executable portion thereof, at compile time, initial runtime, or at any time thereafter during execution of an application. More particularly, administrator 225 may enforce type matching for code compiled by compiler 210 or loaded by loader 21 5. That is, administrator 225 may compare types or members of types requested by at least a portion of the code to the types or members of types used to satisfy those requests, in searching of satisfying matches. In the event that such a 5 match does not exist for a respective request, administrator 225 may instruct execution module 230 to proceed with execution of the code compiled by compiler 210 or loaded by loader 21 5 until a request for the missing type or member of the missing type is at least statistically inevitable.
[0033] Execution module 230 may enable execution of managed code (i.e.,
T O compiled native code) for the computing device platform. Execution module 230 may be regarded as a module in which execution of the code compiled by compiler 210 or loaded by loader 21 5 may be implemented in runtime execution environment 200, and in which runtime services (e.g., device access and memory management) may be provided.
[0034] FIG. 3 shows example data structure 300 in accordance with one or i s more example technologies associated with adaptive compiled code 120 (see FIG. 1). More particularly, data structure 300 may represent at least a portion of compiled code corresponding to an application, program, or function that includes a reference to a type or member of a type that is missing. According to implementations of adaptive compiled code 1 20, an error associated with the missing type, or missing type member, may be
20 deferred until a call to the reference is, at least, statistically inevitable. This implementation scenario may occur, typically though by no means exclusively, when the application, program, function, or other assemblage of code to which data structure 300 corresponds attempts to run on an older, or otherwise different, version of the platform on which it is generated, and is subjected to a verification process at compile time, initial
25 runtime, or at any time thereafter during execution of the application, program, function, or assemblage of code to which data structure 300 corresponds. [0035] Module 305 may refer to one or more modules of executable instructions corresponding to an application, program, function, or other assemblage of code being executable in accordance with, e.g., execution component 230 in runtime execution environment 200 (see FIG. 2). More particularly, module 305 may refer to an 5 entity such as methods, classes, DLLs (dynamic link libraries), frameworks, etc. Module 305 may be compiled by compiler 210 or loaded into runtime execution environment 200 by loader 21 5. That is, module 305 may be native code {i.e., machine-readable code).
[0036] However, module 305 is not limited to the examples of native code only. i o Rather, alternative implementations of the technologies described herein may be application to code that is not compiled, and therefore be relevant to intermediate language code or other code written in any one of a variety of known languages for which at least one of multiple syntactic characteristics and construct properties may be sampled. i s [0037] Module 31 0 may refer to a reference that is associated with module 305.
More particularly, the reference of module 310 may be to a type or a member of a type that is not included in the application, program, function, or assemblage of code to which data structure 300 corresponds. However, in keeping with the example scenario in which implementations of adaptive compiled code 1 20 are presently described, it may be
20 assembled for descriptive purposes only that the type, or at least one member of the type, to which the reference of module 310 corresponds is missing. Further, the referenced types, or members thereof, may be, but are by no means limited to, an integer, a floating point, a string, logical, or binary.
[0038] FIG. 4 shows example data flow 400 for producing and utilizing at least
25 one example implementation of compiling and/or utilizing adaptive compiled code 1 20 (see FIG. 1 ). [0039] In the following description, various operations will be described as being performed on or for one or more modules of data structure 300 (see FIG. 3) by components associated with runtime execution environment 200 (see FIG. 2). The operations that are described with respect to any particular one of these components may be carried out by the component itself, in combination with other components associated with the tool, or by the particular component in cooperation with one or more components of runtime execution environment 200. In addition, the operations may be executed by a processor or processors and implemented as hardware, firmware, or software, either singularly or in various combinations together. Further still, the operations may occur, typically though by no means exclusively, when the application, program, function, or other assemblage of code to which data structure 300 corresponds attempts to run on a different version of the platform on which it is generated, and is subjected to a verification process at compile time, initial runtime, or at any time thereafter during execution of the application, program, function, or assemblage of code to which data structure 300 corresponds.
[00401 Block 405 may refer to the compiling of code that results in data structure 300.
[0041 ] Environment 410 may be a managed execution environment, and block 405 may refer to a compiler interpreting IL into native machine instructions for execution in the managed execution environment or, alternatively, for execution by a CPU in a non- managed execution environment.
[0042] Environment 410 may, alternatively, refer to block 405 may refer to the compiling of at least a portion of an application, program, function, or other assemblage of code that is then loaded as one or more native image files in the aforementioned managed execution environment, thus circumventing CPU consumption required for compilation. [0043] Data structure 300, as described above, may represent at least a portion of compiled code corresponding to an application, program, or function that includes a reference to a type or member of a type that is missing.
[0044] Module 305 may refer to one or more modules of executable instructions corresponding to an application, program, function, or other assemblage of code being executable in accordance with a managed execution environment. Module
305 may refer to an entity such as methods, classes, DLLs (dynamic link libraries), frameworks, etc.
[0045] Module 310 may refer to a reference to a type or a member of a type that is not included in the application, program, function, or assemblage of code to which data structure 300 corresponds.
[0046] Block 410 may refer to execution module 230 of runtime {i.e., managed) execution environment 200 executing executable code 305 corresponding to data structure 300. [0047] Decision 41 5 may refer to administrator 225 implementing a verification process with regard to the application, program, function, or assemblage of code to which data structure 300 corresponds. More particularly, administrator 225 may compare the types and members of types that may be requested during execution of executable code 305 to determine whether such requests are to be satisfied by the types and members of types found in the application, program, function, or assemblage of code to which data structure 300 corresponds.
[0048] The verification process implemented by administrator 225 may take place at compile time, initial runtime, or at any time thereafter during execution of the application, program, function, or assemblage of code to which data structure 300 corresponds. Therefore, at least portions of the functionality of administrator may occur at any point during data flow 400, and thus data flow 400," as depicted in FIC. 4 and described herein, is provided as an example only. That is, alternative implementations of data flow 400 are not beholden to the order shown and described here.
[0049] Regardless, as the verification process reveals that a type or a member of a type that is subject to reference 310 is not included in the application, program, 5 function, or assemblage of code to which data structure 300 corresponds, reference 310 may be flagged or otherwise noted without requiring an interruption to the execution of the application, program, function, or assemblage of code to which data structure 300 corresponds. Further, according to at least one implementation of data flow 400, administrator 225 may statistically determine a likelihood or probability that reference i o 310 to the missing type or type member may be called as other modules of executable code are executed.
[0050] Negative decision 420 may result in the continued execution of executable code 305 and other executable code modules associated with the application, program, function, or assemblage of code to which data structure 300 corresponds. That
15 is, even though reference 310 is to a type or member of a type that is not present in the application, program, function, or assemblage of code to which data structure 300 corresponds, reference 310 does not cause an error according to implementations of technologies associated with adaptive compiled code 120.
[0051 ] Positive decision 425 may result as a statistical inevitability, as
20 determined by administrator 225, during the execution of the application, program, function, or assemblage of code to which data structure 300 corresponds, or simply as a result of reference 310 to a missing type or type member being called.
[0052] That is, if the execution of modules of executable code for the application, program, function, or assemblage of code to which data structure 300, and
25 therefore reference 31 0, corresponds reaches a point of statistical inevitability that reference 310 to a missing type or type member is to be called, the managed execution environment may cause an error. Alternatively, the managed execution environment may cause an error simply when reference 310 to a missing type or type member is called. A non-limiting example of such error may be throwing an exception.
[0053] Thus, by the description above, pertaining to FIGS. 1 - 4, an error
5 associated with a reference to a missing type or type member may be deferred until runtime, when a reference to a missing type or type member may actually be called.
[0054] However, the example implementations described herein are not limited to just the environment of FIG. 1 , components of FIG. 2, modules of FIG. 3, or the process of FIG. 4. Technologies {e.g., tools, methodologies, and systems) associated with
T O adaptive compiled code 120 (see FIG. 1 ) may be implemented by various combinations of the features described with reference to FIGS. 2 - 4.
[0055] Further, the computer environment for any of the examples and implementations described above may include a computing device having, for example, one or more processors or processing units, a system memory, and a system bus to
15 couple various system components.
[0056] The computing device may include a variety of computer readable media, including both volatile and non-volatile media, removable and non-removable media. The system memory may include computer readable media in the form of volatile memory, such as random access memory (RAM); and/or non-volatile memory, such as
20 read only memory (ROM) or flash RAM. It is appreciated that other types of computer readable media which can store data that is accessible by a computer, such as magnetic cassettes or other magnetic storage devices, flash memory cards, CD-ROM, digital versatile disks (DVD) or other optical storage, random access memories (RAM), read only memories (ROM), electric erasable programmable read-only memory (EEPROM), and the
25 like, can also be utilized to implement the example computing system and environment. [0057] Reference has been made throughout this specification to "an example," "alternative examples," "at least one example," "an implementation," or "an example implementation" meaning that a particular described feature, structure, or characteristic is included in at least one implementation of the present invention. Thus, usage of such phrases may refer to more than just one implementation. Furthermore, the described features, structures, or characteristics may be combined in any suitable manner in one or more implementations.
10058] One skilled in the relevant art may recognize, however, that code module initialization may be implemented without one or more of the specific details, or with other methods, resources, materials, etc. In other instances, well known structures, resources, or operations have not been shown or described in detail merely to avoid obscuring aspects of the invention.
[0059] While example implementations and applications of the code module initialization have been illustrated and described, it is to be understood that the invention is not limited to the precise configuration and resources described above. Various modifications, changes, and variations apparent to those skilled in the art may be made in the arrangement, operation, and details of the methods and systems of the present invention disclosed herein without departing from the scope of the invention, as both described above and claimed below.

Claims

WE CLAIM
1 . A computer-readable medium having a verified data structure thereon, the data structure comprising: an executable module; and a reference module that makes reference to a module associated with a type that is missing from an assemblage of code to which the compiled data structure is associated.
2. A computer-readable medium according to Claim 1 , wherein the executable module is a method.
3. A computer-readable medium according to Claim 1 , wherein the module associated with a type that is missing is a type.
4. A computer-readable medium according to Claim 1 , wherein the module associated with a type that is missing is a member of a type.
5. A computer-readable medium according to Claim 1 , wherein a call to the reference module throws an exception.
6. A computer-readable medium according to Claim 1 , wherein the verified data structure is compiled in a runtime execution environment.
7. A computer-readable medium according to Claim 1 , wherein the verified data structure is received, by a runtime execution environment, in compiled form.
8. A method, comprising: verifying source code; compiling the verified source code into a machine language; calling a method associated with the machine language; and
5 causing an error when the calling includes a reference to a module associated with a type that is missing from the compiled source code.
9. JA method according to Claim 8, wherein the method is executed in a managed execution environment.
10. A method according to Claim 8, wherein the compiling is executed i o external to a managed execution environment and the calling and the causing are executed in the managed execution environment.
1 1 . A method according to Claim 8, wherein the reference to the module associated with the type that is missing from the compiled source code is included in the compiled source code.
i s 1 2. A method according to Claim 8, wherein the reference to the module associated with the type that is missing from the compiled source code is a reference to a type.
1 3. A method according to Claim 8, wherein the reference to the module associated with the type that is missing from the compiled source code is a reference to a 20 member of a type.
14. At least one computer-readable medium having one or more executable instructions thereon that, when read, cause one or more processors to: verify source code; compile the verified source code into a native machine code;
5 execute native machine code that includes a reference to a module that is missing from the compiled code; and cause an error when execution of the native machine code is determined to include an inevitable call to the reference.
15. At least one computer- readable medium according to Claim 14, wherein T O the one or more executable instructions to compile the verified source code are executed in a managed execution environment.
16. At least one computer-readable medium according to Claim 14, wherein the one or more executable instructions to compile the verified source code are executed by a just-in-time compiler.
15 1 7. At least one computer-readable medium according to Claim 14, wherein the one or more executable instructions to compile the verified source code are executed in an unmanaged execution environment, and the native machine code is then received by a managed execution environment.
1 8. At least one computer-readable medium according to Claim 14, wherein 20 the reference to a module that is missing from the compiled code is a reference to a type.
1 9. At least one computer-readable medium according to Claim 14, wherein the reference to a module that is missing from the compiled code is a reference to a member of a type.
20. At least one computer-readable medium according to Claim 14, wherein the one or more instructions to cause an error when execution of the native machine code is determined to include an inevitable call to the reference cause the one or more processors to statistically determine the inevitability of the call to the reference.
PCT/US2007/002320 2006-02-27 2007-01-25 Adaptive compiled code WO2007097881A1 (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
EP07717090A EP1999583A4 (en) 2006-02-27 2007-01-25 Adaptive compiled code
JP2008556331A JP2009528589A (en) 2006-02-27 2007-01-25 Adaptive compilation code

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US11/276,362 2006-02-27
US11/276,362 US8615743B2 (en) 2006-02-27 2006-02-27 Adaptive compiled code

Publications (1)

Publication Number Publication Date
WO2007097881A1 true WO2007097881A1 (en) 2007-08-30

Family

ID=38437698

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/US2007/002320 WO2007097881A1 (en) 2006-02-27 2007-01-25 Adaptive compiled code

Country Status (6)

Country Link
US (1) US8615743B2 (en)
EP (1) EP1999583A4 (en)
JP (1) JP2009528589A (en)
KR (1) KR20080103970A (en)
CN (1) CN101390053A (en)
WO (1) WO2007097881A1 (en)

Families Citing this family (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP1752874A1 (en) * 2005-07-19 2007-02-14 Alcatel Adaptive evolutionary computer software product
US8473971B2 (en) 2005-09-06 2013-06-25 Microsoft Corporation Type inference and type-directed late binding
US8615743B2 (en) * 2006-02-27 2013-12-24 Microsoft Corporation Adaptive compiled code
US20080320453A1 (en) * 2007-06-21 2008-12-25 Microsoft Corporation Type inference and late binding
US8572591B2 (en) 2010-06-15 2013-10-29 Microsoft Corporation Dynamic adaptive programming
US9256401B2 (en) 2011-05-31 2016-02-09 Microsoft Technology Licensing, Llc Editor visualization of symbolic relationships
US9772826B2 (en) * 2013-10-04 2017-09-26 Microsoft Technology Licensing, Llc Build-time resolving and type checking references
CN104699485A (en) * 2015-03-19 2015-06-10 神华集团有限责任公司 Massive program management method and massive program construction method
US9940218B2 (en) * 2016-02-15 2018-04-10 International Business Machines Corporation Debugging optimized code using fat binary
KR102253238B1 (en) * 2020-12-09 2021-05-18 넷마블 주식회사 Method of verifying to distributed compiling

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20020169999A1 (en) * 2001-05-14 2002-11-14 Microsoft Corporation Placing exception throwing instructions in compiled code
US20040268095A1 (en) * 2003-06-30 2004-12-30 Tatiana Shpeisman Efficient implementation of null reference check
US20050172286A1 (en) * 2004-02-03 2005-08-04 Microsoft Corporation Hosted code runtime protection
EP1598739A1 (en) * 2003-02-18 2005-11-23 Access Co., Ltd. Native compile method, native compile preprocessing method, computer program, and server

Family Cites Families (31)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPS63163636A (en) 1986-12-26 1988-07-07 Hitachi Ltd Executing system for parallel processing
US5748966A (en) * 1994-12-30 1998-05-05 The Trustees Of The University Of Pennsylvania Type error checker for type-free or polymorphic computer language
EP0727739B1 (en) * 1995-02-17 2002-11-06 International Business Machines Corporation Object-oriented programming interface for developing and running network management applications on a network communication infrastructure
US5655122A (en) 1995-04-05 1997-08-05 Sequent Computer Systems, Inc. Optimizing compiler with static prediction of branch probability, branch frequency and function frequency
US6003095A (en) 1996-10-31 1999-12-14 International Business Machines Corporation Apparatus and method for demand loading a dynamic link library
US5857104A (en) 1996-11-26 1999-01-05 Hewlett-Packard Company Synthetic dynamic branch prediction
US6314566B1 (en) 1998-09-29 2001-11-06 Apple Computer, Inc. Method and apparatus for “Just-in-Time” dynamic loading and unloading of computer software libraries
US20020147969A1 (en) * 1998-10-21 2002-10-10 Richard A. Lethin Dynamic optimizing object code translator for architecture emulation and dynamic optimizing object code translation method
GB9825102D0 (en) * 1998-11-16 1999-01-13 Insignia Solutions Plc Computer system
US6321377B1 (en) * 1998-12-03 2001-11-20 International Business Machines Corporation Method and apparatus automatic service of JIT compiler generated errors
US6636885B1 (en) 1999-03-26 2003-10-21 Sun Microsystems, Inc. System using interface class in client computer to resolve references and retrieve delayed class applet from server
US6763397B1 (en) 1999-05-27 2004-07-13 Sun Microsystems, Inc. Fully lazy linking
US6484313B1 (en) * 1999-06-30 2002-11-19 Microsoft Corporation Compiling and persisting of intermediate language code
US6560774B1 (en) * 1999-09-01 2003-05-06 Microsoft Corporation Verifier to check intermediate language
GB2358261B (en) * 2000-01-17 2004-06-09 Advanced Risc Mach Ltd Data processing with native and interpreted program instruction words
US7080359B2 (en) * 2002-01-16 2006-07-18 International Business Machines Corporation Stack unique signatures for program procedures and methods
US6658657B1 (en) * 2000-03-31 2003-12-02 Intel Corporation Method and apparatus for reducing the overhead of virtual method invocations
US7155606B1 (en) * 2000-04-12 2006-12-26 Microsoft Corporation Method and system for accepting preverified information
US6981249B1 (en) * 2000-05-02 2005-12-27 Microsoft Corporation Methods for enhancing type reconstruction
US6886094B1 (en) * 2000-09-28 2005-04-26 International Business Machines Corporation Apparatus and method for detecting and handling exceptions
US6851111B2 (en) 2000-12-15 2005-02-01 International Business Machines Corporation System and method for class loader constraint checking
US7076785B2 (en) * 2001-08-15 2006-07-11 Microsoft Corporation Lazy loading with code conversion
US6993755B1 (en) * 2001-10-24 2006-01-31 Sun Microsystems, Inc. Dynamic compilation control
US7296257B1 (en) * 2002-08-01 2007-11-13 Tymesys Corporation Techniques for exception handling by rewriting dispatch table elements
US7150004B2 (en) * 2002-08-21 2006-12-12 International Business Machines Corporation Programmatically serializing complex objects using self-healing techniques
US7120898B2 (en) * 2003-06-26 2006-10-10 Microsoft Corporation Intermediate representation for multiple exception handling models
US20070079290A1 (en) * 2005-09-27 2007-04-05 Bea Systems, Inc. System and method for dimensional explorer for performance test
US20070169036A1 (en) * 2005-10-31 2007-07-19 Dhi Technologies, Inc. Incremental type inferencing engine
US7770161B2 (en) * 2005-12-28 2010-08-03 International Business Machines Corporation Post-register allocation profile directed instruction scheduling
US8615743B2 (en) * 2006-02-27 2013-12-24 Microsoft Corporation Adaptive compiled code
US8572570B2 (en) * 2010-06-10 2013-10-29 Accenture Global Services Limited Assisted compositional reasoning for test scripts

Patent Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20020169999A1 (en) * 2001-05-14 2002-11-14 Microsoft Corporation Placing exception throwing instructions in compiled code
EP1598739A1 (en) * 2003-02-18 2005-11-23 Access Co., Ltd. Native compile method, native compile preprocessing method, computer program, and server
US20040268095A1 (en) * 2003-06-30 2004-12-30 Tatiana Shpeisman Efficient implementation of null reference check
US20050172286A1 (en) * 2004-02-03 2005-08-04 Microsoft Corporation Hosted code runtime protection

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
See also references of EP1999583A4 *

Also Published As

Publication number Publication date
US8615743B2 (en) 2013-12-24
US20070240120A1 (en) 2007-10-11
KR20080103970A (en) 2008-11-28
EP1999583A4 (en) 2009-04-15
JP2009528589A (en) 2009-08-06
CN101390053A (en) 2009-03-18
EP1999583A1 (en) 2008-12-10

Similar Documents

Publication Publication Date Title
US8615743B2 (en) Adaptive compiled code
US7730464B2 (en) Code compilation management service
US7743363B2 (en) Extensible meta-data
US7441094B2 (en) Memory management configuration
US10334031B2 (en) Load balancing based on impending garbage collection in execution environment
US20070094671A1 (en) Load balancing interfaces
US20070180455A1 (en) Qualitatively Annotated Code
US8701095B2 (en) Add/remove memory pressure per object
US8713524B2 (en) Memory management configuration
US7600223B2 (en) Abstracted managed code execution
US20070067762A1 (en) Exposing code contentions
US7743377B2 (en) Cooperative threading in a managed code execution environment
US20070168742A1 (en) Isolating code modules
EP1902379B1 (en) Node-to-node communication pipelines
US7549045B2 (en) Delegate registration in a managed code execution environment
US20060101439A1 (en) Memory management in a managed code execution environment
US7673051B2 (en) Resource usage conflict identifier
US20060288336A1 (en) Module initialization

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application
WWE Wipo information: entry into national phase

Ref document number: 2008556331

Country of ref document: JP

WWE Wipo information: entry into national phase

Ref document number: 4388/CHENP/2008

Country of ref document: IN

WWE Wipo information: entry into national phase

Ref document number: 200780006538.1

Country of ref document: CN

WWE Wipo information: entry into national phase

Ref document number: 1020087020839

Country of ref document: KR

NENP Non-entry into the national phase

Ref country code: DE

WWE Wipo information: entry into national phase

Ref document number: 2007717090

Country of ref document: EP