US20020032719A1 - Method and system of dynamic memory management - Google Patents
Method and system of dynamic memory management Download PDFInfo
- Publication number
- US20020032719A1 US20020032719A1 US09/859,163 US85916301A US2002032719A1 US 20020032719 A1 US20020032719 A1 US 20020032719A1 US 85916301 A US85916301 A US 85916301A US 2002032719 A1 US2002032719 A1 US 2002032719A1
- Authority
- US
- United States
- Prior art keywords
- code
- thread
- frame
- compiled
- execution
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4812—Task transfer initiation or dispatching by interrupt, e.g. masked
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3604—Software analysis for verifying properties of programs
- G06F11/3612—Software analysis for verifying properties of programs by runtime analysis
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/0223—User address space allocation, e.g. contiguous or non contiguous base addressing
- G06F12/023—Free address space management
- G06F12/0253—Garbage collection, i.e. reclamation of unreferenced memory
- G06F12/0269—Incremental or concurrent garbage collection, e.g. in real-time systems
-
- 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
- G06F8/4441—Reducing the execution time required by the program code
- G06F8/4442—Reducing the number of cache misses; Data prefetching
-
- 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/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4482—Procedural
- G06F9/4484—Executing subprograms
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4488—Object-oriented
- G06F9/449—Object-oriented method invocation or resolution
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4488—Object-oriented
- G06F9/449—Object-oriented method invocation or resolution
- G06F9/4491—Optimising based on receiver type
-
- 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/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
-
- 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/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
- G06F9/45516—Runtime code conversion or optimisation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/48—Indexing scheme relating to G06F9/48
- G06F2209/481—Exception handling
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
- Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10S707/00—Data processing: database and file management or data structures
- Y10S707/99931—Database or file accessing
- Y10S707/99932—Access augmentation or optimizing
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
- Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10S707/00—Data processing: database and file management or data structures
- Y10S707/99951—File or database maintenance
- Y10S707/99952—Coherency, e.g. same view to multiple users
- Y10S707/99953—Recoverability
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
- Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10S707/00—Data processing: database and file management or data structures
- Y10S707/99951—File or database maintenance
- Y10S707/99956—File allocation
Definitions
- This invention relates, in its most general aspects, to a computer system and to a method of operating that system, and to improvements in the performance of various operations within such a system. It also relates to a computer-readable storage medium.
- the computer system may be, may include, or may be part of, a virtual machine.
- the computer-readable storage medium may contain executable code or other instructions for programming the computer system/virtual machine.
- object-oriented language In recent years, there have been developments in programming languages towards what is known as an object-oriented language. In these developments, concepts are regarded as ‘objects’, each carrying with it a set of data, or attributes, pertinent to that object, as well as information relating to so-called ‘methods’, that is functions or sub-routines, that can be performed on that object and its data. This is well known to those skilled in the art of computing and/or programming.
- a particularly notable product of this type is that developed by Insignia Solutions of High Wycombe, GB and Santa Clara, Calif., USA and known under the name ‘SoftWindows 2.0 for Powermac’.
- This software enables a physical Macintosh computer to emulate a PC having an Intel 80486DX processor and 80487 maths co-processor plus memory, two hard disks, IBM-style keyboard, colour display and other features normally found on recent versions of the PC-type of computer.
- Emulation software packages tend to have certain features in common, notably that they are not general purpose but are dedicated. They are of most benefit in rapid development areas and have a distinct advantage in enabling manufacturers to cut costs. In particular, they can divorce software from the physical machine, i.e., the effect of the software in the physical machine can be altered by the emulating software without having to go into the machine's native software to implement those changes.
- Java registered trade mark to Sun Microsystems Corporation.
- Some of the following implementations will enable Java to be used in smaller devices than is currently possible because of the improved performance and/or reduced memory footprint.
- Future uses projected for embedded software include computers worn on the body, office equipment, household appliances, and intelligent houses and cars.
- FIG. 1 shows certain components of the virtual machine.
- the virtual machine 20 is an executable code installed in the particular item of equipment 22 . It can provide a degree of independence from the hardware and operating system.
- the virtual machine may typically include any, some, or all of the following features: an operating engine, a library of routines, one or more interpreters, one or more compilers, storage means for storing a plurality of instruction sequences, queue management means, and buffer management means.
- the virtual machine is coupled to one or more applications 24 on one side (the “high level” side), and, on the other side (the “low level” side), perhaps via various intermediate logical units, to the hardware 26 of the item of equipment.
- the hardware can be regarded as including various ports or interfaces 28 (perhaps an interface for accepting user input); the virtual machine receives events from those ports or interfaces.
- the hardware also includes one or more processors/control means 30 and memory 32 .
- Agent's Reference No. 1 Computer System, Computer-readable Storage Medium and Method of Operating Same, and Method of Operating that System
- the present invention relates to a computer system and to a method of operating a computer system.
- the invention relates to computer systems including a compiler for compiling code for execution.
- the invention relates to Dynamic Compilation of the Dominant Path.
- This invention is preferably related to the optimisation of the runtime representation of object-oriented computer languages by means of runtime compilation technology and preferably to the optimisation of the runtime representation of object-oriented computer languages by means of runtime compilation technology. Aspects of the invention are related to optimised execution of virtual machines, and in particular Java virtual machines.
- the invention relates in particular to trace scheduling, optimising compilers, dynamic compilation, profile guided optimisations, just in time compilers and the Java VM specification.
- code may be interpreted directly using an interpreter.
- the interpreter translates the code during execution and thus, the interpretation of code can be very slow.
- the execution of compiled code is therefore preferred since such execution is generally significantly faster than interpretation.
- Standard compilers translate all of the code of an application to give a complete compiled runtime representation of the code for execution. Such standard compilation is time consuming, especially where optimisation of the compiled code is desired, and is usually carried out off-line before execution of the code.
- JIT Just-in-Time
- the Just-in-Time (JIT) compiler provides on-line compilation of code. For example, using a JIT compiler, when a method is first encountered in the execution of the code, the execution is stopped and the JIT compiler compiles the whole of the method, optimising where possible. Thus the JIT compiler compiles the whole method, including parts of the method which are unlikely to be used. Such compilation wastes time in compilation and the compiled version of the code takes up space in the memory. This can present a particular problem for an embedded application where minimising the use of memory is of importance.
- JIT Just-in-time
- compilers of the runtime representation of computer languages and in particular so-called Just-in-time (JIT) compilers compile the representation of a whole method at a time, or a larger unit (for example, a file or one of many classes at a time).
- JIT Just-in-time
- a significant portion of an application relates to handling exceptional situations, or rarely executed code.
- the compiler blocks any further progress of the application until the compilation completes.
- Offline compilers which use profile input from a previous run of the application can often optimise the frequently executed paths of an application to mitigate the latter problem. However they still must compile every path through the application, and cannot easily react when an application exhibits different behaviour, to that of the profile run.
- the amount of memory available to the compiler varies depending on the computer system used.
- the overall memory allocated to the compiler includes the code buffer space, the space allocated to the compiler for building required internal data structures and for register allocation. That memory is usually set aside for the compiler prior to compilation.
- JIT compilers were designed for use on desktop computer systems having plenty of memory.
- the memory allocated to the compiler is generally so great that the amount of buffer space available to the compiler is, in practice, unlimited.
- the amount of memory allocated to the compiler might be 70 or 80K. Clearly, that imposes constraints on the amount of code that may be compiled.
- the invention described in this application aims to, among other things, reduce the performance impact of online compilation, generate code which is optimised for the dominant paths through an application, allow better optimisation of code, within time and memory constraints, reduce the storage overhead of compiled code which is rarely executed, improve application responsiveness in a multi-threaded computer system, and reduce the amount of memory used by the compiler itself.
- a computer system including a compiler for compiling the code of an application, wherein the compiler is arranged to compile a fragment of the code.
- the compilation may be made more efficient as only those fragments required are compiled. Also, the memory of the system need not be filled with compiled versions of rarely executed code.
- fragment of code it preferably refers to a section of code which represents less than a whole method.
- fragment of code includes one or more blocks of code. It is preferred that the smallest unit of compilation of the code is a block.
- a particularly preferred feature of the invention is that the fragment of code is a dominant path fragment of the code.
- a dominant path fragment includes a fragment including a number of blocks of code which represents a preferred execution route through the relevant code. For example, where a section of code includes a conditional branch, on repeated execution of code through the branch, one path through the branch is likely to be preferred over another path through the branch.
- the fragment of code associated with the preferred route through the branch is preferably considered to be a dominant path fragment.
- another less preferred route through the branch may also be a dominant path.
- the dominant path fragments of code include code which is frequently executed.
- the dominant path does not include infrequently executed code.
- Such infrequently executed code may include, for example, code for handling infrequently encountered exceptions.
- the storage overhead of storing compiled code which is rarely executed can be minimised.
- optimisation techniques can be used to optimise the execution of the dominant path code thus increasing the speed of execution of the dominant path code.
- the compiler need not waste time on-line in compiling rarely executed code and so the overall speed of execution in the system can be improved.
- a fragment of code is considered to be part of a dominant path if it is executed more than a predetermined number of times.
- the computer system further includes an execution history recorder for recording the number of times a fragment of code is executed, preferably interpreted.
- the execution history recorder records the number of times a block of code is interpreted.
- the execution history recorder also records further information regarding the execution of the block, for example, from where the transfer of control into the block came and to where control was transferred out of the block.
- the recorder preferably also records what type of code was executed in the block.
- a fragment which has been interpreted a number of times which is equal to or greater than a threshold is able to be compiled.
- the threshold is greater than or equal to 2, 5 or even 10.
- the frequently executed blocks of code are compiled. It is generally unpreferable for unexecuted blocks to be compiled. In preferred embodiments of the invention, no unexecuted blocks are compiled.
- the system further includes a compiler manager and the execution history recorder is arranged to alert the compiler manager when a fragment of code has been interpreted the threshold number of times.
- the compiler manager administers a queue of frequently executed blocks for compilation.
- the queue is managed in such a way that only the more frequently executed blocks are chosen from the queue for compilation by the compiler.
- the threshold is able to be dynamically tuned.
- the threshold is preferably raised so that fewer blocks are sent to the queue for compilation.
- the execution history recorder prefferably be arranged to record during the execution of the application. It is preferred for the execution history to be collected on-line so that a representation of the dominant path for the particular execution of the application by the system may be determined and used to generate the compiled code.
- the dominant path may change during a run.
- the system further includes an interpreter for interpreting the code of the application and the execution history recorder is arranged to record the interpretation of fragments of code. It is more efficient for the interpreter to manage the execution history recordal. It is envisaged that the recordal of execution of compiled fragments of code could be carried out but in many cases it is thought that it would not be worthwhile having regard to the time and memory required to do so.
- the execution history recorder is arranged to record a path of execution from a first fragment to a second fragment.
- the path of execution from a first block to a second block is recorded.
- the execution history recorder records, for the execution of a particular block, to where control was transferred from the block.
- the most likely successor block can be determined.
- a dominant path from the particular block can be determined. If the particular block passes the threshold number of executions and is compiled, a dominant path from that particular block through the most likely successors can be compiled.
- the compiler is arranged to compile a path of fragments.
- the system is arranged so that only fragments in which all of the code has been executed are able to be compiled. Some sections of code are not always suitable for compilation. If sections of the code have not been executed, the unexecuted portions might include “hidden” code which is unsuitable for compilation. Compilation of such unexecuted code is avoided in preferred embodiments of the invention.
- a block of code is unsuitable for compilation if it has not executed all the way to a control transfer. As a result, there may still be symbolic resolution required—a job left for the interpreter to implement.
- the compiled version of the dominant path exposes only one external entry point to the rest of the system. Therefore, assumptions may be made in the compilation of the code.
- the compiler is preferably arranged to create compiled fragments having only one external entry point.
- the compiler is able to optimise the compiled code.
- optimise the compiled code might include inlining.
- the compiled code is associated with a marker to indicate that a particular optimisation or assumption has been made.
- the system includes a fallback interpreter.
- the fallback interpreter is not used when a compiled version of code is available, but is used when no compiled version is available, an exception occurs, or an assumption proves false during execution.
- the system includes an interpreter and at least one portion of compiled code wherein, on execution of the code, at least a first portion of the code is executed from compiled code and at least a second portion of the code is executed from non-compiled code by the interpreter.
- the system uses a fall back interpreter.
- a further aspect of the invention provides a computer system including an interpreter and further including the code of an application, the code including at least one portion of compiled code, wherein, on execution of the code, at least a first portion of the code is executed from the compiled code and at least a second portion of the code is executed by the interpreter.
- the interpreter can be used where there is no compiled versions of the code available or, for example, where assumptions made in the compilation of the code are found to be untrue. Thus more aggressive optimisation is thus made possible to produce optimised code which might not be ‘safe’ to use in all cases. Where a case is identified in which the compiled version is not safe to use, the fallback interpreter can complete the execution of the necessary code without excessive disruption to the execution and without the need to cease execution while a fresh compiled version of the section of code is produced.
- the system further includes a searching device for determining whether there is a compiled version of a fragment of code.
- a searching device for determining whether there is a compiled version of a fragment of code.
- the compiler is able to compile on-line.
- the compiler is able to create compiled versions for any new dominant path fragments which may appear during a run.
- the system is multi-threaded.
- the compiler runs on a separate thread to the thread executing code.
- the compiler is able to limit the memory which is used by itself and by the compiled fragments.
- the compiler preferably has a memory management policy enforced by the compiler to limit the memory used by compilation. This is of particular importance for virtual machines which have limited memory.
- the system also includes a deletion device for deletion of compiled code.
- compiled versions of less frequently used code are able to be deleted to release memory for new compiled code.
- the present invention finds particular application for virtual machines, in particular in embedded systems. It is envisaged that the invention could also find general use in systems for which there is the choice of executing compiled code and interpreting code. The invention is of particular use in systems having memory constraints.
- the invention also provides a compiler for compiling code in a computer system, the compiler being arranged for the compilation of a fragment of code.
- the compiler is arranged for the compilation of a dominant path fragment of the code.
- the invention provides a computer system containing a compiler for compiling the operating code of an application, in which only dominant path (or near dominant path) fragments of the code are compiled.
- This technique can afford the primary advantage of enhancing performance and reducing compiled space. It is important for a small memory application and involves a mixture of trade offs between memory size, compilation time and performance.
- the compiler is operating on-line, in the sense that as the operating code is running parts of it are being compiled; what is termed the dominant path may be constantly changing as execution of the code progresses.
- the invention further provides a method of operating a computer system, the computer system including a compiler for compiling the code of an application, wherein a fragment of the code is compiled.
- the number of times a fragment of code is executed is recorded by an execution history recorder.
- system further includes a compiler manager and the execution history recorder alerts the compiler manager when a fragment of code has been executed a threshold number of times, and preferable wherein the execution history recorder records during the execution of the application.
- the invention provides in a further aspect a method of operating a computer system including an interpreter and further including the code of an application, the code including at least one portion of compiled code, wherein the method includes executing at least a first portion of the code from the compiled code and executing at least a second portion of the code using the interpreter.
- the compiler compiles on line.
- the memory available to the compiler is limited and preferably the method further includes the step of deleting compiled code.
- the method can enhance the performance and reduce the compiled space requirement of the computer system and the memory space requirements of the compiler itself.
- information identifying the dominant path is provided from the execution history of the code.
- the execution history information is preferably derived dynamically as the program runs.
- the execution history information is advantageously captured from a previous run of the code.
- infrequently executed code is interpreted in a fallback interpreter, whereby preferably execution of the code can continue without the need for compiled code for the infrequently executed code.
- an online compilation system which can compile code on demand as the application/program executes whereby compilation information can be generated in response to the appearance of a new frequently executed path.
- new fragments of code are preferably incorporated into the multi-threaded system, whereby preferably to achieve smoother operation without stopping running threads.
- the invention further provides a method of operating a computer system containing a compiler for compiling the operating code of an application, the method including compiling only the dominant path fragments of the code.
- the method includes compiling a fragment of the code and preferably includes compiling a dominant path fragment of the code.
- the invention also provides the use of a fall back interpreter to execute infrequently executed code.
- code for a computer system including compiled code produced by a method as aforesaid.
- FIG. 1A shows paths of execution
- FIG. 1B shows the comparative costs of compiling dominant paths
- FIG. 1C shows a dispatch table
- FIG. 1D is a schematic representation of apparatus for carrying out the invention.
- FIG. 1E shows paths of execution through code.
- the compiler takes as input the runtime representation of the source program, and execution history information (which may be obtained as described below).
- the execution history information could be live (that is, dynamically changing as the program runs), or captured from a previous run of the program.
- Execution history information is combined with structural information determined from the runtime representation of the program source, to establish what is the dominant path of the program the compiler should compile. Unexecuted code is preferably never included in the dominant path.
- the compiler treats the dominant path as a super-block fragment, laying the code out sequentially, even though the program source may not be. Branches and tests are adjusted where necessary to make the dominant path fall-through. Code and registers are optimised with the assumption that the dominant path will be followed to the end. This improves performance on modern processor architectures. Critically, the dominant path only exposes one external entry point. This greatly simplifies and enhances optimisations.
- the appropriate run-time tests are inserted with a forward branch 1000 to some stub code referred to as an “Outlier” 1002 .
- the outlier stub updates any state which the dominant path has not written back yet, before transferring control out of the fragment.
- the mainline code of dominant paths are generally kept together, as are the outlier stubs as shown at 1002 . This improves performance on modern processors, especially where branch prediction software/hardware initially assumes that forward branches are less likely. It also provides better instruction cache behaviour.
- optimisations can be made in compiling the code.
- the optimisations may be made at block level or may be more widespread, in particular where several blocks are involved.
- An advantage of the preferred embodiments of the invention is that flow analysis need not be carried out. Registers are preferably used for the compiled code to give faster execution of the compiled code.
- fallback interpreter is available for use, it is possible to make various assumptions when compiling the code and to omit several safety checks which might otherwise have been required if no fallback interpreter were available. If later any of the assumptions is proved wrong, or if the lack of safety checks would cause something to go wrong, the fallback interpreter can be used to interpret the relevant non-compiled code.
- Execution history is captured as the application executes. It is maintained at the block level, when a transfer of control occurs. It is preferred for the execution history recorder to record when a block is entered (when the transfer of control into the block occurs). The execution history recorder may also record other details relating to the execution of the block, for example which is the next block (successor) that was executed after the block in question. Thus information about the preferred route of execution through the blocks of code may be obtained rather than only information about individual blocks.
- execution history records are recycled in two ways. Firstly, the list of successors is limited to a small number, and when a new successor is encountered the least popular existing successor is replaced with the new one. When there are no free execution history records, all of the history records associated with the least frequently used method are moved to the free list.
- compilation of a fragment is triggered by the entry count of a block exceeding a given threshold.
- the threshold may be fixed, or dynamically tuned. However, if the state of the history block indicates that the block is already queued to be compiled, or is not compilable, it is ignored. Such a block may not be queued for compilation.
- the code when the code is first executed, none of the code is compiled.
- Execution is initially carried out by the interpreter. As each block is interpreted, the count of the block held by the execution history is increased by one.
- the execution history recorder records, for each block, from where the transfer of control into the block came and to where the control was transferred from the block.
- the execution history may also contain further information about the execution of the block, for example the type of code executed in the block.
- a threshold is set and when the count for a particular block reaches the threshold value, the block is entered on the queue for compilation. The threshold may be 5; when a particular block has been executed 5 times, it is entered on the queue.
- the compiler is associated with a compiler manager which manages the queue of blocks for compilation. When a particular block reaches the threshold number of executions, the execution history recorder sends a message to the compiler manager to enter the block on the queue for compilation.
- the compiler is running on a separate thread and checks at intervals to see whether there is an item for compilation in the queue and, at some time, the compiler will start to compile the block referred to at the top of the queue.
- the queue is managed so that new entries onto the queue are entered at the top of the queue and are therefore most likely to be compiled.
- the compiler manager may delete part or all of the queue from time to time.
- the threshold can be raised. Equally, if few, or no, blocks are being queued for compilation, the threshold can be lowered. This can be carried out dynamically during the execution of the application.
- the compiler manager can monitor the length of the queue and, if desired, send a message to the execution history recorder to increase or decrease the threshold.
- the compiler When the compiler compiles a block which is queued by the compiler manager, it may proceed to compile just that single block. It is preferred, however, that the compiler uses the information gathered by the execution history recorder regarding the successors of the block and compiles not only the single block which has reached the threshold but also the most popular successors of the block, thus compiling the most popular path from the block (the dominant path). It will be appreciated that the successors of the block may or may not have been executed the threshold number of times to be eligible for compilation in their own right but, nevertheless, are compiled as a part of the dominant path from a block which has been executed the threshold number of times.
- the compiler When the compiler takes a block for compilation, it carries out checks to determine whether the block is one which is desirable to compile, for example, if it is able to be compiled, and whether there is already a compiled version of the block available.
- the compiler then traces the dominant path (though the most popular successors of the block) until it gets to the end of the method or comes across a piece of code which it is not desirable to compile, for example because a compiled version already exists.
- Other code which is not desirable to compile would be code which merges back into the dominant path other than at the original block that triggered compilation.
- Flow analysis would be required for optimal compilation otherwise.
- the compiler detects and prevents such control flow merges from occurring (having determined the likely flow at a branch, the unlikely flow is handled by generating code to exit the fragment). It will not pass beyond the end of the method but it will follow, for example, invokes to follow the dominant path.
- the compiler stops in its tracing of the dominant path it starts to compile the code, starting at the beginning of the dominant path.
- the dominant path can be determined by following the most popular successors a block at a time, including following method calls.
- both or all of the paths through the method may be dominant paths and be compiled if the relevant blocks are executed sufficient times.
- Execution history does not need to be accurate, and can be updated in a number of ways. Rather than track execution history in compiled code, which would slow execution down significantly, execution history is maintained by the fallback interpreter.
- fallback interpreter means that when infrequent or exceptional code is executed, execution can continue without the presence of compiled code for it.
- the fallback interpreter maintains execution history. It also means that all issues to do with class resolution can be solely handled by the fallback interpreter.
- a dynamic compiler can generate optimised code for any new frequently executed paths which show up. By running as a separate thread, this allows the application to continue useful work via the fallback interpreter.
- the compiler Once the compiler has completed the compilation of the dominant path for a particular block, it sends a message to the compiler manager that the compilation has been completed. Until complete, the compiled code is kept from the executable code. The compiler manager loads the compiled code in the executable code. The necessary changes are made in the dispatch tables and code cache to indicate that the compiled code is available for the relevant block and where the compiled code is. The introduction of the compiled code is carried out atomically so that the stopping of running threads is not required.
- the fallback interpreter can be used to interpret a non-dominant path through the code. However, if a dominant path which has been compiled is subsequently executed infrequently, it would be desirable to remove the compiled version of the code to release the memory used by the compiled version.
- the number of times of execution of each piece of compiled code is monitored and, if it is executed infrequently, can be marked as suitable for deletion.
- the number of times a code buffer is accessed is recorded. Before passing control into a buffer, its execution count is increased. The least popular buffer may be deleted when desirable.
- the compiler may run out of code buffer space. A buffer is then deleted. If a count has been made of the number of times control has been passed into the various buffers, the least popular buffer may be deleted. Alternatively, the oldest buffer may be deleted.
- FIG. 1B The fact that compilation costs can be radically reduced is illustrated by the schematic diagram in FIG. 1B in which the comparative time taken up in profiling, compiling and executing at full speed for the invention 1020 and the typical prior art 1022 are shown as a proportion of a 10-second time slot.
- the dynamic compiler works within external configurable constraints imposed upon it at system start up or build time. It then compiles as much of a fragment as it can within these constraints. If necessary, it truncates the fragment, by relying on the feedback interpreter to receive control at the truncation point. This is impossible in prior art compilers, where the unit of compilation is a method or greater, and where no interaction with a fallback interpreter is available.
- the system described includes a virtual machine (VM) and includes an interpreter (in C language) and a Java application.
- VM virtual machine
- the system is multithreaded and includes a Java main thread, a Compiler Manager thread and a compiler thread.
- the Java thread is started: Java A class load A
- Class A is loaded and A's dispatch table is loaded.
- the dispatch table is shown schematically in FIG. 1C.
- FIG. 1C shows A's dispatch table 1030 having various address entries 1032 .
- the main method is located at address 4000 .
- the main program of the VM identifies the address of the method main A at 4000 and calls glue code:
- Glue code is a part of the conversion device which enables the execution to switch between the use of the interpreter and the execution of compiled code.
- Glue code includes several devices for effecting smooth transfer between the execution of compiled code and non-compiled code.
- Glue code includes sections for one or more of:
- the conversion device may include outliers as described above for updating the states. For example, when an exception is encountered in execution of compiled code, control may pass first to an outlier for states to be updated before passing to the glue code for instructing the interpreter to begin executing the code for dealing with the exception.
- the glue code then calls the interpreter to start to execute code beginning at address 4000 :
- the interpreter starts at address 4000 and executes the byte code until it reaches the invoke instruction.
- the interpreter returns to the glue code which determines that the interpreter is trying to perform the invoke.
- the interpreter knows where the invoke is in the dispatch table, and tells the glue code.
- the glue code takes the object reference for the method off the stack and looks at the dispatch table to get the address for the method.
- the dispatch table includes an entry for “invoke glue” and a return is effected to a separate section of the glue code which starts interpretation of the method at the relevant address:
- the interpreter When the interpreter jumps into the method, it sends a message to the execution history recorder that the method is about to be executed.
- the glue code includes a dedicated portion for handling returns which ensures that the register, stacks, and so on are correct for the execution of the next piece of code. For example, where the method has been executed from a compiled version and the next piece of code is to be interpreted, anything put onto registers for the compiled version has to be restored into the correct memory location before the next section of code is generated. Thus the return handling glue code restores any states which have been altered as a result of the use of the compiled code.
- glue code described above may all be a part of the same piece of glue code, or may be separate glue code pieces.
- the updating of the states may be carried out by outliers as described above and in Agent's reference no. 3 of this specification.
- a further example below describes the action of the interpreter for a transfer of control other than an invoke.
- the method void func is called for the first time. There is no compiled version so the method starts execution by the interpreter. At execution time, the following blocks (groups of lines of code) are recognised by the interpreter:
- the interpreter executes the first block b 1 .
- the interpreter runs an execution history recorder in which it records that b 1 has been executed once and has a count of 1. (Preferably, it also records that the successor of b 1 , is b 2 and that b 1 was executed all of the way through. For simplicity, references to the recordal of such extra information is omitted below).
- the interpreter consults the code cache to see if there is a compiled version of the next block b 2 . (Note that in this example, while there is a transfer of control from one block to another, there is not an invoke and thus there is no return to the glue code. In an alternative embodiment, the interpreter might return to the glue code after every block, but that is likely to be time consuming. In the preferred embodiments described herein, the interpreter only returns to the glue code when
- the interpreter proceeds to execute b 2 , giving b 2 a count of 1 in the execution history recorder.
- the interpreter consults the cache again and, finding no compiled version of b 3 , proceeds to execute b 3 .
- the loop is repeated 3 times so when a return is made from the method by block b 4 (going through the return handler glue code as described above), the counts of the blocks in the execution history recorder are as follows:
- the execution history recorder sends a message to the Compiler Manager to queue b 3 for compilation.
- the compiler will consult the queue, and compile b 3 .
- the compiler determines the dominant path from b 3 using the record for b 3 in the execution history recorder which indicates the successors of b 3 .
- the most popular successor of b 3 is b 3 so that only the single block b 3 representing the loop is compiled.
- the compilation of b 3 may be optimised for example by using registers to store the values of p, x, i and a.
- the compiler has completed the compilation, it notifies the Compiler Manager what compilation has been done, where the compiled version is and whether it includes a method entry point or not. The compiled version is not available for execution at this time.
- the compiler manager will load the compiled version of b 3 .
- the code cache is updated so that the host code address for that part of the method now points to where the compiled code is.
- the interpreter consults the code cache after execution of b 2 and finds that a compiled version of b 3 is available.
- the interpreter returns to the glue code which, as described above, effects the execution of the compiled version of b 3 .
- the compiled code for b 1 /b 2 is executed, a return is made to the glue code, which effects execution of the b 3 compiled code. If the path from compiled b 1 /b 2 to the glue to the compiled b 3 is effected a sufficient number of times, a patch connecting the compiled b 1 /b 2 to compiled b 3 may be made. (Patching is described in more detail under Agent's reference no. 12 of this specification). Thus the execution can be made more efficient because the step through the glue is no longer required.
- a memory manager associated with the compiler manager decides that memory for the compiler should be freed.
- the oldest buffer chosen for deletion includes the compiled version of b 3 .
- the compiler manager calls the deleter to delete the buffer.
- FIG. 1D shows apparatus 1040 suitable for carrying out the embodiment described above.
- the apparatus 1040 includes an interpreter 1042 for interpreting Java code 1043 in the computer system.
- interpreter 1042 for interpreting Java code 1043 in the computer system.
- the interpreter reaches the end of a block of code, unless there is an invoke or a return, it consults the code cache using the code cache searcher 1044 to see if a compiled version of the next block is available. If there is, the converter device 1046 (which includes the glue code referred to above) carries out the necessary changes and alterations before passing control to an executer 1048 for executing the compiled version 1049 of the code.
- interpreter 1042 executes, it records in the execution history recorder 1050 which blocks of code have been executed as well as further details about the execution of the block, for example which blocks were executed before and after the block and what type of code was executed.
- the execution history recorder 1050 notifies the compiler manager 1052 when a block is executed a threshold number of times.
- the block is held in a queue 1054 managed by the compiler manager 1052 .
- a threshold tuner 1056 monitors the length of the queue from information from the compiler manager 1052 . Based on information regarding the length of the queue, the threshold tuner 1056 alters the threshold for the execution history recorder 1050 to send a block to the compiler manager.
- a compiler 1058 compiles blocks referred to in the queue 1054 .
- the compiler 1058 uses information from the execution history recorder 1050 regarding the execution of the block to determine the dominant path from the block and prepares a complied version of the code.
- the compiler 1058 notifies the compiler manager 1052 which updates the necessary dispatch tables and code caches and loads the compiled version.
- the compiler manager 1052 includes a memory manager 1060 which monitors the memory available to the compiler 1058 . If memory available becomes low, the memory manager 1060 instructs a deleter 1062 to delete some of the compiled code. Also, if the queue 1054 becomes too long, the compiler manager 1052 instructs the deleter 1062 to delete some or all of the queue 1054 .
- FIG. 1E shows paths of execution through code of a method generally referred to as 1066 .
- the figure shows schematically various fragments of code, for example 1068 , 1070 , 1072 .
- Such fragments of code may each represent a block of code.
- the code shown in the Figure has one external entry point 1074 .
- a conditional branch 1076 for example an exception check. If an exception occurs, the execution passes along path A to code 1078 to handle the exception. Otherwise, code passes along path B to code block 1080 at which point there may be a call (path C to block 1082 ) or the execution may follow path D to code sections 1083 , 1084 . Execution may pass along path E to block 1085 or path F to block 1086 .
- block 1068 If block 1068 is found to have been executed by the interpreter the threshold number of times, it is passed to the queue 1054 .
- the compiler 1058 consults the execution history in the recorder 1050 and finds that:
- the compiler 1058 determines that the dominant path is therefore 1068 , 1070 , 1072 , 1080 , 1083 , 1084 , 1085 through the code.
- the dominant path is indicated as 1088 .
- the compiled dominant path fragment includes fragments 1068 , 1070 , 1072 , 1080 and 1083 .
- the invention may be embodied in any, some or all of the following forms: it may be embodied in a method of operating a computer system; it may be embodied in the computer system itself; it may be embodied in a computer system when programmed with or adapted or arranged to execute the method of operating that system; and/or it may be embodied in a computer-readable storage medium having a program recorded thereon which is adapted to operate according to the method of operating the system.
- computer system may be interchanged for “computer”, “system”, “equipment”, “apparatus”, “machine” and like terms.
- the computer system may be or may include a virtual machine.
- Agent's Reference No. 2 Computer System, Computer-readable Storage Medium and Method of Operating Same, and Method of Operating that System
- the present invention relates to computer systems and to methods of operating computer systems.
- the invention preferably relates to a computer system including a compiler for compiling code and to a method of compiling code in a computer system.
- the invention relates to computer systems running interpreted languages, for example Java.
- the invention preferably relates to object-oriented programs (preferably Java).
- the invention relates to pre-exception condition checks.
- Java is a language which is rich in exceptions. Java also has various mechanisms for dealing with exceptions when they occur.
- a ‘checked’ exception will either be ‘caught’ or ‘thrown’. Indeed the compiler will force a checked exception to be caught or thrown. In contrast, an ‘unchecked’ exception is more like a runtime error, such as divide-by-zero, and neither Java nor C++ forces declaration of a throw.
- the object reference indicates the type of exception and goes to a table for instructions (assuming there are any for that exception) on how the exception is to be handled. For example, the table might indicate that if the exception occurs in any of lines 1-20, it will be handled in line 21.
- Java is a language rich in exceptions. Java state must be written to as dictated by the semantics of the Java program.
- Another example involves an exception condition covering the situation where a point may be reached in a division step where the denominator equals zero.
- This example involves division of a variable x by another variable i.
- the present invention seeks to mitigate this and/or other problems.
- a method of compiling a fragment of code including a possible exception including the step of including a pre-exception condition check.
- the pre-exception condition check is preferably included in the compiled version of the fragment of code. By using a pre-exception condition check, it can be determined early on before the code which might raise an exception is executed, whether an exception will occur. If the check shows that no exception will occur, it will then be safe to execute the code including the exception.
- the pre-exception condition check will preferably be included immediately before the body of the fragment of code in which the exception might occur.
- code other than the pre-exception check can be optimised.
- the condition check is included at the beginning of the compiled fragment. That is especially preferred where the fragment contains a loop.
- the fragment of code is compiled on the assumption that the exception will not occur.
- the pre-exception check is used, if the check is passed it is known that the exception will not occur.
- optimisations may be made which would not have been safe to make if it were not known whether or not the exception would occur.
- the compiled code can be more efficient, both in terms of the increased speed in executing the code as well as being more compact, thus occupying less memory space.
- the method includes providing a bailout device for use if the condition check determines that an exception will occur.
- the pre-exception condition check will determine that no exception will occur and execution of the compiled code can proceed. However, in some cases, an exception will occur and the condition check will determine that an exception condition is imminent.
- the bailout device preferably allows the exception to be encountered in the interpreter at the expected point of execution.
- the original code fragment included code for dealing with the exception that code is not included in the compiled version as a part of the optimisation procedure.
- the code is preferably compiled so as not to be cluttered with code for use in the further detection and handling of exceptions which occur infrequently.
- an interpreter is used to interpret uncompiled code for handling the exception.
- the bailout device is arranged to pass control to an interpreter. The control is forced to pass to the interpreter because, since there is a compiled version of the code, the interpreter would normally not be used for execution of that code.
- the compiled version of the code is preferably prepared only for use when the exception does not occur and is compiled so as to optimise the compiled code for that situation.
- the compiled code is preferably not used and the interpreter is used to execute up to the point of detecting the condition, and raising the exception.
- the compiled version of the code for use where an exception occurred would be infrequently used and would clutter up the memory allocated for compiled versions of code.
- the condition of states (for example the values of integer variables and the register states) when the condition check reveals that the exception will occur, is not the same as for the corresponding uncompiled code.
- the bailout device includes an outlier for updating states.
- the fragment is a dominant path fragment of code.
- at least part of the code forms a loop.
- the method also includes the step of determining a dominant path through the code.
- infrequently executed code for example non-dominant path fragments of code are not compiled.
- the compiler compiles only dominant path fragments of code.
- the invention also provides a compiler for compiling code according to the method described above.
- Also provided by the invention is an apparatus for compiling a fragment of code including a possible exception, the apparatus including means for including a pre-exception condition check.
- the apparatus is preferably a part of a computer system, preferably a virtual machine.
- the invention relates in particular to interpreted languages, and has particular relevance to Java.
- the compiler is arranged to include the condition check at the beginning of the compiled fragment and preferably the compiler is arranged to compile the fragment of code on the assumption that the exception will not occur. This is of particular relevance where the fragment includes a loop.
- the apparatus includes a bailout device for use if the condition check determines that an exception will occur.
- the bailout device is preferably provided on compilation by the compiler.
- the apparatus further includes an interpreter and the bailout device is arranged to pass control to the interpreter.
- the interpreter is arranged to interpret the code for handling the exception.
- the bailout device includes an outlier for updating states.
- control is relinquished from the execution of compiled code and, it will often be necessary to update states before the control is passed.
- the fragment is a dominant path fragment of code and preferably the compiler is arranged to compile the dominant path code.
- the compiler is arranged to compile only dominant path fragments of code.
- the compiler is an on-line compiler. The execution time impact of the compiler and the amount of memory that it uses can be reduced if the compiler only compiles dominant path fragments of code.
- the invention also provides code compiled using a method described above.
- code for a computer system including a fragment of compiled code including a possible exception, the code further including a pre-exception condition check.
- the code further includes a bailout device for use if an exception is indicated and preferably, the bailout device includes means for forcing a transfer of control to an interpreter.
- Also provided by the invention is a computer-readable storage medium having structured data recorded thereon including code as described above, and also a computer-readable storage medium having a programme recorded thereon for carrying out a method as described above.
- a computer system when programmed with a method as aforesaid, and a computer system when programmed according to a method in which a fragment of code including a possible exception is compiled, the method including a pre-exception check.
- the invention aims to allow optimisations relating to code motion in the presence of exception conditions within loops, which in turn improves the execution speed of the resulting compiled fragment.
- such a check critically relies upon the presence of the fallback interpreter. If the check detects an exception condition, then control reverts to the fallback interpreter without the possibility of re-entering the fragment at this loop entry point. The fallback interpreter continues execution at the loop entry point, and hence executes up to the point where the exception is encountered at its correct control point, thus raising the exception with all Java states containing the correct values. If the pre-exception condition check passes however, then the fragment is safely usable, and any code motion optimisations are valid.
- pre-exception condition checks are effected outside any execution loops, to reduce any time penalty of execution of the checks (in particular where the loop may be repeated a large number of times).
- the compiled code includes several pre-exception condition checks, to check for several possible exceptions.
- Such checks may be arranged as a collection of individual checks, or may include a single check which determines whether any of a number of exception conditions exists.
- the computer system includes a virtual machine.
- the method of the invention finds particular application in the context of a virtual machine (VM).
- VM virtual machine
- a VM requires a small memory footprint in embedded systems, and the present invention allows the footprint of the compiled version of code in the virtual machine to be reduced.
- the invention finds particular application for interpreted languages, where an interpreter may be used, and in particular the Java language.
- the interpreter can be used as a fall back for when an exception is indicated. If the interpreter were not present, a number of different compiled versions of code might have to be provided to deal with alternative routes through the code, for example in the presence of exceptions. Such an arrangement might reduce, or indeed cancel, any benefit in reduced memory space occupied by compiled versions of the code.
- the benefits of the invention may include increased safety in execution (by use of the condition checks), preferably without incurring increased execution time and memory penalties.
- a further advantage of the invention is the choice of the fast (unchecked) route through the compiled fragment or the slow (exception detecting route through the fallback interpreter.
- the invention enables the fast route to take advantage of code motion (including exception condition checks) outside of a loop, even in the presence of exception conditions within the loop. This choice is unavailable to prior compilers which have compiled the entire method and whose compiled methods do not have the ability to interact with an interpreter to field exception conditions.
- a computer system including (preferably during the running of a program) means for compiling an exception check to identify the occurrence of an exception condition, and means for executing an exception, when identified by the exception check, in an interpreted language.
- the invention provides a method of operating a computer system including the steps of: running a program; compiling an exception check to identify the occurrence of an imminent exception condition, and executing an exception, when identified by the exception check, in an interpreted language.
- the exception check is carried out outside a processing loop, whereby preferably to avoid the need for the exception check to be carried out at each circulation of the loop.
- An advantage of the invention is the choice of taking the fast (unchecked) route through the compiler or the slow (exception detecting) route through the interpreter which is not available to prior compilers off-line.
- FIG. 2A shows apparatus for carrying out the method of the invention
- FIG. 2B shows a fragment of code including an exception
- FIG. 2C shows a compiled fragment of code in accordance with the present invention.
- the method func When the method func is first invoked, it will be executed by the interpreter. If an exception occurs, it will be dealt with in the normal way and, because the code is being interpreted, the write to x will only occur if the exception does not occur. In accordance with a preferred aspect, if fragments of the code of the method func are executed sufficient times by the interpreter such that the fragments are considered to be dominant path fragments of the code, they are queued for compilation. A detailed discussion will be found in Agent's reference no. 1 of this specification.
- the repeating loop represents a third block b 3 .
- Block b 3 is represented by lines 12 to 27 of the bytecode. When block b 3 has been executed sufficient times, it will be queued for compilation.
- the compiler sees that there is a possible ‘divide by zero’ exception in the block b 3 .
- a pre-exception condition check is inserted into the compiled version of the block b 3 .
- the check is inserted at the beginning of the compiled fragment. (It could, of course, be inserted at any point before the exception might occur in the compiled code. Where the exception could occur within a loop, preferably the check is inserted prior to the entry point of the loop.
- the entry point of the loop will, in any case, be the start of a dominant path fragment.
- a compiled version of block b 3 might be, for example, as shown in the left-hand column below (given in simplified code for clarity). An indication as to the step performed by each section of compiled code is included in the right-hand column.
- Compiled code Step performed cmp i, 0 compare i with zero ble glue_bailout if i is less than or equal to 0, go to the glue code load r a , b load b into the register store r a , y y b (loop invariant step) load r n , i load registers for start of loop load r m , x div r s , r m , r n x/i and store result in register s add r n , 1 i++ cmp r n , r a i ⁇ b blt if i ⁇ b, repeat the loop (from div r s , r m , r n )
- the first two lines of the compiled code above include the pre-exception condition check. If i is greater than zero, the check passes and the remainder of the compiled code is executed (from the third line). If i is less than or equal to 0, the second line of code transfers the execution to the glue code of the bailout device as described below. The remainder of the compiled block b 3 is not then executed. Note that the interpreter then interprets the loop from the start of the loop body, through to the point where an exception is detected. Thus the check in the compiled code is giving an early warning of an imminent exception rather than an immediate one. In some case this can reduce the number of steps carried out in the compiled code which have to be “undone” before control is transferred to the interpreter.
- pre-exception condition check (either before or after the i is less than or equal to 0 check), for the situation where i is out of bounds for the execution of the loop.
- each section of compiled code may have several pre-exception condition checks. Examples of types of pre-exception condition checks are discussed below.
- the first line of the compiled code is executed to check if i is less than or equal to 0. If it does, the second line of code directs the execution to a specific entry point of the glue code.
- the glue code then forces control to pass to the interpreter.
- the glue code tells the interpreter at which address to start to interpret code (and not to consult the code cache before executing (because the code cache will contain a reference to the compiled version and in this case the compiled version cannot be used)).
- the glue code indicates to the interpreter to recommence execution at the beginning of the non-compiled version of the block b 3 (from iload — 3, see above).
- the interpreter sees the exception at the correct time and it is dealt with accordingly. (The interpreter cannot raise the exception too early.)
- control may pass back through the glue code for the execution of a compiled version of code as discussed in Agent's reference no. 1 of this specification.
- a separate pre-exception condition check could be used for any exception which could occur in the code to be compiled.
- One pre-exception condition check could be used to check for several possible exceptions.
- a suite of such pre-exception checks are available for use, including early typecast check, early bounds check against the possible range of array index values, early null-reference check, early divide by zero, and early object type check, to enable code motion and other early checks to be applied to inlined methods.
- a checkcast check proves whether or not an object of a given type can be stored in a field for that type—for example, the check could answer the question whether a ‘graphics’ type object could be stored in a ‘car’ type object.
- Java and other object oriented languages
- Java has a hierarchical structure for classes where if Class A extends a Class 0 and Class B extends a Class 0 then Class A and Class B are not related. Conversely, if Class A extends Class 0 and Class B extends Class A then Class B is a subclass of A and the system could use B where it uses A. Thus it will be seen that there is scope for an exception to arise where the hierarchy of objects in a section of code is not appropriate.
- the checkcast condition check checks to see that the class relationship is correct and, if the checkcast check fails, control passes to the bailout device.
- a bounds check proves whether the array index is within the permitted limits, that is, the bounds, of the array, otherwise it refers to the bailout device (glue code) to raise the exception for the index being out of bounds.
- the bailout device glue code
- a null-reference check identifies whether a field reference is null, in which case nothing can be done with that field.
- a divide-by-zero check determines whether a situation will or may be reached where the denominator of a divider function becomes zero, an uncomputable function.
- An object type check can best be described as a check to ensure that objects are fitted into the hierarchical structure of an object-oriented system with the correct implementation of methods.
- the object type check is made to determine whether the called method can appropriately be implemented on the relevant object.
- the check will determine whether the object is a graphics type rather than anything else and whether the draw method is appropriate for the object.
- FIG. 2A Apparatus for carrying out the method of the present invention is shown schematically in FIG. 2A.
- the apparatus includes an interpreter 2000 for interpreting code.
- An execution history recorder 2002 records details of the execution of the code by the interpreter 2000 .
- the execution history recorder 2002 notifies the compiler manager 2004 which administers a queue of blocks for compilation.
- the compiler 2006 consults the queue and takes blocks for compilation, determines the dominant path from the records of the execution history recorder 2002 .
- the compiler also determines whether there are any possible exceptions which may occur in the dominant path fragment to be compiled. If so, the necessary pre-exception condition checks are inserted at the beginning of the compiled fragment of code.
- the compiler 2006 compiles the fragment and sets up any necessary links to bailout devices 2008 .
- the compiled code is executed by the execution device 2010 . If the pre-exception condition check indicates that an exception will occur, the bailout device 2008 transfers to glue code 2014 which passes control to the interpreter 2000 for execution of non-compiled code relating to the exception.
- FIG. 2B shows a section of uncompiled Java code 2100 . Code section 2100 would be executed using the interpreter 2000 .
- the section 2100 includes a loop 2102 .
- a possible exception 2104 for example a division which might result in a ‘divide by zero’ exception.
- the loop 2102 also includes a loop invariant term 2106 which it is desired to move out of the loop to increase the speed of execution of the loop 2102 .
- FIG. 2C shows the compiled version of the code fragment (indicated generally as 2108 ).
- the compiled code fragment 2108 includes a pre-exception condition check 2112 to check to see whether the exception will occur.
- the compiled version still includes a loop 2114 but, due to optimisations made in the compilation, it is smaller than before, and quicker to execute.
- the loop invariant term 2116 has been moved out of the loop 2114 , to increase the speed of execution.
- the pre-exception condition check 2112 includes a path 2118 to a bailout device 2008 for the case in which it is found that an exception will occur.
- the invention may be embodied in any, some or all of the following forms: it may be embodied in a method of operating a computer system; it may be embodied in the computer system itself; it may be embodied in a computer system when programmed with or adapted or arranged to execute the method of operating that system; and/or it may be embodied in a computer-readable storage medium having a program recorded thereon which is adapted to operate according to the method of operating the system.
- computer system may be interchanged for ‘computer’, ‘system’, ‘equipment’, ‘apparatus’, ‘machine’ and like terms.
- the computer system may be or may include a virtual machine.
- Agent's Reference No. 3 Computer System, Computer-readable Storage Medium and Method of Operating Same, and Method of Operating that System
- the present invention relates to a computer system and to a method of operating a computer system.
- the invention relates to the management of memory in a computer system, and in particular to the management of cache memory in a computer system.
- the invention relates to outliers for spatial separation of infrequent code etc.
- a computer system including a compiler, the compiler being arranged to compile dominant path fragments of code.
- a dominant path represents a frequently executed path of execution through the code and may include a large number of individual blocks of code.
- the system further includes an execution history recorder for recording information about the dominant path.
- an on-line record of the dominant path is made during the execution run.
- the system includes means for determining the dominant path fragment during the execution of the code.
- the system further includes a compiler for compiling code and, preferably, the compiler is arranged to compile a dominant path fragment.
- the compiler is an on-line compiler.
- the dominant path fragment does not include infrequently executed code. Thus, if the dominant path fragments of code are arranged separately from infrequently executed fragments of code, management of the memory of the system can be improved.
- the system further includes an outlier for use where a path of execution leaves the dominant path.
- a computer system including outliers for use in the execution of infrequently executed code.
- control is passed to the outlier.
- the outlier is in the same code buffer as the fragment of dominant path from which control is transferred.
- the dominant path is a ‘best guess’ of the likely path of execution through the code based on current behaviour. It will sometimes prove to be inapplicable for a particular execution of the code. The outliers are used to deal with the situation.
- the system further includes an interpreter.
- the interpreter is used to execute at least some of the infrequently executed code.
- the system further includes a converter for converting between the execution of compiled code and non-compiled code. The converter preferably includes outliers.
- the outlier is adapted to effect transfer of control to the interpreter.
- the outlier is adapted to transfer control to an exception handler.
- the outlier is adapted to update states before execution of infrequently executed code.
- the updating may be required, for example, where optimisations have been used in the compilation of the dominant path code.
- the code includes a conditional branch to the outlier, the conditional branch including a conditional test and being such that execution follows the dominant path if the conditional test fails.
- processors often predict that forward branches will fail and will carry out various checks before the branch is carried out. If the condition of the branch occurs rarely so that usually the execution falls through (in the dominant path), when the code for the condition is compiled, the code is arranged so that if the condition is true, the control passes to the outlier. Thus the forward branch occurs only rarely and thus the processor checks are only carried out on the rarely executed jump to the outlier. Thus, processor time can be reduced because the condition is usually not true and the execution simply drops through to follow the dominant path.
- the system includes means for separating frequently executed code from infrequently executed code.
- the invention further provides a computer system including means for separating frequently executed code and infrequently executed code.
- the means for separating the code may be provided by a compiler which compiles the code in a particular way as described in more detail below. The separation may be effected by arranging that certain types of code are stored in one memory area and other types of code are stored in a different memory location.
- the system further includes an outlier, and means for separating dominant path fragments from the outlier.
- the system preferably includes means for storing the frequently executed code in a first memory region and means for storing infrequently executed code in a second memory region.
- the system includes means for storing the dominant path fragments in a first memory region and means for storing outliers in a second memory region.
- the first memory region and the second memory region are regions of a code buffer.
- the frequently executed code and infrequently executed code are generated in different areas of the code buffer.
- the system may include means for storing the infrequently executed code “backwards” in the buffer.
- the system includes means for storing the dominant path fragments and the outlier at opposite ends of the code buffer.
- the invention further provides a computer system including a code cache, the system being arranged so that infrequently executed code is unlikely to be stored in the cache.
- the frequently executed code includes the compiled dominant path fragments. Those fragments are preferably generated forwards in the code buffer.
- the outliers are preferably generated backwards in the code buffer, thus spatially separated from the dominant path fragments.
- the memory occupied by the outliers in the code buffer can be much less than a compiled version of the original portion of infrequently executed code fragment of the uncompiled code.
- the present invention further provides a computer system including means for storing substantially all of (and preferably only) the dominant path compiled code together in one memory region.
- the system further includes means for storing code for dealing with the non-dominant cases in spatially separate regions.
- the present invention also provides a method of operating a computer system, the method including compiling dominant path fragments of code.
- the method includes determining the dominant path during the execution of the code.
- an outlier is used when a path of execution leaves the dominant path, and preferably the outlier effects transfer of control to the interpreter and/or to an exception handler.
- the outlier updates states before execution of infrequently executed code.
- conditional branch includes a conditional test such that execution follows the dominant path if the conditional test fails.
- the method includes separating frequently executed code from infrequently executed code.
- Also provided by the invention is a method of operating a computer system, including separating frequently executed code and infrequently executed code.
- the method includes separating dominant path fragments from outliers and preferably storing the dominant path fragments in a first memory region and storing outliers in a second memory region.
- the first memory region and the second memory region are regions of a code buffer.
- the method includes storing the dominant path fragments and the outliers at opposite ends of the code buffer.
- the method includes storing the code so that infrequently executed code is unlikely to be pulled into a cache.
- the invention also provides a method of storing code in a computer system including a code cache, the method being such that infrequently executed code is unlikely to be stored in the cache.
- a method of operating a computer system including the steps of: compiling dominant path code, and storing the compiled code in one memory region.
- the method includes storing outliers in a separate memory region.
- Also provided by the invention is a method of compiling code, the compilation being effected so that frequently executed code is separate from outliers.
- the invention also provides code stored in a computer system by a method described herein and provides a compiler for compiling code in accordance with the invention.
- the invention further provides a computer-readable storage medium having a programme recorded thereon for carrying out a method according to the invention.
- the invention also provides a computer-readable storage medium having a programme recorded thereon for compiling code, the compilation being effected so that frequently executed code is separate from outliers.
- the invention further provides a computer programmed according to a method as aforesaid.
- the invention also provides a computer programmed for compiling code, the compilation being effected so that frequently executed code is separate from outliers.
- the invention provides a computer system including means for storing substantially all of (and preferably only) the dominant path compiled code together in one memory region, whilst, preferably, any outlier is only stored in spatially separate regions.
- a memory layout typically maximises the amount of useful code loaded into the cache.
- the invention also provides a method of operating a computer system including the steps of: compiling all of the dominant path code; and storing substantially all of the compiled code in one memory region, while preferably storing outliers in a separate region.
- An ‘outlier’ is so called since it lies out of the normal memory region for predominantly executed code.
- the infrequent, by which may be meant the non-dominant path, code is separated from the more frequently used dominant path code, and so does not get loaded into the cache as long as the dominant path is executing.
- FIG. 3A shows a section of code before compilation
- FIG. 3B shows a standard compilation of the code of FIG. 3A
- FIG. 3C shows compilation of code in accordance with a preferred embodiment
- FIG. 3D shows a code buffer
- FIG. 3E shows the memory arrangement in a computer system
- FIG. 3F shows apparatus for carrying out the method of the invention.
- FIG. 3A shows a section of Java bytecode including blocks B 1 , B 2 , B 3 , B 4 and B 5 which carry out calculations 1, 2, 3, 4 and 5, respectively.
- B 4 is code which deals with exceptions which may occur in B 1 , B 2 or B 3 (see paths 9000 , 9002 and 9004 to B 4 ).
- the dominant path through the blocks is found to be such that control (almost) always passes from B 1 to B 3 (path 9006 ) at the conditional transfer of control at the end of B 1 , and B 3 passes control to B 5 (path 9008 ).
- the paths 9000 , 9002 and 9004 are hardly ever taken.
- An outline of the original Java source for the example of FIG. 3A is void method () ⁇ try ⁇ calculations 1 // calculations 1 and if (condition) if (condition) ⁇ translates to block B1 calculations 2 // calculations 2 translates to block B2 ⁇ calculations 3 // translates to block B3 and a jump to B5 ⁇ ⁇ catch () ⁇ calculations 4 // translates to block B4 ⁇ calculations 5 // translates to block B5 ⁇
- Standard compilation techniques for this code would be to emit code for all five blocks, to allow for all eventualities in the subsequent execution of the compiled code.
- the compiled versions of B 2 and B 4 potentially waste memory space, and as detailed below can lead to reduced cache density of useful code compared to preferred embodiments. If many such methods are compiled in this standard manner, the wider range of address space used to encompass the compiled code can lead to control transfers crossing address space page boundaries more frequently, with ensuing higher frequency of page faults (if virtual memory is enabled on the computer system), compared to preferred embodiments.
- the processor picks up instructions from the memory.
- the memory manager must be interrogated to find and check the next page if that next page is not in main memory. That is time consuming. Crossing a page boundary is therefore time consuming.
- FIG. 3B A standard compilation of the code is shown in FIG. 3B. Blocks B 1 , B 2 , B 3 , B 4 and B 5 are set out sequentially.
- FIG. 3C shows compiled code according to a preferred embodiment. Note that the dominant path includes blocks B 1 , B 3 and B 5 .
- Blocks B 2 and B 4 do not exist in the compiled versions of the code because they were found not to be a part of the dominant path.
- B 5 is also spatially contiguous with block B 3 , and the original unconditional control transfer present in the bytecode for jumping over the exception handler B 4 requires no corresponding host instruction.
- Block B 3 simply drops though into block B 5 in terms of control flow.
- blocks B 1 , B 3 and B 5 are spatially contiguous, and hence occupy a smaller range of the memory address space in total than if they were interspersed with blocks B 2 and B 4 .
- These blocks (B 1 , B 3 and B 5 ) have been packed to model the current execution characteristics of the Java method.
- FIG. 3C shows outliers OL 1 and OL 2 for use if the execution leaves the dominant path. If the conditional test passes at the end of BI, control will pass to OL 1 .
- OL 1 synchronises states (that is, ensures that register-cached values are spilt back to their corresponding memory locations) and then passes control to a piece of glue code to effect resumption of the unpredicted (non-dominant) path corresponding to calculations 2 via a fall back interpreter. Until such time as the corresponding bytecodes of the non-dominant path execute frequently enough to warrant dynamic compilation, these continue to be interpreted, thus saving space in the code buffers (which are limited resources) for more important paths of bytecode execution.
- outliers of the type of OL 1 handle the case where normal control flow takes an unpredicted path away from the dominant path, such as needing to execute calculations 2.
- the interpreter will start execution at the beginning of block B 2 . If the bytecode at 3000 is executed enough, it will later be compiled. The next time the glue is told to interpret from 3000 , it will recognise that there is a compiled version of B 2 . It will amend the ‘callglue’ line of OL 1 (automatically) to ‘goto . . . ’ to direct control to the compiled version. This is known as “patching” (see Agent's Reference No. 12 of this specification). Thus, the next time the outlier OL 1 is called, the control will be transferred directly to B 2 , without the glue being used. (See also Agent's Reference No. 1 of this specification).
- a different type of outlier OL 2 deals with the situation in which an exception condition is recognised within the dominant path (for example, block B 1 attempts to access an array outside of its legal bounds).
- the dominant path passes control to an outlier (OL 2 ) to deal with the exception.
- the outlier synchronises state as usual, and then passes control to the glue code to raise the exception within the virtual machine.
- Outliers are spatially far separated from those blocks of code corresponding to their associated dominant paths.
- a given compilation produces a set of blocks for the dominant path and another set of blocks of outliers used by the dominant path when unpredicted or exceptional behaviour is encountered during execution.
- FIG. 3D shows the blocks of compiled code and the outliers filled into a code buffer 9054 .
- the dominant path blocks are filled into the buffer in the direction 9056 and the outliers are filled in the direction 9058 .
- the dominant path blocks occupy one end of the code buffer, and its outliers the other end.
- Each compilation of a new fragment of code produces new sets of dominant path blocks and outliers and the code buffer is laid out so that the outliers and dominant path blocks grow towards each other.
- the code buffer is managed by the compiler manager which indicates where the pointers are at the high memory and low memory ends of the buffer.
- the compiler manager As the compiled code is generated for a block, the compiled version of the block will be entered in the buffer, followed by the block of code for the outlier(s). The code for the outlier is then moved to the opposite end of the buffer.
- the dominant path blocks and outlier blocks fill the buffer from separate ends. This improves cache density and reduces paging problems.
- the blocks of dominant path code and outliers can be filled from the same end of the buffer, but in blocks for each fragment of code.
- the buffer would include (in order) B 1 , B 3 , B 5 , OL 1 , OL 2 , OL 3 . . . .
- the next fragment to be compiled would also lay down the code for the dominant path blocks followed by that for the outliers. That arrangement is, however, less preferred since address space is being used up by the outliers and there is a greater chance that code of the outliers will be pulled into the cache.
- a processor chip 9200 may operate at a speed of 400 MHz and be associated with an on-board, first level memory cache 9202 of 16K.
- a second level cache 9204 of say 512K would be associated with the chip 9206 .
- the processor would pull instructions in from the cache a line at a time (32 bytes).
- the execution history recorder notes that the block has been executed and also notes from where the control has passed into the block and also notes the successor of the block (to where the control passes from the block). From that information, the most popular successors of each block can be determined and thus the dominant path can be found.
- the code is code of a Java application
- the code is first translated by an interpreter.
- the execution history recorder is run by the interpreter and records information about the interpretation of each block. Once a block has been executed a threshold number of times by the interpreter, the interpreter passes details of the block to a queue for compilation which is managed by a compiler manager. The threshold number of times may be 5.
- the compiler manager inspects the queue and takes the block for compilation, it traces the dominant path from the block using the information recorded by the execution history recorder regarding the interpretation of the block and its most popular successors. The compiler then produces a compiled version of the dominant path fragment of code as described in more detail below.
- a path of execution through the blocks of code is usually B 1 , B 3 , B 5 .
- the compiler traces the dominant path from B 1 and finds that, although the exceptions sometimes occurred, the most popular successor of B 1 was B 3 , and the most popular successor of B 3 was B 5 .
- the dominant path from B 1 is B 1 , B 3 , B 5 .
- the compiler then proceeds to produce a compiled version of the dominant path.
- the fragments B 1 , B 3 , B 5 are laid out sequentially (see fragments B 1 , B 3 , B 5 of FIG. 3C). Optimisations are made in the compilation of the code, for example using known optimisation techniques. Exception checks are inserted at relevant positions in the compiled code, the exception checks corresponding to the checks originally in the blocks B 1 , B 3 , B 5 of the non-compiled code. The exception checks each include a jump to a relevant piece of code called an outlier (OL 2 is shown for the exception in B 1 ). As indicated above, it is preferred that the outlier does not just contain a compiled version of the code B 4 for handling the exceptions. The outliers include code for updating any necessary states and registers before transfer of control out of the compiled version of code.
- the compiled code has been optimised, at the time of the conditional transfer corresponding to that at the end of block B 1 , some states may not yet have been updated at the end of block b 1 . Also, the compiled version of the code may hold states in different memory locations to those of the original code.
- the outlier OL 1 updates all of the states and registers to what they would have been at the transfer of control out of the block B 1 into B 2 . The outlier OL 1 then transfers control to a conversion device which transfers control to the interpreter which then proceeds to interpret the code for B 2 .
- control can be passed back, via the glue code, to the outlier, which reinstates the states which had been updated and execution of the compiled code can resume at block B 3 .
- Agent's Reference No. 1 of this specification for a further discussion of the role of the conversion device and the glue code.
- the compiled code is generated in the code buffer forwards and the outliers are generated in the code buffer backwards so that they are spatially separated in the buffer.
- the outliers are less likely to be pulled into a cache.
- the execution of the exceptions might be slower than for the case where the infrequently executed code was cached with the dominant path code, that decrease in speed is more than compensated for by the increased speed of execution of the dominant path, especially where the infrequently executed code is very rarely executed.
- FIG. 3F Apparatus for carrying out the method of the present invention is shown schematically in FIG. 3F.
- the apparatus includes an interpreter 9300 for interpreting code.
- An execution history recorder 9302 records details of the execution of the code by the interpreter 9300 .
- the execution history recorder 9302 notifies the compiler manager 9304 which administers a queue of blocks for compilation.
- the compiler 9306 consults the queue and takes blocks for compilation, determines the dominant path from the records of the execution history recorder 9302 and compiles the dominant path fragment and prepares any necessary outliers for the fragment.
- the compiled fragments are loaded into the code buffer 9308 .
- the dominant path fragments are loaded forwards in the buffer 9308 and the outliers are loaded backwards in the buffer 9308 .
- lines of the compiled code in the buffer 9308 are pulled into the cache 9310 .
- Compiled code is executed from the buffer 9308 or from the cache 9310 by the execution device 9312 . If an exception is encountered which cannot be handled by the dominant path code, the outlier 9314 updates any necessary states and transfers to the glue code 9316 which transfers control to the interpreter 9300 which proceeds to interpret code for the handling of the exception.
- the invention may be embodied in any, some or all of the following forms: it may be embodied in a method of operating a computer system; it may be embodied in the computer system itself; it may be embodied in a computer system when programmed with of adapted or arranged to execute the method of operating that system; and/or it may be embodied in a computer-readable storage medium having a program recorded thereon which is adapted to operate according to the method of operating the system.
- computer system may be interchanged for ‘computer,’ ‘system,’ ‘equipment,’ ‘apparatus,’ ‘machine’ and like terms.
- the computer system may be or may include a virtual machine.
- Agent's Reference No. 4 Computer System, Computer-readable Storage Medium and Method of Operating Same, and Method of Operating that System
- the invention preferably relates to optimized execution of object oriented languages which use the ‘interface’ abstraction, and in particular Java.
- the invention relates to Dispatch Mechanism for Interface Methods.
- Java supports single inheritance of class types, with interfaces. Interfaces themselves can be multiply inherited from other interfaces. When a concrete class claims to implement a set of interfaces, it must provide or inherit implementations of every method directly or indirectly defined by those interfaces. (See Reference [2] listed under Other Information at the end of Agent's Reference No. 4 in this specification).
- objects are classified in a hierarchical structure with each object associated with attributes (data about its features or properties) and methods (functions it may perform). Typical such functions might be ‘ring’ in the context of a mobile or other telephone, or ‘play’ in the context of audio and/or video reproduction equipment.
- attributes data about its features or properties
- methods functions it may perform.
- Typical such functions might be ‘ring’ in the context of a mobile or other telephone, or ‘play’ in the context of audio and/or video reproduction equipment.
- the attributes and methods of a super class of objects are ‘inherited’ by its subclasses.
- “mode of transportation” 400 is the superclass of both ‘bike’ 402 and ‘car’ 404 classes of objects.
- the ‘car’ sub-class could be subdivided into ‘saloon’ 406 and ‘sports’ 408 and further subdivision is possible according to, for example, the make or model of sports car etc.
- Certain attributes of the ‘car’ sub-class, such as the number of wheels, model, and so on, will be inherited by the ‘saloon’ and ‘sports’ sub-classes.
- methods such as ‘turn on lights’ can be common to cars within the hierarchy, but in some sub-classes the methods themselves may differ to the extent that a certain function has to be performed before lights can actually be turned on. For instance, a sports car with pop-up headlights may need to raise the lights before they can be turned on. In such a case, the inheritance
- ring would be termed an ‘interface.’ Its significance is that ‘ring’ is a function that a variety of objects in the hierarchy would perform (like ‘turn on lights’ in the car example above) but the actual implementation would differ from object to object. Interfaces therefore cut across hierarchies. An interface is thus a list of functions that the object can perform (such as ‘ring’ or ‘play’ or ‘record’ and so on).
- Single inheritance is usually implemented using dispatch tables (otherwise known as virtual function tables).
- a subclass inherits the dispatch table of its superclass, extending it with any new methods, and replacing entries which have been overridden.
- the relevant data is stored in slots in a dispatch table illustrated schematically in FIG. 4B.
- the attributes of an object in a table 410 are always located at the same distance from the start of the object.
- the object includes a pointer 412 to a dispatch table of methods 414 which are always at the same distance from the start for the same function.
- interface methods are used, as explained above, there is no longer any certainty of knowing in which slot of the dispatch table the particular function appears. This is a problem peculiar to the multiple inheritance and particularly interfaces found in Java language.
- Reference [3] listed under Other Information at the end of Agent's Reference No. 4 in this specification describes an optimization where the last offset at which the interface method was found is remembered, and tried as a first guess next time the invoke interface is encountered. If the guess turns out to be wrong, a fuller search is performed. This approach is based on the assumption that a given call site will tend to operate on the same type of objects.
- the invention solves this problem by a method for reducing dispatch times during the execution of a program in object-oriented language, which program has a number of interface methods, the method including the steps of:
- the invention can also be applied in the form of a “virtual machine” wherein software emulates a “virtual” computer system in order to run a “foreign application.
- steps (ii) and (iii) above are still similarly applied.
- the invention also provides a method for reducing dispatch times wherein a virtual machine, and a set of programs executed by the virtual machine are stored on a computer readable medium (such as a CD); the virtual machine being operative to reduce dispatch times in the course of program execution by:
- the dispatch table points to the interface hash table.
- the hash table is part of the dispatch table at the start. This later form of the invention thereby eliminates one level of indirection.
- the interface hash table can contain, for example, slot numbers of the dispatch table.
- the interface hash table can contain function points, thereby eliminating one level of indirection.
- the method of the invention preferably includes the step of calling a special recovery method, in the event of a collision occurring when looking up the same interface method in the interface hash table.
- the hash table can either point to a method stored in the computer, or to a fallback slot in the dispatch table, which will redirect the call to an appropriate stored method, which is designed to “sort out” the class and direct the call to the appropriate location.
- the solution to this problem is to use an extra level of indirection through a hash table.
- the problem of fast access to the required information is solved or alleviated by the use of an interface hash table as well as a dispatch table for each of the various devices.
- FIG. 4A illustrates a hierarchical structure in object-oriented programming
- FIG. 4B shows the arrangement of data stored in dispatch tables
- FIG. 4C shows the application of an interface hash table to a dispatch table
- FIG. 4D is a hierarchical structure of a domestic equipment system
- FIG. 4E shows dispatch tables used in operating devices in the domestic system of FIG. 4D.
- FIG. 4F shows a controller program with driver devices for operating the devices in the domestic system of FIG. 4D.
- FIG. 492 An embodiment of the invention will now be described by way of example only, to illustrate how a “virtual machine” can be applied in practice. It will be appreciated that this is just an illustrative example, because the “virtual machine” can be applied to very many different systems. Examples of these include Mobile Telephones (which incorporate hand-held computers); Set Top Boxes for digital television; Video Equipment which is intended for use with MPEG digital systems; and intelligent Disc Drives.
- the invention is particularly useful where, due to physical size (e.g., Mobile Telephones) memory is limited and more efficient modes of executing programs, using an object-oriented language such as Java, can be used.
- the memory onboard a Mobile Telephone may be limited, for example, to less than 500 kB, and it is in environments with limited memory that the invention works well. However, it can also run well for memories above this.
- FIGS. 4 D- 4 F schematically illustrate an example of employing a virtual machine to a domestic environment where a computer (not shown), or microcontroller (not shown), is equipped with a controller program 460 for controlling the state of operating devices 461 - 464 used in controlling the supply or flow of WATER (e.g. valves); HEAT (e.g. timers, valves, pumps); and LIGHTS (e.g. switches); and also controlling the operation of a VIDEO system (e.g. switches).
- WATER e.g. valves
- HEAT e.g. timers, valves, pumps
- LIGHTS e.g. switches
- VIDEO system e.g. switches
- These operating devices 461 - 464 are each shown connected to respective device drivers 465 - 468 which receive appropriate command signals from the Controller Program 460 during execution of a program, so that appropriate drives are given to the switches, valves, pumps, etc. to produce the required action.
- Input 469 enables the Controller
- FIG. 4D there is shown various parts of a domestic system represented as objects that are classified in a hierarchical structure where DEVICE is a class having the method of on and off that is common to the sub-classes HEATING SYSTEM and ELECTRICAL DEVICE and the subsequent sub-classes HOT WATER SYSTEM (or the domestic hot water used for washing); CENTRAL HEATING (which is a closed circulation system used in space heating); LIGHTS (which include the lights in each room); and VIDEO (which includes the control functions for playing, recording, ejecting cassettes, etc.).
- DEVICE is a class having the method of on and off that is common to the sub-classes HEATING SYSTEM and ELECTRICAL DEVICE and the subsequent sub-classes HOT WATER SYSTEM (or the domestic hot water used for washing); CENTRAL HEATING (which is a closed circulation system used in space heating); LIGHTS (which include the lights in each room); and VIDEO (which includes the control functions for
- the HEATING SYSTEM has the method of Set Temperature, which enables control, of room temperature; the HOT WATER SYSTEM has the method Reload (which is intended to indicate when a water softener cartridge needs to be changed; the LIGHTS sub-class has the method Dim; and the VIDEO sub-class has the attributes Play and Reload cassette.
- FIG. 4E shows the Dispatch Tables for this class and its sub-classes.
- ON and OFF functions occupy positions 1 and 2.
- position 3 for the HOT WATER SYSTEM and the CENTRAL HEATING SYSTEM is Set Temperature
- position 3 for the HOT WATER SYSTEM and the CENTRAL HEATING SYSTEM is Set Temperature
- position 3 is Dim for lights and Reload for WATER and VIDEO.
- the method Reload will need to distinguish between reloading a cartridge in the water softener and reloading a cassette in the Video system, but the Reload attribute is otherwise similar. Only a few control functions have been illustrated in FIG. 4E to simplify the drawings and description, and their dispatch tables will normally contain many more slots or entries.
- FIGS. 4 D- 4 F It is clear from FIGS. 4 D- 4 F that an interface exists, between the class/sub-classes (or control functions, i.e. methods) where the same method is used in controlling a similar function in the operating devices.
- One interface is the ON/OFF method; another interface is RELOAD method.
- Each interface method is allocated a small hash value.
- This interface hash value can be derived in many ways, but must not exceed the size of the hash table.
- the hash values are chosen to reduce as far as possible conflicts between interface methods.
- One way of doing this is to derive pseudo-random hash values from each interface methods name, or some other fairly random attribute of the interface method.
- Hash values should be chosen so that methods of the same interface or related interfaces have unique hash values and do not conflict or clash.
- a larger hash table usually reduces the number of clashes.
- FIG. 4C illustrates an embodiment of the invention wherein the data for an object (e.g. Video) within a particular hierarchy (e.g. FIG. 4D) is located in a data structure such as a table 420 .
- the data structure will contain a header and a plurality of object data fields.
- the dispatch table 422 will automatically re-route the call to a hash table 424 containing a condensed version of the method locations in the dispatch table 422 .
- the hash table 424 will be able to generate an index pointer 426 leading to the correct location in the dispatch table 422 more quickly than searching all possible locations within the dispatch table.
- the same process is followed with other hash tables (not shown) and their respective dispatch tables.
- the hash table will point to a method stored in the computer designed to ‘sort out’ the clash and direct the caller to the appropriate location. This can also be done by first pointing to a slot (e.g., the first) in the dispatch table 422 which then points to the “sort out” method stored in the computer.
- a slot e.g., the first
- each dispatch table is created after defining each concrete class and when the set of methods it implements is known. (The dispatch table will take into account method implementations inherited from its superclass).
- a fixed size hash table is created for each class which maps the interface method hash value described above to a dispatch table index of the corresponding implementation. Where a class implements two or more interface methods which have the same interface hash value, the hash table is set to contain the dispatch table index of the fallback routine for “sorting out” a clash.
- This hash table is either included at the beginning of the dispatch table, or referenced from the dispatch table.
- Interface hash table stored with (before) dispatch table LOAD Rd, doffs [Ro] Load dispatch table address LOAD Ri, ⁇ hash [Ri] Load slot from hash table LOAD Ru, #uniqIfaceId Load unique interface id LOAD Ri, [Rd + Ri] Get method address CALL Ri Invoke interface method
- the interface hash table contains the dispatch table index of a fallback method.
- the fallback method has access (in registers) to the destination object, and a unique identifier for the interface method. It performs the standard search for that object's implementation of the interface method.
- a hash table is a means of reducing to manageable proportions a data set where information is sparsely populated and there is otherwise a high degree of redundancy within the data set.
- a hash table thus can reduce the scale of a whole application and thereby reduce the footprint of the device, one of the important features of Java.
- Each interface method is allocated a small hash value. This interface hash value can be derived in many ways, but must not exceed the size of the hash table used below.
- hash values are chosen to reduce conflicts between interface methods, therefore hash values should be chosen so that methods of the same interface or related interfaces have unique hash values. Clearly an object which implements many interfaces or interfaces with many methods may not be able to avoid clashes.
- a fixed size hash table is created for each class which maps the interface method hash value described above to a dispatch table index of the corresponding implementation. Where a class implements two or more interface methods which have the same interface hash value, the hash table is set to contain the dispatch table index of the fallback routine described below.
- This hash table is either included at the beginning of the dispatch table, or referenced from the dispatch table.
- the interface hash table contains the dispatch table index of a fallback method.
- the fallback method has access (in registers) to the destination object, and a unique identifier for the interface method.
- a hash table is a means of reducing to manageable proportions a data set where information is sparsely populated and there is otherwise a high degree of redundancy within the data set.
- a hash table thus can reduce the scale of a whole application and thereby reduce the footprint of the device, one of the important features of Java. Overflows are taken into account in a way which is already known in the utilisation of hash tables.
- a computer system includes one or more dispatch tables for storing data containing methods appropriate to objects in a class hierarchy and an interface hash table pointing to the location in the dispatch table where a method of interest is located.
- the invention also provides a method of operating a computer system which uses dispatch tables containing methods appropriate to objects in a class hierarchy, including the steps of: directing a call for a method to the dispatch table; passing on the call to a hash table containing information as to the location of methods in the dispatch table; and redirecting the call from the hash table to that location in the dispatch table where the method is stored.
- the invention also provides a computer system including means for storing data relating to an object, means for calling data relating to a method appropriate to the object, a dispatch table adapted to contain data relating to at least one the method, means for passing the call on to a hash table containing information as to the location of method(s) in the dispatch table and means for redirecting the call from the hash table to the dispatch table to access the location of the called method.
- the invention provides both a method of improving the performance of interface dispatching by using a hash table and a computer system including a hash table to improve the performance of interface dispatching.
- the invention provides a method or a computer system in which the interface reference for a particular method is found by means of a hash table.
- interface dispatching is the method by which the slot location for a particular method, e.g., the slot location number (2) for the ‘play’ function of a video recorder, is located and then the relevant data is called.
- Chief advantages of the invention may include faster interface dispatching and/or a reduction in the size of footprint.
- the data for an object within a particular hierarchy is located in a data structure such as a table 420 .
- the data structure will contain a header and a plurality of frames containing relevant data.
- the dispatch table 422 will automatically re-route the call to a hash table 424 containing a condensed version of the method locations in the dispatch table.
- the hash table will be able to generate an index pointer 426 leading to the correct location in the dispatch table more quickly than searching all possible locations within the dispatch table.
- the hash table will point to a method designed to ‘sort out’ the clash and direct the caller to the appropriate location or locations.
- the invention may be embodied in any, some or all of the following forms: it may be embodied in a method of operating a computer system; it may be embodied in the computer system itself; it may be embodied in a computer system when programmed with or adapted or arranged to execute the method of operating that system; and/or it may be embodied in a computer-readable storage medium having a program recorded thereon which is adapted to operate according to the method of operating the system.
- computer system may be interchanged for “computer”, “system”, “equipment”, “apparatus”, “machine” and like terms.
- the computer system may be or may include a virtual machine.
- Java is a trademark of Sun Microsystems.
- Agent's Reference No. 5 Computer System, Computer-readable Storage Medium and Method of Operating Same and Method of Operating that System
- the present invention relates to a computer system and method of operating the same, to so-called return barriers for garbage collection in a computer, to a computer-readable storage medium, computer system, Virtual Machine or similar apparatus incorporating the same, and to an operating method.
- the invention relates to return barriers for garbage collection.
- the invention has general applicability to Run-time Environments. More particularly, it is applicable to automatic dynamic memory management.
- the present invention relates in one aspect to the use of so-called return barriers to minimize blocking while a thread's stack is being inspected by a concurrent garbage collector.
- data is stored in (activation) frames 29000 in an (activation) stack 29002 with the most recent activity being regarded as stored in the lowermost frame in the stack (although it could equally be in the uppermost).
- Garbage collection involves tracing the connectivity of all cells. Any that are not traced in this way are therefore invisible and cannot contain any information of relevance. Those cells can thus be released for use (as additional memory) in the system.
- the garbage collector traces every frame in every thread's stack.
- a typical activation stack is shown in more detail in FIG. 5B.
- the stack ( 29102 as shown in this figure) may be regarded as a memory store in which items are successively added from top to bottom so that the ‘youngest’ items are nearest the bottom of the stack.
- Each stack consists of a number of frames ( 29104 as shown in this figure), each frame containing data and one or more references or frame pointers to other frames or stacks.
- each frame will contain a pointer 29106 to the previous, that is older, frame and a return pointer 29108 into the calling procedure's executable code.
- any references contained in a thread of control's activation stack need to be treated as part of a tracing concurrent garbage collector's root set, and need to be examined during the garbage collection process. It is vitally important that the thread being inspected does not alter any information that the garbage collector (“GC”) thread could be examining.
- One way of achieving this is to suspend execution of the thread to be inspected, allow the GC to inspect the entire contents of the stack, and then to resume execution of the inspected thread.
- the main problem with the above technique which has been identified pursuant to the present invention is that the amount of time a thread will be suspended is determined by the size of the thread's stack, and suspending a thread for too long will lead to noticeable pauses.
- the technique described by this patent allows a thread to continue execution, provided preferably that it is not trying to use a portion of the stack that the GC thread is interested in.
- a method of operating a computer system including at least one, preferably a plurality or even multiplicity of, activation stack(s) arranged to be managed by its (their) respective thread of control, the method including the steps of:
- execution of the thread may be paused for only part of the time that the further thread is accessing the activation stack of the thread.
- any operation which for example wants to examine the contents of another thread's stack can do so without causing that thread to be halted unduly.
- the thread and the further thread may be prevented from accessing the same activation frame at the same time.
- execution by the thread of its current activation frame may be paused for the time it takes the further thread to access the same activation frame.
- a barrier may be provided to selectively prevent return of the thread from its current activation frame into the frame currently being accessed by the further thread.
- one thread would be expected to execute a given activation frame more slowly than the time that the other thread (in this case referred to as the further thread) would take to access it. Accordingly, it is not expected that the return barrier will come into operation particularly frequently. However, it is most important in ensuring that no conflict occurs.
- the preventive effect of the barrier may be selective upon whether the further thread is currently accessing the parent frame of the thread's current activation frame.
- a barrier is provided to prevent return of the thread from its current activation frame into the parent activation frame of the current activation frame of the thread if the further thread is currently accessing the parent activation frame.
- the barrier for the current activation frame may be provided before the further thread changes the frame it is currently accessing. By this feature a form of ‘air lock’ is created.
- a second further thread or even a larger number of further threads may be permitted to access, preferably simultaneously, the same activation stack.
- the further thread is the thread of a, preferably concurrent, garbage collector
- the second further thread is the thread of a debugger
- the thread is any other arbitrary thread within the computer system.
- the barriers are arranged to allow a group of the barriers to be associated with a single activation frame.
- a descriptor block may be provided, the descriptor blocks preferably being linked to form a linked list. This is a convenient way of coping with multiple barriers.
- the further thread may be the thread of a, preferably concurrent, garbage collector.
- the garbage collector makes an initial and at least one further scan of the frames of the stack.
- the at least one further scan only frames which have mutated are scanned. Scanning can be time-consuming and accordingly this feature can reduce the time taken for garbage collection.
- a record may be kept of the extent to which, in the at least one further scan, the frames need to be re-scanned. This record can be used to determine the point at which subsequent scans can be started. More specifically, the record may be of which frames could have mutated or been created between two given scans. Re-scanning may be from the youngest frame which has an intact return barrier to the current activation frame.
- the present invention provides a computer system including:
- [0582] means (preferably a run time engine) for executing the thread using its activation stack
- [0583] means for permitting a further thread to access, preferably simultaneously, the same activation stack.
- the computer system further includes means for pausing (or, for example the run time engine, is further adapted to pause) execution of the thread for only part of the time that it takes the further thread to access the activation stack of the thread.
- the computer system may further include means for preventing (or may further be adapted to prevent) the thread and the further thread from accessing the same activation frame at the same time.
- the computer system may further include means for pausing (or may further be adapted to pause) execution by the thread of its current activation frame for the time it takes the further thread to access the same activation frame.
- the computer system may further include means for providing (or may further be adapted to provide) a barrier to selectively prevent return of the thread from its current activation frame into the frame currently being accessed by the further thread.
- the computer system may further include means for providing (or may further be adapted to provide) a barrier to prevent return of the thread from its current activation frame into the parent activation frame of the current activation frame of the thread if the further thread is currently accessing the parent activation frame.
- the computer system may further include means for providing (or may further be adapted to provide) the barrier for the current activation frame before the further thread changes the frame it is currently accessing.
- the computer system may further include means for permitting (or may further be adapted to permit) a second further thread to access the same activation stack.
- the computer system may be adapted to provide for the same activation frame different barriers for the further and the second further threads.
- the barriers are arranged to allow a group of the barriers to be associated with a single activation frame.
- the computer system may be adapted to provide for each the different barrier a descriptor block, the descriptor blocks being linked to form a linked list.
- the further thread may be the thread of a garbage collector.
- the garbage collector may be adapted to make, in a single cycle, an initial and at least one further scan of the frames of the stack.
- the computer system may be adapted so that in the at least one further scan only frames which have mutated are scanned.
- the computer system may further include means for keeping (or may further be adapted to keep) a record of the extent to which, in the at least one further scan, the frames need to be re-scanned.
- the invention has especial utility in the context of garbage collection.
- Garbage collection is a relatively rapid event by comparison with the speed of execution of a typical procedure call. Thus, it is relatively rare (though, of course, certainly possible) for a return from a procedure call to occur before the garbage collection is complete. In such a rare event the special code is activated; it intercepts attempts to return from an activation frame back to the caller's frame. If the caller's frame is currently being examined by the GC thread, the non-GC thread is compelled to wait until the GC thread has moved onto another frame.
- the invention further provides a method of improving the concurrent garbage collection of reference data contained within a thread stack in a computer system, wherein the thread is only paused for the purpose of garbage collection for the time it takes to examine the current activation frame, rather than the entire stack.
- Preferably measures are taken to prevent the return of an outstanding procedure call into an activation frame whose contents are currently being inspected by the garbage collector until such time as the garbage collector has completed the inspection of that frame.
- Analogous apparatus may also be provided within the scope of the invention, including a garbage collector and means for pausing the thread for the purpose of garbage collection only for the time it takes to examine the current activation frame, rather than the entire stack.
- a computer or computer system including a garbage collector and means for pausing the thread for the purpose of garbage collection only for the time it takes to examine the current activation frame, rather than the entire stack.
- a computer-readable storage medium having a program recorded thereon, the program providing a method of improving the concurrent garbage collection of reference data contained within a thread stack in a computer system, wherein the thread is only paused for the purpose of garbage collection for the time it takes to examine the current activation frame, rather than the entire stack.
- a computer when programmed so as to provide a method of improving the concurrent garbage collection of reference data contained within a thread stack in a computer system, wherein the thread is only paused for the purpose of garbage collection for the time it takes to examine the current activation frame, rather than the entire stack.
- the invention provides a method of improving concurrent garbage collection in a thread stack of a computer system, including the steps of: enabling the garbage collection thread to access the thread of interest in the stack; suspending the execution of the thread of interest only for as long as necessary for the most active activation frame to be examined; editing the return address of the frame to a return barrier code; allowing the thread of interest to continue execution while successive activation frames are examined; and editing the return address of each frame to the same return barrier code before moving on to the next frame.
- the barrier code may be used to prevent the return of an outstanding procedure call into an activation frame whose contents are currently being inspected by the garbage collector until such time as the garbage collector has completed the inspection of that frame.
- the invention thereby achieves the objective of reducing the time that the thread of interest is suspended. It can also maximize the degree of concurrency in a garbage collection system and improves the illusion of concurrency.
- a computer-readable storage medium having a program recorded thereon, the program providing a method of improving concurrent garbage collection in a thread stack of a computer system, including the steps of: enabling the garbage collection thread to access the thread of interest in the stack; suspending the execution of the thread of interest only for as long as necessary for the most active activation frame to be examined; editing the return address of the frame to the return barrier code; allowing the thread of interest to continue execution while successive activation frames are examined; and editing the return address of each frame to the same return barrier code before moving on to the next frame.
- the present invention extends to a computer when programmed according to the above method.
- the present invention also extends to a computer system including at least one, preferably a plurality or even multiplicity of, activation stack(s) arranged to be managed by its (their) respective thread of control, when programmed so as to:
- the present invention also extends to a computer-readable storage medium having a program recorded thereon, the program providing the above method.
- a computer-readable storage medium having a program recorded thereon, the program providing a method of operating a computer system, the computer system including at least one activation stack arranged to be managed by its respective thread of control, the method including the steps of:
- the invention extends to a Virtual Machine including the above computer or computer system.
- the invention extends to a Virtual Machine when operated by the above method.
- the invention extends to a Virtual Machine when operated by means of the above computer-readable storage medium.
- FIG. 5A is a schematic illustration of data storage in a stack
- FIG. 5B shows an activation stack
- FIG. 5C illustrates how checks are made on references in a frame
- FIG. 5D shows the arrangement of data in a procedure call frame
- FIG. 5E shows the execution of a procedure
- FIG. 5F shows the arrangement of the contents of a barrier descriptor block.
- the success of the invention relies on the realization that only the youngest frame will have been changed or mutated as a result of work being done on it.
- the thread is paused, for example for garbage collection, checks are made on all the references in the youngest frame.
- the frame pointer and return address are copied into a separate store ( 29204 ) and the return address is edited into the special code.
- the thread can then continue in the youngest frame.
- the youngest frame wants to return to the previous frame, it may not be able to do so because the GC may be active at that location.
- the return barrier diverts the request to the special code, thereby preventing the thread from returning to the previous frame until the GC has finished.
- the GC lays down the return barrier and the thread removes it when safe to do so.
- a thread's stack is composed of a sequence of frames.
- a frame contains all the information related to one particular outstanding procedure call. All frames contain the following:
- a return address which is the address of some executable code which indicates where program execution should resume from once the procedure call associated with the frame has returned (a return address is a specific kind of instruction pointer);
- a parent frame pointer which is a particular type of pointer to memory which points to an address which indicates the frame of the calling procedure (a parent frame pointer is a specific kind of frame pointer).
- Successive parent frame pointers such as 29406 refer to increasingly older frames 29410 , 29412 .
- procedure A (pa 1 , pa 2 , pa 3 )
- a generic return barrier mechanism is now described (that is a mechanism which is not restricted to use in the context of a garbage collector), by which it can be arranged to have a series of arbitrary functions executed whenever a procedure executing in the context of a particular barriered frame attempts to return. This mechanism incurs no overhead if no barrier is present.
- the return barrier mechanism may have a number of different clients, possibly (or even probably) simultaneously (so that more than one return barrier per frame may be required). More detailed description is provided herein of one particular client, the garbage collector, where the function to be executed is effectively a halting function. Another possible client is a debugging interface, where rather than being a halting function the function concerns the provision of information to the debugger. The important feature in this context is the ability to interrupt the return mechanism.
- d's original parent frame be the original parent frame in the barrier descriptor block pointed to byfs parent frame.
- the procedure return mechanism means that the frame register
- the garbage collector utilises return barriers to ensure that no attempt is made by another thread to continue execution in a frame which is currently being scrutinised by the GC, while allowing execution in frames that are not being examined.
- gcf be a system-wide global variable which contains a reference to the activation frame currently being inspected by the GC thread. Only the GC can alter this, although it can be read by any thread. Hence gcf expresses the concept of the garbage collector focus, the frame which the garbage collector is currently examining.
- the GC thread examines a thread t's stack as described in the following section of pseudo-code:
- the barrier intercept code B is invoked in the relatively unlikely event that a procedure attempts to return from a frame into the parent (caller's) frame (pf), and it will be supplied with a pointer to the frame it is trying to return into. It ensures that no attempt is made to return into a frame that the GC is currently inspecting (that is, it traps attempt to return to the parent frame):
- the non-GC thread can allow its return to caller to complete safely.
- the particular GC being employed may require that a particular thread's stack be examined multiple times in a single GC cycle, until no new activity is detected in the relevant thread (incidentally, this process is guaranteed to terminate at some point, since the heap is of a finite size).
- each frame in each stack would need to be examined the appropriate number of times.
- the barrier function B is enhanced to keep a record (in fact a single record per activation stack) of the most recent frame it had been invoked from. This record effectively represents the “high water mark” of activity on the stack.
- each thread has a variable tl-hwf, which at all times holds the youngest frame in the thread which has an intact GC return barrier.
- the following enhanced technique examines a thread t's stack: suspend t let oldhwf be t's tl-hwf value. if this is the first time this thread is being scanned in this GC cycle, then let scanlimit be NULL else let scanlimit be oldhwf endif let gcf be t's youngest frame. inspect the contents of frame gcf if gcf is not the same as oldhwf then lay down a return barrier B in gcf let laybarriers be TRUE. else let laybarriers be FALSE. endif let t's tl-hwf value be gcf if scanlimit is the same as gcf, then let finished be TRUE.
- gcf be gcf's parent frame. endif allow t to resume execution. while finished is not TRUE do inspect the contents of frame gef if laybarriers is TRUE, then if gcf is not the same as oldhwf, then lay down a return barrier B in gcf else let laybarriers be FALSE. endif endif if scanlimit is the same as gcf, then let finished be TRUE else let gcf be gcf's parent frame.
- this thread refers to the thread executing Code B at the time (several threads may be doing this simultaneously).
- a generic return barrier mechanism is provided, allowing arbitrary actions to be undertaken when a procedure returns.
- the mechanism does not cause excessive overhead to occur when the return barrier is not being used. Only the current frame has to pause when necessary—thereafter the procedure is self regulating in the sense that it can proceed at its own pace; little synchronization or handshaking is required.
- the invention may be embodied in any, some or all of the following forms: it may be embodied in a method of operating a computer system; it may be embodied in the computer system itself; it may be embodied in a computer system when programmed with or adapted or arranged to execute the method of operating that system; and/or it may be embodied in a computer-readable storage medium having a program recorded thereon which is adapted to operate according to the method of operating the system.
- computer system may be interchanged for ‘computer,’ ‘system,’ ‘equipment,’ ‘apparatus,’ ‘machine,’ and like terms.
- the computer system may be or may include a virtual machine.
- Agent's Reference No. 6 Computer System, Computer-readable Storage Medium and Method of Operating Same, and Method of Operating that System
- the invention relates to a method of and apparatus for examining memory in a computer system to allow a section of compiled code to be deleted, and to a method of and apparatus for deleting compiled code in a computer system.
- the invention finds particular (but not exclusive) application in the environment of a unified stack virtual machine in which stack walking allows compiled code to be deleted.
- the invention relates to stack walking to allow compiled code deletion in the multi-threaded environment of a unified stack virtual machine
- the invention applies preferably to virtual machines where compiled portions of the code being run in the virtual machine appear and need to be removed at various times in the execution of the virtual machine; for example, in a dynamically compiling virtual machine.
- the deletion of compiled code from a system can give rise to problems. There may be a link from a section of compiled code which is not being deleted into a section of deleted code. Particular problems can arise because of the proposed use of a native call instruction (or equivalent) to emulate a call or invoke in the virtual machine; this would typically leave the address where execution is to continue once the called method is complete (the “return address”) on that stack for that thread, at or near the stack point when the call or invoke is performed. If the native call instruction is part of a compiled version of a section of code, then the return address will point into the compiled version. This causes no problems until the point of deletion of the compiled version. The return address cannot be left pointing to where the compiled version used to be.
- the present invention seeks to mitigate this and/or other problems.
- the solution to these problems in a preferred embodiment of the invention is, at the point of deletion of the compiled code, to perform an examination of the virtual machine, looking for cases where a return address exists in the stacks that points to a position within the piece of compiled code to be deleted, and to re-arrange the thread's stack contents to allow seamless continuation of execution of that thread without the compiled version of the code which is about to be deleted.
- the mechanism is preferably arranged such that the cost of the operation is borne at the time of deletion, with little or no extra cost at normal call/return time, since the relative frequency of the two situations is such that there are many more call/return operations than code deletion operations.
- the invention in one aspect provides a method of examining memory in a computer system to allow a section of compiled code to be deleted, the method including:
- any such return address is changed to the address of a piece of continuation code.
- the continuation code enables execution to continue after the return without the code to be deleted.
- the continuation code is arranged to transfer control to an interpreter.
- the continuation code may be arranged so that subsequent instructions are interpreted, for example, until a section of emulated instructions is encountered for which there is a compiled version, or alternatively, to jump to a compiled version of the code to be deleted, if such a version exists.
- the use of a fallback interpreter for the execution of instructions subsequent to the return allows execution of the instructions of the deleted compiled code without the overhead of creating a new compiled version of the instructions.
- values in the frame are changed.
- values in the frame are arranged to enable execution to continue without the code to be deleted.
- temporary register information which is stored in the frame may be changed to take into account optimisations which were made when the code to be deleted was compiled. Such changes may be required, for example, where control is to be transferred to an interpreter for subsequent execution (see Agent's reference no. 1 of this specification).
- the alteration of the frame is carried out at the time of deletion.
- none of the links and return addresses of the frame will point into the compiled code after deletion, and time consuming checks during execution can be avoided.
- a plurality of frames in the stack are examined. For example, all frames in the stack may be examined, or else, each frame which may contain a return address pointing into the section of compiled code is examined.
- the computer system operates a multi-threaded environment. Each thread has its own stack.
- the stacks of a plurality of threads in the computer system are examined.
- the stacks of all threads in the computer system may be examined, or else, the stack of every thread to which the code to be deleted may have had access is examined.
- a method of deleting a section of compiled code in a computer system including, examining the memory of the computer system identifying a link to the section of compiled code and altering the link.
- the link to the section of compiled code is preferably a return address in a frame.
- the return address identified when examining a frame is preferably a return address which is in the range of addresses of the section of compiled code to be deleted.
- the examination of the memory may identify a patch or other jump to the compiled code to be deleted.
- the link may be a direct or an indirect link to the compiled code to be deleted.
- the link may be via a section of glue code to the section of compiled code.
- the computer system is configured as a virtual machine.
- an apparatus for examining memory in a computer system to allow a section of compiled code to be deleted including:
- apparatus for deleting compiled code in a computer system including:
- [0791] means for examining a frame of a stack in the computer system
- the apparatus may further include means for executing subsequent instructions, and the means for arranging the contents of the frame may be adapted to change any such return address to the address of the means for executing subsequent instructions.
- the apparatus further includes a fallback interpreter.
- the means for executing subsequent instructions may be arranged to interpret subsequent instructions until a section of emulated instructions is encountered for which there is a compiled version.
- the means for arranging the contents of the frame may be adapted to alter values in the frame to enable execution to continue without the code to be deleted, if the frame contains such a return address.
- a record is kept of the optimisations which have been carried out in compiling code so that “clean up” information will be available as to what alterations are required to update the values to allow for the subsequent execution, for example, by the interpreter.
- the system further includes a compiler system, the compiler system including a recorder for recording “clean up” information as the code is compiled.
- the means for examining a frame in the stack may be adapted to examine a plurality of frames in the stack.
- the means for examining a frame in the stack may be adapted to examine the stack of each of a plurality of threads in the computer system.
- the invention also provides a virtual machine including the apparatus described above.
- the invention further provides a computer system including the apparatus described above.
- the invention provides a computer system including means for deleting compiled code, further including means for examining each frame of each stack of each thread in the system, means for identifying whether a return address points to a portion of compiled code which is to be deleted, and means for rearranging the contents of each stack containing the return address so as to enable that thread to continue execution without that portion of compiled code about to be deleted.
- the invention further provides a computer-readable storage medium having a programme recorded thereon for carrying out a method as described above.
- FIG. 6A illustrates the principle of a virtual machine
- FIG. 6B illustrates the operation of an emulator stack
- FIG. 6C illustrates the operation of a unified stack
- FIG. 6D shows an embodiment of the present invention.
- FIG. 6E shows an apparatus embodiment of the present invention.
- a virtual machine allows software which has been written for one operating system to run on another operating system; the software is then termed ‘non-native’ software.
- the virtual machine emulates the operation of the operating system for which the software was written. This situation is illustrated in FIG. 6A.
- the virtual machine 5004 translates the instructions of the non-native software 5002 into native instructions which can be run by the host operating system 5006 .
- Conventional emulators work by interpreting the non-native instructions during execution.
- Any execution path, or ‘thread,’ will have a stack associated with it.
- a stack is an area in memory that stores frames consisting of temporary register information and return addresses of subroutines.
- the non-native application has its own stack (the emulator stack) separate from the stack of the host operating system.
- FIG. 6B An example of the operation of the emulator stack is shown in FIG. 6B.
- a section of non-native code 5008 has a call instruction at address aaa which calls a subroutine 5010 located at address bbb.
- the address aaa (the return address) is put onto the emulator stack 5009 , together with temporary register information, and the path of execution then jumps to address bbb.
- the emulator encounters a return instruction. It then takes the return address from the stack, together with the register information, and returns to the instruction following the call instruction in the main routine.
- part or all of the instructions are compiled into native instructions that can run on the host operating system. Although a certain amount of time is required for the compilation, significant time savings can made when running the compiled code.
- Time savings can be made in various ways. Firstly, if a section of code is to be executed more than once, then it will be more efficient to execute a compiled version. Secondly, as described above in Agent's reference no. 1 of this specification, various assumptions may be made during compilation that allow optimisation of the compiled code. Thirdly, time savings can be made by using the host operating system's stack, and by using native call instructions (rather than emulated call instructions) to call subroutines.
- non-native main routine 5008 and non-native subroutine 5010 are compiled into native main routine 5012 and native subroutine 5014 .
- Call instruction 5016 at address xxx is a native call instruction.
- the address xxx (the return address) is put onto the host stack 5015 , together with temporary register values, and the instructions in the subroutine at address yyy are picked up.
- the return instruction at the end of the subroutine is encountered, the return address and register values are pulled from the host stack, and execution of the main routine resumes.
- the stack is examined frame by frame to identify any return addresses that point to the section of code to be deleted. If such a return address is identified, the address is changed to the address of a piece of continuation code referred to herein as ‘glue code’.
- the glue code enables execution to continue without the piece of code to be deleted. This is done either by interpreting instructions in the original, non-native code until a section of code is encountered for which there is a compiled version, or by jumping to another compiled version of the code, if this exists.
- register information is also put onto the stack, in the same frame as the return address. Since various optimisations may have been made during the compilation of the code, this register information may only be valid if the rest of the compiled code is executed. For example, when a section of code is compiled, the compiler may have identified that not all parameters are needed in that section of code. In that case, some of the register information may have been left out, since it is not needed for executing the rest of the compiled code. However, if execution then returns to the original interpreted code, all of the parameters are needed (since the interpreter cannot look forward to see which parameters are or are not needed). Thus, it may be that missing register information needs to be added, before the interpreted version of the code can be executed.
- the preferred embodiment is designed to operate in a multi-threaded environment, that is, an environment in which there are two or more processors, or threads, running asynchronously but sharing the same work space. Each thread has its own stack. In the preferred embodiment, the stack of every thread to which the compiled code may have had access is examined, or simply the stack of every thread is examined.
- the thread to which that stack relates is stopped for a certain period of time.
- the thread is stopped while all of the frames in the stack are examined.
- the thread is paused for long enough to examine the most recent frame, or a predetermined number of most recent frames, on the stack.
- a ‘return barrier’ is inserted into the stack, in the way described in Agent's reference no. 5 of this specification. The thread can then be allowed to continue execution for as long as the stack stays above the return barrier.
- step 5020 it is decided that a certain code buffer is to be deleted.
- a code buffer is an area in memory that stores compiled code.
- a thread is selected whose stack is to be examined.
- step 5024 that thread is stopped.
- a return barrier is inserted into the stack, and operation of the thread allowed to continue for as long as the stack stays above the return barrier.
- step 5028 a frame on the stack is selected.
- the first frame to be examined will typically be the youngest frame on the stack.
- step 5030 the selected frame is examined to see whether it contains a return address in the buffer that is to be deleted.
- step 5032 If it is found that there is such a return address, then in step 5032 the fragment within the buffer that the return thread points to is identified. In step 5034 the other frame fields are adjusted to ‘clean up’ any optimisations of local variable values, or of variables specific to the virtual machine, that may have been made. In step 5036 the return address is changed to point to a piece of glue code.
- step 5038 it is determined whether all frames in the stack have been examined. If not, then in step 5040 the next youngest frame in the stack is selected, and that frame is examined. Once all of the frames in the stack have been examined, then in step 5042 the thread is restarted, or the return barrier is removed. In step 5044 it is determined whether the stacks of all threads have been examined. If not, then another thread whose stack has not been examined is selected and the process is repeated.
- step 5046 the code buffer is deleted.
- FIG. 6E shows a computer system including a virtual machine 5050 which allows non-native code 5052 to run on host computer 5054 .
- the virtual machine includes control means 5056 , interpreter 5058 which interprets non-native application code, compiler 5060 which compiles sections of non-native application code, and ‘stack walker’ 5062 .
- the host computer includes a processor 5064 and memory 5068 .
- a single processor is shown which executes several threads simultaneously by appropriate division of its time between the various threads, but two or more processors could be provided, each executing one or more threads.
- Compiled code 5070 which has been compiled by compiler 5060 is stored in memory 5068 . Also located in memory 5068 are a number of stacks 5072 , 5073 , 5074 corresponding to the number of threads that are being executed by the processor 5064 .
- control means 5056 may decide at a certain time that a section of compiled code 5070 should be deleted, for example to allow this area of memory to be used for other purposes.
- the control means indicates to stack walker 5062 that this section of code is to be deleted.
- the stack walker pauses operation of each thread in turn, and examines the frames in the stacks of the threads to identify any frames which contain return addresses which are in the area of memory containing the section of code to be deleted. Any such addresses are changed to the address of a piece of glue code 5076 , and other fields in the frame are adjusted to ‘clean up’ any optimisations of local variable values, or of variables specific to the virtual machine, that may have been made.
- the glue code operates in the way described above with reference to FIG.
- the stack walker 5062 indicates to the control means 5056 that the section of code may be deleted.
- the control means 5056 controls deletion means 5078 to delete the section of compiled code 5070 .
- each thread in the virtual machine is paused in turn, and the stacks of these threads are scanned, looking for return address values which point at code which is to be deleted. Once one of these cases is found, the state of the stack around the return address value is adjusted to “clean up” the virtual machine state for that thread at the point where the return is encountered (i.e., some time in the future for that thread), and the return address value itself is adjusted to cause the flow of execution to transition to one of a small number of central pieces of code.
- glue code centralised pieces of code
- centralised pieces of code perform some generalised checks and cause the continuation of the flow of execution for that thread in the appropriate manner; usually this will involve interpretation of subsequent emulated instructions until a section of emulated instructions is encountered for which there is a compiled version.
- the invention may be embodied in any, some, or all of the following forms: it may be embodied in a method of operating a computer system; it may be embodied in the computer system itself; it may be embodied in a computer system when programmed with or adapted or arranged to execute the method of operating that system; and/or it may be embodied in a computer-readable storage medium having a program recorded thereon which is adapted to operate according to the method of operating the system.
- computer system may be interchanged for ‘computer,’ ‘system,’ ‘equipment,’ ‘apparatus,’ ‘machine,’ and like terms.
- the computer system may be or may include a virtual machine.
- Agent's Reference No. 7 Computer System, Computer-readable Storage Medium and Method of Operating Same, and Method of Operating that System
- the present invention relates to a method of operating a garbage collector (especially a concurrent garbage collector) in a computer system, to a computer and computer system for garbage collection, to a computer-readable storage medium and to a Virtual Machine.
- the present invention relates to grey packets: low-contention grey object sets for concurrent marking garbage collection in a highly multi-threaded environment.
- the invention is applicable to run-time environments; at a more specific level it is applicable to automatic dynamic memory management.
- Such ‘memory management’ may typically be ‘manual,’ where the program itself contains code indicating that it requires memory to perform a function and code indicating when it has finished using that memory, or ‘automatic’ where the program does not inform the computer system when it has finished with memory and instead the system itself has to implement some way of identifying and recovering expended memory.
- the latter is conveniently referred to as ‘garbage collection’ and relies on the computer system initiating a process in which it searches through the memory objects currently being utilised by a program. Any such objects which are encountered during the search are regarded as currently in use whilst others not encountered cannot be currently in use and may be regarded as dead and therefore available for reallocation.
- the third technique involves all memory being located in one logical unit containing objects.
- GC is invoked when there is no region of memory in the heap large enough to satisfy an allocation request, at which point it will colour all objects “white” and trace all possible paths through references to live objects. Any objects reached by the GC are coloured “black” and regarded as live, while areas not reached remain “white” and can be regarded as dead and available for reallocation.
- the final stage of the technique involves a ‘sweep’ operation in which all areas marked white are released and work is allowed to continue.
- FIG. 7B shows at 12204 a memory heap, which is the storage area for memory objects, including their coloration.
- references 12206 in the object to other objects which have not yet been encountered by the tracing process are pushed onto the grey stack, and those objects are recolored “grey.”
- Each object, shown enlarged at 12208 for convenience in FIG. 7B, includes an indication 12210 of the black/white status of the reference and pointers such as 12212 to other objects in a stack. The process is repeated until the grey stack is empty. Subsequent to the tracing process there is the sweep phase in which what is black is made white and what is white is made available for future use. At the end of the garbage collection, it will be understood that the grey stack ceases to exist.
- a reference field “b” ( 12306 ) in an object could be updated to refer to a different reference “d” ( 12308 ). If the object A being updated (designated 12302 ) is “black” (that is it has been fully traced by the GC) while the new object B (designated 12304 ) is “white”, then there is a risk that B could be misidentified as dead if A becomes the only route to B. This occurs because the GC has no reason to revisit A, so B will never be traced.
- the set of grey objects is a resource shared amongst several threads of control, all of which could alter it.
- any alteration must be policed by a locking mechanism of some kind.
- the grey set is used heavily during the tracing process, so there is a high probability that any attempt to gain access to the grey set will find it already in use.
- any overheads incurred by the locking mechanism will tend to be magnified.
- other parts of the system can be attempting to alter objects while the GC is still tracing through methods to locate the live and dead memory locations. Special measures may need to be taken in order to prevent a live object being identified incorrectly as dead and thereby being reallocated. Corruption and/or loss of data could thereby result.
- a typical solution to this problem has been to use a ‘write barrier’ on all operations which could alter the contents of objects.
- a further problem for GC is that space for the entire grey stack has to be allocated at the start of the GC cycle and usually has to be large enough to cope with the worst eventuality, even though it is highly unlikely that that will occur. Hence, most of the space set aside for the grey stack is wasted.
- the invention can be regarded as relating in one aspect to the management of the grey queue (or stack) in order to overcome the problem that there is a lot of contention for access to the grey stack.
- the present invention provides a method of operating a garbage collector in a computer system, the garbage collector having (typically at a given time) a set of partially traced memory objects (typically ‘grey’ objects), the method including handling the set of partially traced memory objects in a plurality of discrete packets (or dividing the set of partially traced memory objects into the plurality of discrete packets).
- the garbage collector may, for example, be an incremental or pausing garbage collector. However, preferably, for speed of operation, the garbage collector is a concurrent garbage collector. (Typically a concurrent garbage collector operates concurrently with the execution of at least one other thread of control; that is it does not prevent mutation occurring at the same time as the garbage collection. In a non-concurrent garbage collector the collector's thread is the only thread which is running, and so no locking is required). In this case, preferably each packet is accessible by at most one thread of control at any given time. This can limit the amount of locking required to the occasions when a thread finishes with one packet and needs another to work on. This, in turn, can improve the performance of a GC in a very heavily used system and/or reduce the memory requirement of the computer system, by releasing memory no longer in use.
- different packets can be accessed by different threads of control at the same time. This can enhance the degree of concurrency in the system.
- the packets are preferably treated separately so that they can be used by different threads.
- each packet that is currently in use by a particular thread of control is marked as ‘checked out’ and each packet that currently has no particular thread of control using it is marked as ‘checked in’, and only checked out packets can be operated on by the particular thread of control, whereas for each checked in (grey) packet preferably a mutual exclusion lock is imposed before its contents can be read by a thread. This can afford a convenient way of managing the packets.
- the minimum number of packets is two, as described later, one is for filling up with references to grey objects, the other is for emptying during “blackening.”
- the packets are preferably sufficiently long to afford the advantages of division into packets and avoid the disadvantage of using too much memory (especially when multiple threads are executing), but preferably not so long that they are unmanageable and give rise to an excessive number of locks.
- each packet contains a number of slots, one per reference to an object, the number being one of at least 2, 5, 10, 50 or 100.
- each packet contains a number of slots, one per reference to an object, the number being one of less than 5,000, 1,000, 500 or 100.
- a less important measure of the size of the packets is their length in terms of the number of bytes. Preferably, this is a power of two.
- each packet is one of at least 8, 16, 32, 64, 128 and 256 bytes long.
- each packet is less than one of less then 1024, 512, 256, 128 and 64 bytes long.
- each packet is of a fixed size.
- each packet contains a fixed number of slots and an indication (typically a header) of the number of slots currently in use within that packet.
- the packets are preferably created and destroyed in accordance with demand.
- the packets are dynamically managed in that they can be created or destroyed as required.
- the number of packets in existence is a function of the interval between the marking process and the blackening process.
- Destruction of the packets may be achieved at least in part by merging together the contents of partially full packets. This feature can save on memory requirement.
- the present invention provides a computer system including a garbage collector, the garbage collector having a set of partially traced memory objects, and means for handling the set in a plurality of discrete packets.
- the garbage collector is a concurrent garbage collector.
- each packet is accessible by at most one thread of control at any given time.
- the computer system further includes means for rendering (or is adapted to render) different packets accessible by different threads of control at the same time.
- the computer system further includes means for treating (or is adapted to treat) the packets separately so that they can be used by different threads.
- the computer system further includes means for marking (or is adapted to mark) each packet that is currently in use by a particular thread of control as ‘checked out’ and each packet that currently has no particular thread of control using it as ‘checked in,’ and means for permitting operation only on checked out packets by the particular thread of control.
- each packet contains a number of slots, one per reference to an object, the number being one of at least 2, 5, 10, 50 or 100.
- each packet contains a number of slots, one per reference to an object, the number being one of less than 5,000, 1,000, 500 or 100.
- Each packet may be of a fixed size.
- Each packet may contain a fixed number of slots and an indication of the number of slots currently in use within that packet.
- the computer system further includes means for creating and destroying (or is adapted to create or destroy) the packets in accordance with demand.
- the computer system further includes means for destroying (or is adapted to destroy) the packets at least in part by merging together the contents of partially full packets.
- the invention provides a method of operating a concurrent garbage collecting system in a computer system in a multi-threaded environment, so as to release memory no longer in use, including:
- the invention provides a computer system including:
- a concurrent garbage collector (preferably a run time engine);
- [0884] means for tracing the state of each object in a memory group
- [0885] means for allocating an identifier according to whether the object has not yet been encountered by the tracing means (white), the object and all objects to which it refers has been encountered by the tracing means (black), and the object itself has been encountered but some of the objects it refers to have not yet been visited (grey);
- the invention extends to a computer system including means for operating a concurrent garbage collection system and means for dividing the grey queue into packets such that each packet is accessible by at most one thread at any given time.
- the invention provides a method of operating a concurrent garbage collection system in a computer system environment, wherein the grey queue is divided into packets, each packet being accessible by at most one thread at any given time.
- the computer system is adapted to operate in a multi-threaded environment.
- the computer system further includes a manager for the packets.
- the invention extends to a computer when programmed according to the above method.
- the invention extends to a computer system including a garbage collector, the garbage collector having a set of partially traced memory objects, when programmed so as to handle the set of partially traced memory objects in a plurality of discrete packets.
- the invention also extends to a computer-readable storage medium having a program recorded thereon, the program providing the above method.
- the invention provides a computer-readable storage medium having a program recorded thereon, the program providing a method of operating a garbage collector in a computer system, the garbage collector having a set of partially traced memory objects, the method including handling the set of partially traced memory objects in a plurality of discrete packets.
- the invention extends to a Virtual Machine including the above computer or computer system.
- the invention provides a Virtual Machine when operated by the above method.
- the invention provides a Virtual Machine when operated by means of the above computer-readable storage medium.
- FIG. 7A shows the division of memory according to a prior art approach
- FIG. 7B illustrates another prior art approach
- FIG. 7C shows an arrangement of objects in a so-called “concurrent” environment
- FIG. 7D shows the tracing of garbage collection work
- FIG. 7E shows the structure of an object
- FIG. 7F shows an empty stack
- FIG. 7G shows the structure of an individual packet according to the present invention.
- FIG. 7H shows the overall operation of the present invention.
- Garbage Collection is a process whereby a run-time environment can identify memory which was in use at one time, but is now no longer in use, and make the identified memory available for re-use for other purposes.
- Concurrent GC is a way of implementing GC such that other activity in a program or system does not need to be impeded by ongoing GC activity.
- Tracing GCs work by following references, indicated as arrows 12400 in FIG. 7D, between memory objects generally indicated as 12402 , starting from some given root set 12404 , to establish the set of all objects which must be treated as “live.” Objects which are not in that set are deemed to be “dead” and their memory space can be recycled.
- the root set is some starting condition for the garbage collection, and is typically a set of public references including references on the stack of interest.
- Black The object and all the objects it refers to have been encountered by the tracing process.
- Grey The object itself has been encountered, but some of the objects it refers to may not have been visited (in other words, the grey coloration effectively denotes work in progress).
- Marking GCs tend to implement this abstraction fairly literally, while copying GCs do not, with an object's colour implicitly determined by its absolute location in memory.
- the present invention is concerned mainly with marking GC algorithms and techniques.
- the colour of objects is stored within the object itself, as part of the object's header ( 12502 in FIG. 7E).
- the colour is encoded as mark information M, 12504 , which is in one of four states, white, black, grey and free (that is, the object is available for allocation).
- M will typically be a pair of bits which together allow the four distinct states to be encoded. Recolouring an object is a matter of altering the M state information in the object's header in the appropriate way. In the preferred embodiment, object coloration is stored for the lifetime of the object. Outside the operation of the GC, all objects are coloured white.
- the present invention divides the set into discrete segments, or packets, (see for example 12406 in FIG. 7D), preferably such that each thread can be apportioned a segment it (and only it) can work on in isolation. This can minimise the amount of locking required to the occasions when a thread finishes with one packet and needs another to work on. Hence the packets replace the grey stack entirely (which is why the arrow in FIG. 7D from the stack to the heap is shown dotted).
- the present invention involves so-called “grey packets” and in particular the provision of low-contention grey object sets for concurrent marking garbage collection especially in a highly multi-threaded environment.
- Some GCs move objects in memory.
- the system used here preferably does not because of the difficulty of doing so in a concurrent GC. Instead, a ‘mark and sweep’ operation is performed.
- everything white is released at the end of the tracing or ‘mark’ process.
- the sweep phase In the sweep phase what is black is made white and what is white is made available for future use.
- a grey packet manager is provided by the technique described herein for managing the grey packets.
- the GPM comes into existence at the start of the program, but typically does not operate (except for housekeeping purposes) unless the garbage collector is also operating.
- Any thread could make something grey.
- a Virtual Machine the GPM is asked by the thread for its own memory for what is termed a grey packet in hand.
- VM Virtual Machine
- One of the reasons for dividing the set of grey objects into separate packets is so that the thread has its own grey packet in hand. If the thread wants to continue writing into a grey packet which is full or very nearly so, the GPM gives that thread a new packet, takes away the full one and stores it. The GPM can keep a queue of empty packets in readiness. Any number of threads can have their own separate packets in hand, so that the grey stack can be divided into a number of regions of exclusive access, and no global locks are required.
- Grey packets are like mini arrays, which are created and destroyed on demand. They are handled as complete packets. Grey packets typically are 256 bytes in size and can hold up to 60 references. It follows that only once in every 60 accesses does the grey packet need to communicate with the GPM. When there is no current GC there are no grey packets active.
- a set of grey packets 12406 exists as blocks within the program or system. Each block contains a fixed number of slots 12408 (each capable of describing a single object reference), and an indication of how many slots are currently in use within that block.
- checked-in packets are grouped in sets, preferably linked to form chains.
- the structure of an individual packet 12406 is shown in FIG. 7G.
- Each grey packet is either checked out, in which case it is currently being used by one (and only one) particular thread of control, or checked in, in which case no particular thread of control is using it.
- the grey packets are managed by a separate module within the program or system, the Grey Packet Manager, or GPM.
- the GPM maintains the following resources, internally:
- partial a list of partially full packets.
- Each of the above lists has a separate lock to control access to it. A packet is checked in if it is present in either of the above lists.
- the GPM offers the following fundamental services.
- C getEmptyPacketo obtain an empty packet (or partially filled packet, but not a full packet) from the set of checked in packets, alter its status to checked out, and return it to the calling thread.
- the GPM performs each of the above operations under lock.
- the GPM can handle the packets in any order it chooses; there is no system of “Last In, First Out”.
- partial list head pointer be p's successor.
- m be the minimum of the number of occupied slots in p and the number of unoccupied slots in partial list head pointer.
- partial list head pointer be p's successor packet.
- Each thread of control (including the GC) has a thread local packet-in-hand (or tl-pih) grey packet pointer.
- This pointer may be NULL (indicating that the thread has no packet in hand), but if non-NULL it must refer to a checked out packet.
Priority Applications (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US11/771,629 US8127280B2 (en) | 1998-11-16 | 2007-06-29 | Method and system for dynamic memory management |
US13/365,936 US8631219B2 (en) | 1998-11-16 | 2012-02-03 | Method and system for dynamic memory management |
Applications Claiming Priority (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
GBGB9825102.8A GB9825102D0 (en) | 1998-11-16 | 1998-11-16 | Computer system |
GBGB9825102.8 | 1998-11-16 | ||
PCT/GB1999/000788 WO2000029937A2 (en) | 1998-11-16 | 1999-03-16 | Computer system, computer-readable storage medium and method of operating same, and method of operating that system |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/GB1999/000788 Continuation WO2000029937A2 (en) | 1998-11-16 | 1999-03-16 | Computer system, computer-readable storage medium and method of operating same, and method of operating that system |
Related Child Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US11/771,629 Continuation US8127280B2 (en) | 1998-11-16 | 2007-06-29 | Method and system for dynamic memory management |
Publications (1)
Publication Number | Publication Date |
---|---|
US20020032719A1 true US20020032719A1 (en) | 2002-03-14 |
Family
ID=10842535
Family Applications (13)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/858,827 Expired - Lifetime US7080366B2 (en) | 1998-11-16 | 2001-05-16 | Dynamic compiler and method of compiling code to generate dominant path and to handle exceptions |
US09/859,133 Expired - Lifetime US6862728B2 (en) | 1998-11-16 | 2001-05-16 | Hash table dispatch mechanism for interface methods |
US09/858,578 Expired - Lifetime US7069549B2 (en) | 1998-11-16 | 2001-05-16 | Multi-threaded fragment patching |
US09/859,134 Expired - Lifetime US7039738B2 (en) | 1998-11-16 | 2001-05-16 | Method and system for handling device driver interrupts |
US09/859,072 Expired - Lifetime US6901587B2 (en) | 1998-11-16 | 2001-05-16 | Method and system of cache management using spatial separation of outliers |
US09/859,161 Expired - Lifetime US6766513B2 (en) | 1998-11-16 | 2001-05-16 | Method and system of memory management using stack walking |
US09/859,162 Expired - Lifetime US6691303B2 (en) | 1998-11-16 | 2001-05-16 | Method and system of testing and verifying computer code in a multi-threaded environment |
US09/858,426 Expired - Lifetime US7007005B2 (en) | 1998-11-16 | 2001-05-16 | Method and structure for reducing search times |
US09/859,135 Expired - Lifetime US7058929B2 (en) | 1998-11-16 | 2001-05-16 | Direct invocation of methods using class loader |
US09/858,826 Expired - Lifetime US6925637B2 (en) | 1998-11-16 | 2001-05-16 | Low-contention grey object sets for concurrent, marking garbage collection |
US09/859,163 Abandoned US20020032719A1 (en) | 1998-11-16 | 2001-05-16 | Method and system of dynamic memory management |
US11/771,629 Expired - Fee Related US8127280B2 (en) | 1998-11-16 | 2007-06-29 | Method and system for dynamic memory management |
US13/365,936 Expired - Fee Related US8631219B2 (en) | 1998-11-16 | 2012-02-03 | Method and system for dynamic memory management |
Family Applications Before (10)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/858,827 Expired - Lifetime US7080366B2 (en) | 1998-11-16 | 2001-05-16 | Dynamic compiler and method of compiling code to generate dominant path and to handle exceptions |
US09/859,133 Expired - Lifetime US6862728B2 (en) | 1998-11-16 | 2001-05-16 | Hash table dispatch mechanism for interface methods |
US09/858,578 Expired - Lifetime US7069549B2 (en) | 1998-11-16 | 2001-05-16 | Multi-threaded fragment patching |
US09/859,134 Expired - Lifetime US7039738B2 (en) | 1998-11-16 | 2001-05-16 | Method and system for handling device driver interrupts |
US09/859,072 Expired - Lifetime US6901587B2 (en) | 1998-11-16 | 2001-05-16 | Method and system of cache management using spatial separation of outliers |
US09/859,161 Expired - Lifetime US6766513B2 (en) | 1998-11-16 | 2001-05-16 | Method and system of memory management using stack walking |
US09/859,162 Expired - Lifetime US6691303B2 (en) | 1998-11-16 | 2001-05-16 | Method and system of testing and verifying computer code in a multi-threaded environment |
US09/858,426 Expired - Lifetime US7007005B2 (en) | 1998-11-16 | 2001-05-16 | Method and structure for reducing search times |
US09/859,135 Expired - Lifetime US7058929B2 (en) | 1998-11-16 | 2001-05-16 | Direct invocation of methods using class loader |
US09/858,826 Expired - Lifetime US6925637B2 (en) | 1998-11-16 | 2001-05-16 | Low-contention grey object sets for concurrent, marking garbage collection |
Family Applications After (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US11/771,629 Expired - Fee Related US8127280B2 (en) | 1998-11-16 | 2007-06-29 | Method and system for dynamic memory management |
US13/365,936 Expired - Fee Related US8631219B2 (en) | 1998-11-16 | 2012-02-03 | Method and system for dynamic memory management |
Country Status (7)
Country | Link |
---|---|
US (13) | US7080366B2 (de) |
EP (1) | EP1208425B1 (de) |
JP (2) | JP2003526135A (de) |
AU (1) | AU2846999A (de) |
DE (1) | DE69939495D1 (de) |
GB (1) | GB9825102D0 (de) |
WO (1) | WO2000029937A2 (de) |
Cited By (40)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20040039759A1 (en) * | 2002-08-23 | 2004-02-26 | Detlefs David L. | Eliminating write barriers for young objects |
US20040088277A1 (en) * | 2002-11-05 | 2004-05-06 | Garthwaite Alexander T. | Placement of allocation trains in the train algorithm |
US20040088339A1 (en) * | 2002-11-05 | 2004-05-06 | Garthwaite Alexander T. | Efficient encoding of references into a collection set |
US20040103126A1 (en) * | 2002-11-27 | 2004-05-27 | Garthwaite Alexander T. | Avoiding remembered-set maintenance overhead for memory segments known to be in a collection set |
US20040111444A1 (en) * | 2002-12-06 | 2004-06-10 | Garthwaite Alexander T. | Advancing cars in trains managed by a collector based on the train algorithm |
US20040111450A1 (en) * | 2002-12-06 | 2004-06-10 | Garthwaite Alexander T. | Better placement of objects reachable from special objects during collection based on the train algorithm |
US20040172507A1 (en) * | 2003-02-27 | 2004-09-02 | Garthwaite Alexander T. | Better placement of objects promoted into a generation managed by the train algorithm |
US20040186863A1 (en) * | 2003-03-21 | 2004-09-23 | Garthwaite Alexander T. | Elision of write barriers for stores whose values are in close proximity |
US20040199556A1 (en) * | 2003-02-27 | 2004-10-07 | Garthwaite Alexander T. | Incremental scanning of enormous objects to improve scheduling and pause-time behavior of garbage collection |
US20050050135A1 (en) * | 2003-08-25 | 2005-03-03 | Josef Hallermeier | Handheld digital multimedia workstation and method |
US20050149585A1 (en) * | 2004-01-05 | 2005-07-07 | International Business Machines Corporation | Method and apparatus for scheduling and performing garbage collection in a real-time system with guaranteed space bounds |
US20060026565A1 (en) * | 2004-07-27 | 2006-02-02 | Texas Instruments Incorporated | Method and system for implementing an interrupt handler |
US7031990B2 (en) | 2002-12-06 | 2006-04-18 | Sun Microsystems, Inc. | Combining external and intragenerational reference-processing in a garbage collector based on the train algorithm |
US20060090063A1 (en) * | 2002-06-24 | 2006-04-27 | Jean-Paul Theis | Method for executing structured symbolic machine code on a microprocessor |
US7069280B2 (en) | 2002-12-06 | 2006-06-27 | Sun Microsystems, Inc. | Collection-tick mechanism for a collector based on the train algorithm |
US7069281B2 (en) | 2003-02-24 | 2006-06-27 | Sun Microsystems, Inc. | Efficient collocation of evacuated objects in a copying garbage collector using variably filled local allocation buffers |
US7080172B1 (en) | 2003-05-27 | 2006-07-18 | Marvell Luternational Ltd. | Management of memory, hardware and associated device drivers using stacks |
US7089272B1 (en) | 2003-06-18 | 2006-08-08 | Sun Microsystems, Inc. | Specializing write-barriers for objects in a garbage collected heap |
US7096238B2 (en) | 1999-08-19 | 2006-08-22 | Sun Microsystems, Inc. | Dynamic feedback for determining collection-set size |
US20060206901A1 (en) * | 2005-03-08 | 2006-09-14 | Oracle International Corporation | Method and system for deadlock detection in a distributed environment |
US7143124B2 (en) | 2002-12-06 | 2006-11-28 | Sun Microsystems, Inc. | Detection of dead regions during incremental collection |
US7146390B2 (en) | 2003-02-24 | 2006-12-05 | Sun Microsystems, Inc. | Staging the processing of remembered-set entries as part of collection based on the train algorithm |
US7149762B1 (en) | 2003-08-20 | 2006-12-12 | Sun Microsystems, Inc. | Handling futile collections in the train algorithm through selective extension of the collection set |
US7188129B2 (en) | 2002-11-15 | 2007-03-06 | Sun Microsystems, Inc. | Merging trains in a collector based on the train algorithm |
US20070067774A1 (en) * | 2005-08-30 | 2007-03-22 | Alexey Kukanov | Fair scalable reader-writer mutual exclusion |
US7321909B1 (en) | 2004-12-23 | 2008-01-22 | Sun Microsystems, Inc. | Method and apparatus for forwarding references to objects concurrently with space-incremental garbage collection |
US7404182B1 (en) | 2003-10-03 | 2008-07-22 | Sun Microsystems, Inc. | Deferring and combining write barriers for a garbage-collected heap |
US20090063595A1 (en) * | 2007-09-05 | 2009-03-05 | Mark Graham Stoodley | Method and apparatus for updating references to objects in a garbage collection operation |
US7533237B1 (en) * | 2006-05-11 | 2009-05-12 | Nvidia Corporation | Off-chip memory allocation for a unified shader |
US7533236B1 (en) * | 2006-05-11 | 2009-05-12 | Nvidia Corporation | Off-chip out of order memory allocation for a unified shader |
US7539713B2 (en) | 2002-11-05 | 2009-05-26 | Sun Microsystems, Inc. | Allocation of likely popular objects in the train algorithm |
US20090210379A1 (en) * | 2008-02-14 | 2009-08-20 | Sun Microsystems, Inc. | Dynamic multiple inheritance method dispatch and type extension testing by frugal perfect hashing |
US7620943B1 (en) | 2004-06-30 | 2009-11-17 | Sun Microsystems, Inc. | Using class properties to segregate objects in a generation managed by the train algorithm |
US7676801B1 (en) | 2004-08-31 | 2010-03-09 | Sun Microsystems, Inc. | Scanning of evacuated objects in a generation managed by the train algorithm |
US20110225213A1 (en) * | 2010-03-10 | 2011-09-15 | Microsoft Corporation | Loop control flow diversion |
US8566812B1 (en) * | 2006-08-31 | 2013-10-22 | Oracle America, Inc. | Using observed object patterns to dynamically tune a virtual machine for responsiveness |
US8578347B1 (en) * | 2006-12-28 | 2013-11-05 | The Mathworks, Inc. | Determining stack usage of generated code from a model |
US8856761B2 (en) | 2011-03-18 | 2014-10-07 | Fujitsu Limited | Instruction processing method, instruction processing apparatus, and instruction processing program |
US20140330781A1 (en) * | 2005-06-29 | 2014-11-06 | Cisco Technology, Inc. | Parallel Filesystem Traversal For Transparent Mirroring of Directories and Files |
US11537429B2 (en) * | 2019-12-19 | 2022-12-27 | Red Hat, Inc. | Sub-idle thread priority class |
Families Citing this family (520)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP0825506B1 (de) | 1996-08-20 | 2013-03-06 | Invensys Systems, Inc. | Verfahren und Gerät zur Fernprozesssteuerung |
JPH11296381A (ja) * | 1998-04-08 | 1999-10-29 | Matsushita Electric Ind Co Ltd | 仮想マシン及びコンパイラ |
US7260817B2 (en) * | 1999-07-09 | 2007-08-21 | International Business Machines Corporation | Method using array range check information for generating versioning code before a loop for execution |
GB9825102D0 (en) * | 1998-11-16 | 1999-01-13 | Insignia Solutions Plc | Computer system |
US6842853B1 (en) * | 1999-01-13 | 2005-01-11 | Sun Microsystems, Inc. | Thread suspension system and method |
US7013454B2 (en) * | 1999-02-22 | 2006-03-14 | Sun Microsystems, Inc. | Thread suspension system and method using trapping instructions |
US6308319B1 (en) | 1999-02-22 | 2001-10-23 | Sun Microsystems, Inc. | Thread suspension system and method using trapping instructions in delay slots |
US7283991B1 (en) * | 1999-03-11 | 2007-10-16 | Microsoft Corporation | Caching system for path search optimization |
US7353163B2 (en) * | 1999-04-27 | 2008-04-01 | Transitive Limited | Exception handling method and apparatus for use in program code conversion |
AU5025600A (en) * | 1999-05-17 | 2000-12-05 | Foxboro Company, The | Process control configuration system with parameterized objects |
US7089530B1 (en) | 1999-05-17 | 2006-08-08 | Invensys Systems, Inc. | Process control configuration system with connection validation and configuration |
US6788980B1 (en) * | 1999-06-11 | 2004-09-07 | Invensys Systems, Inc. | Methods and apparatus for control using control devices that provide a virtual machine environment and that communicate via an IP network |
US7150005B2 (en) * | 1999-07-02 | 2006-12-12 | Beryl Technical Assays, Llc | Method and system for global constant management for memory |
US7882501B1 (en) * | 1999-08-13 | 2011-02-01 | Oracle America, Inc. | System and method for enabling dynamic modifed class reloading in an application server environment |
US6983350B1 (en) | 1999-08-31 | 2006-01-03 | Intel Corporation | SDRAM controller for parallel processor architecture |
GB9921720D0 (en) * | 1999-09-14 | 1999-11-17 | Tao Group Ltd | Loading object-oriented computer programs |
US6880152B1 (en) | 1999-10-13 | 2005-04-12 | Transmeta Corporation | Method of determining a mode of code generation |
US6532509B1 (en) | 1999-12-22 | 2003-03-11 | Intel Corporation | Arbitrating command requests in a parallel multi-threaded processing system |
US6694380B1 (en) | 1999-12-27 | 2004-02-17 | Intel Corporation | Mapping requests from a processing unit that uses memory-mapped input-output space |
US6661794B1 (en) | 1999-12-29 | 2003-12-09 | Intel Corporation | Method and apparatus for gigabit packet assignment for multithreaded packet processing |
US6952824B1 (en) * | 1999-12-30 | 2005-10-04 | Intel Corporation | Multi-threaded sequenced receive for fast network port stream of packets |
US7480706B1 (en) * | 1999-12-30 | 2009-01-20 | Intel Corporation | Multi-threaded round-robin receive for fast network port |
US7080359B2 (en) * | 2002-01-16 | 2006-07-18 | International Business Machines Corporation | Stack unique signatures for program procedures and methods |
US6904594B1 (en) * | 2000-07-06 | 2005-06-07 | International Business Machines Corporation | Method and system for apportioning changes in metric variables in an symmetric multiprocessor (SMP) environment |
ATE285594T1 (de) * | 2000-07-27 | 2005-01-15 | Abb Research Ltd | Verfahren und computerprogramm zum herstellen einer regelung oder steuerung |
US6658656B1 (en) * | 2000-10-31 | 2003-12-02 | Hewlett-Packard Development Company, L.P. | Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions |
US6813760B1 (en) * | 2000-11-30 | 2004-11-02 | Nortel Networks Limited | Method and a tool for estimating probability of data contention in a multi-processor shared-memory system |
US8458754B2 (en) | 2001-01-22 | 2013-06-04 | Sony Computer Entertainment Inc. | Method and system for providing instant start multimedia content |
US7461148B1 (en) * | 2001-02-16 | 2008-12-02 | Swsoft Holdings, Ltd. | Virtual private server with isolation of system components |
US8219620B2 (en) * | 2001-02-20 | 2012-07-10 | Mcafee, Inc. | Unwanted e-mail filtering system including voting feedback |
US6892212B2 (en) * | 2001-03-22 | 2005-05-10 | International Business Machines Corporation | Method for efficient garbage collection based on object type |
CA2346766A1 (en) * | 2001-05-07 | 2002-11-07 | Ibm Canada Limited-Ibm Canada Limitee | Efficient locking for thread-safe self-modifying code |
US6760726B1 (en) * | 2001-06-19 | 2004-07-06 | Ants Software | System and method of managing concurrent operations on linked lists |
US7082597B2 (en) * | 2001-06-20 | 2006-07-25 | Sun Microsystems, Inc. | Representation of objects in a Java programming environment |
US6980997B1 (en) * | 2001-06-28 | 2005-12-27 | Microsoft Corporation | System and method providing inlined stub |
US20030005408A1 (en) * | 2001-07-02 | 2003-01-02 | Pradeep Tumati | System and method for creating software modifiable without halting its execution |
JP3790683B2 (ja) * | 2001-07-05 | 2006-06-28 | インターナショナル・ビジネス・マシーンズ・コーポレーション | コンピュータ装置、その例外処理プログラム及びコンパイル方法 |
US6851006B2 (en) * | 2001-08-25 | 2005-02-01 | International Business Machines Corporation | Interruption handler-operating system dialog for operating system handling of hardware interruptions |
US7350194B1 (en) * | 2001-09-24 | 2008-03-25 | Oracle Corporation | Techniques for debugging computer programs involving multiple computing machines |
JP4272371B2 (ja) * | 2001-11-05 | 2009-06-03 | パナソニック株式会社 | デバッグ支援装置、コンパイラ装置、デバッグ支援プログラム、コンパイラプログラム、及びコンピュータ読取可能な記録媒体。 |
US6996814B2 (en) * | 2001-11-14 | 2006-02-07 | Sun Microsystems, Inc. | Method and apparatus for dynamically compiling byte codes into native code |
US7069546B2 (en) * | 2001-12-03 | 2006-06-27 | Corrigent Systems Ltd. | Generic framework for embedded software development |
JP2003196553A (ja) * | 2001-12-27 | 2003-07-11 | Seiko Epson Corp | 会員管理サーバシステム、そのプログラム及び会員管理方法 |
SE521753C2 (sv) * | 2002-02-08 | 2003-12-02 | Xelerated Ab | Förfarande och system för att uppfylla realtidskrav för en dataprocessor |
US6735756B1 (en) * | 2002-02-22 | 2004-05-11 | Xilinx, Inc. | Method and architecture for dynamic device drivers |
US7065760B2 (en) * | 2002-02-28 | 2006-06-20 | Sun Microsystems, Inc. | Reducing the memory footprint of applications executed in a virtual machine |
US7421478B1 (en) * | 2002-03-07 | 2008-09-02 | Cisco Technology, Inc. | Method and apparatus for exchanging heartbeat messages and configuration information between nodes operating in a master-slave configuration |
US20030182653A1 (en) * | 2002-03-22 | 2003-09-25 | Giuseppe Desoli | Systems and methods for verifying correct execution of emulated code via dynamic state verification |
AU2003213927A1 (en) * | 2002-03-29 | 2003-10-13 | Research In Motion Limited | System and method for object oriented interface checking and method dispatching |
US7379860B1 (en) | 2002-03-29 | 2008-05-27 | Cypress Semiconductor Corporation | Method for integrating event-related information and trace information |
US20030187911A1 (en) * | 2002-04-01 | 2003-10-02 | Michael Abd-El-Malek | Method and apparatus to facilitate recovering a thread from a checkpoint |
US7587465B1 (en) * | 2002-04-22 | 2009-09-08 | Cisco Technology, Inc. | Method and apparatus for configuring nodes as masters or slaves |
EP1502182B1 (de) * | 2002-04-25 | 2016-10-05 | Koninklijke Philips N.V. | Automatische aufgabenverteilung in skalierbaren prozessoren |
US7020870B2 (en) * | 2002-05-15 | 2006-03-28 | Sun Microsystems, Inc. | Dynamic size for language variables |
JP3956113B2 (ja) * | 2002-06-13 | 2007-08-08 | インターナショナル・ビジネス・マシーンズ・コーポレーション | データ処理装置及びプログラム |
EP1515232A4 (de) * | 2002-06-18 | 2007-09-05 | Matsushita Electric Ind Co Ltd | Programmausführungsendgeräteeinrichtung, programmausführungsverfahren und programm |
US20040003383A1 (en) * | 2002-06-28 | 2004-01-01 | Microsoft Corporation | Stripping of unnecessary information from source code |
US6970985B2 (en) * | 2002-07-09 | 2005-11-29 | Bluerisc Inc. | Statically speculative memory accessing |
US20040010779A1 (en) * | 2002-07-10 | 2004-01-15 | Di Loreto Michael A. | Multi-module interpreter |
US7036057B2 (en) * | 2002-07-11 | 2006-04-25 | Mediatek Inc. | Range splitting read/write methods for CD-MRW |
US7047488B2 (en) | 2002-07-19 | 2006-05-16 | Open Invention Network | Registry driven interoperability and exchange of documents |
US7346895B2 (en) * | 2002-07-31 | 2008-03-18 | International Business Machines Corporation | Method of tracing data collection |
US7296257B1 (en) * | 2002-08-01 | 2007-11-13 | Tymesys Corporation | Techniques for exception handling by rewriting dispatch table elements |
US20040040029A1 (en) * | 2002-08-22 | 2004-02-26 | Mourad Debbabi | Method call acceleration in virtual machines |
TWI324309B (en) * | 2002-08-26 | 2010-05-01 | Interdigital Tech Corp | Communication circuit |
US20040044988A1 (en) * | 2002-08-29 | 2004-03-04 | Schene Christopher Robin | Generation of compiled code for simulator speed up |
US7367022B2 (en) * | 2002-09-05 | 2008-04-29 | Intel Corporation | Methods and apparatus for optimizing the operating speed and size of a computer program |
US9043194B2 (en) * | 2002-09-17 | 2015-05-26 | International Business Machines Corporation | Method and system for efficient emulation of multiprocessor memory consistency |
US8108843B2 (en) * | 2002-09-17 | 2012-01-31 | International Business Machines Corporation | Hybrid mechanism for more efficient emulation and method therefor |
US7953588B2 (en) * | 2002-09-17 | 2011-05-31 | International Business Machines Corporation | Method and system for efficient emulation of multiprocessor address translation on a multiprocessor host |
US7765532B2 (en) * | 2002-10-22 | 2010-07-27 | Oracle America, Inc. | Inducing concurrency in software code |
US7346902B2 (en) * | 2002-10-22 | 2008-03-18 | Sun Microsystems, Inc. | System and method for block-based concurrentization of software code |
US7603664B2 (en) * | 2002-10-22 | 2009-10-13 | Sun Microsystems, Inc. | System and method for marking software code |
US7178132B2 (en) * | 2002-10-23 | 2007-02-13 | Microsoft Corporation | Forward walking through binary code to determine offsets for stack walking |
US7069279B1 (en) * | 2002-11-04 | 2006-06-27 | Savaje Technologies, Inc. | Timely finalization of system resources |
US7194744B2 (en) * | 2002-12-17 | 2007-03-20 | International Business Machines Corporation | System and method for dynamic exception handling using an external exception handler |
FR2849229B1 (fr) * | 2002-12-18 | 2005-02-25 | Trusted Logic | Procede de compactage de programme par suppression dynamique de code |
US7983239B1 (en) | 2003-01-07 | 2011-07-19 | Raytheon Bbn Technologies Corp. | Systems and methods for constructing a virtual model of a multi-hop, multi-access network |
JP3924787B2 (ja) * | 2003-02-27 | 2007-06-06 | ソニー株式会社 | 記録装置、ファイル管理方法、ファイル管理方法のプログラム、ファイル管理方法のプログラムを記録した記録媒体 |
US7225439B2 (en) * | 2003-03-21 | 2007-05-29 | Sun Microsystems, Inc. | Combining write-barriers within an inner loop with fixed step |
GB2399897B (en) | 2003-03-26 | 2006-02-01 | Advanced Risc Mach Ltd | Memory recycling in computer systems |
CN100342377C (zh) * | 2003-04-16 | 2007-10-10 | 华为技术有限公司 | 一种提高数据处理效率的方法 |
GB2411990B (en) * | 2003-05-02 | 2005-11-09 | Transitive Ltd | Improved architecture for generating intermediate representations for program code conversion |
US7284100B2 (en) | 2003-05-12 | 2007-10-16 | International Business Machines Corporation | Invalidating storage, clearing buffer entries, and an instruction therefor |
US9454490B2 (en) | 2003-05-12 | 2016-09-27 | International Business Machines Corporation | Invalidating a range of two or more translation table entries and instruction therefore |
US7293265B2 (en) * | 2003-05-15 | 2007-11-06 | Intel Corporation | Methods and apparatus to perform return-address prediction |
US7603663B2 (en) * | 2003-05-20 | 2009-10-13 | Intel Corporation | Apparatus and methods for restoring synchronization to object-oriented software applications in managed runtime environments |
CA2430763A1 (en) | 2003-05-30 | 2004-11-30 | Ibm Canada Limited - Ibm Canada Limitee | Efficiently releasing locks when an exception occurs |
US7219329B2 (en) * | 2003-06-13 | 2007-05-15 | Microsoft Corporation | Systems and methods providing lightweight runtime code generation |
US7322027B2 (en) * | 2003-06-27 | 2008-01-22 | Microsoft Corporation | Detecting termination and providing information related to termination of a computer system process |
JP4569926B2 (ja) * | 2003-06-30 | 2010-10-27 | パナソニック株式会社 | ガーベジコレクションシステム |
US7496896B2 (en) * | 2003-07-17 | 2009-02-24 | Computer Associates Think, Inc. | Accessing return values and exceptions |
US7881229B2 (en) * | 2003-08-08 | 2011-02-01 | Raytheon Bbn Technologies Corp. | Systems and methods for forming an adjacency graph for exchanging network routing data |
US20050039189A1 (en) * | 2003-08-14 | 2005-02-17 | Todd Anderson | Methods and apparatus to preemptively compile an application |
US7210135B2 (en) * | 2003-08-26 | 2007-04-24 | Microsoft Corporation | Data flow analysis of transactional processes |
US7606927B2 (en) | 2003-08-27 | 2009-10-20 | Bbn Technologies Corp | Systems and methods for forwarding data units in a communications network |
US8166204B2 (en) * | 2003-08-29 | 2012-04-24 | Raytheon Bbn Technologies Corp. | Systems and methods for automatically placing nodes in an ad hoc network |
US7552426B2 (en) * | 2003-10-14 | 2009-06-23 | Microsoft Corporation | Systems and methods for using synthetic instructions in a virtual machine |
US7447829B2 (en) | 2003-10-15 | 2008-11-04 | International Business Machines Corporation | Heap and stack layout for multithreaded processes in a processing system |
US7668083B1 (en) | 2003-10-28 | 2010-02-23 | Bbn Technologies Corp. | Systems and methods for forwarding data in a communications network |
US20050114850A1 (en) | 2003-10-29 | 2005-05-26 | Saurabh Chheda | Energy-focused re-compilation of executables and hardware mechanisms based on compiler-architecture interaction and compiler-inserted control |
US20050097533A1 (en) * | 2003-10-31 | 2005-05-05 | Chakrabarti Dhruva R. | Run-time performance with call site inline specialization |
US7487498B2 (en) * | 2003-11-12 | 2009-02-03 | Microsoft Corporation | Strategy for referencing code resources |
US7263690B1 (en) * | 2003-11-14 | 2007-08-28 | Sun Microsystems, Inc. | Mechanism for safe byte code in a tracing framework |
US7996671B2 (en) | 2003-11-17 | 2011-08-09 | Bluerisc Inc. | Security of program executables and microprocessors based on compiler-architecture interaction |
US8302111B2 (en) | 2003-11-24 | 2012-10-30 | Time Warner Cable Inc. | Methods and apparatus for hardware registration in a network device |
US7266726B1 (en) | 2003-11-24 | 2007-09-04 | Time Warner Cable Inc. | Methods and apparatus for event logging in an information network |
US7380086B2 (en) * | 2003-12-12 | 2008-05-27 | International Business Machines Corporation | Scalable runtime system for global address space languages on shared and distributed memory machines |
US7770034B2 (en) * | 2003-12-16 | 2010-08-03 | Intel Corporation | Performance monitoring based dynamic voltage and frequency scaling |
US7603668B2 (en) * | 2004-01-09 | 2009-10-13 | Hewlett-Packard Development Company, L.P. | Determining the applicability of patches for installation on a computer system |
US20050165837A1 (en) * | 2004-01-22 | 2005-07-28 | International Business Machines Corporation | System and method for embedded java memory footprint performance improvement |
JP4086791B2 (ja) * | 2004-01-28 | 2008-05-14 | インターナショナル・ビジネス・マシーンズ・コーポレーション | コンパイラプログラム、動的コンパイラプログラム、再現コンパイラプログラム、再現コンパイラ、コンパイル方法、及び記録媒体 |
US8607209B2 (en) | 2004-02-04 | 2013-12-10 | Bluerisc Inc. | Energy-focused compiler-assisted branch prediction |
US9213538B1 (en) | 2004-02-06 | 2015-12-15 | Time Warner Cable Enterprises Llc | Methods and apparatus for display element management in an information network |
US20050183077A1 (en) * | 2004-02-12 | 2005-08-18 | International Business Machines Corporation | System and method for JIT memory footprint improvement for embedded java devices |
US7475002B1 (en) * | 2004-02-18 | 2009-01-06 | Vmware, Inc. | Method and apparatus for emulating multiple virtual timers in a virtual computer system when the virtual timers fall behind the real time of a physical computer system |
US8078669B2 (en) | 2004-02-18 | 2011-12-13 | Time Warner Cable Inc. | Media extension apparatus and methods for use in an information network |
US7266804B2 (en) | 2004-02-20 | 2007-09-04 | Microsoft Corporation | Strategy for selectively making non-public resources of one assembly visible to another |
US7689543B2 (en) * | 2004-03-11 | 2010-03-30 | International Business Machines Corporation | Search engine providing match and alternative answers using cumulative probability values |
US7904893B2 (en) * | 2004-03-17 | 2011-03-08 | Marvell International Ltd. | Power and/or energy optimized compile/execution |
US7496897B1 (en) | 2004-03-17 | 2009-02-24 | Timesys Corporation | Multiple code sets for multiple execution contexts |
US7644402B1 (en) * | 2004-03-17 | 2010-01-05 | Sun Microsystems, Inc. | Method for sharing runtime representation of software components across component loaders |
US7406687B1 (en) * | 2004-03-17 | 2008-07-29 | Sun Microsystems, Inc. | Sharing runtime representation of software component methods across component loaders |
US20050228851A1 (en) * | 2004-03-29 | 2005-10-13 | Intel Corporation | Configuration of redirection tables |
US7836434B1 (en) * | 2004-05-04 | 2010-11-16 | Oracle America, Inc. | Method and system for analyzing array access to a pointer that is referenced as an array |
US7770169B2 (en) * | 2004-05-17 | 2010-08-03 | Oracle America, Inc. | Thread rendezvous for read-only code in an object-oriented computing environment |
US8869104B2 (en) * | 2004-06-30 | 2014-10-21 | Lsi Corporation | Object code configuration tool |
US20060005190A1 (en) * | 2004-06-30 | 2006-01-05 | Microsoft Corporation | Systems and methods for implementing an operating system in a virtual machine environment |
US7949666B2 (en) * | 2004-07-09 | 2011-05-24 | Ricoh, Ltd. | Synchronizing distributed work through document logs |
KR100678891B1 (ko) * | 2004-07-30 | 2007-02-05 | 삼성전자주식회사 | Av데이터 수신시 버퍼량을 컨텐츠 속성에 따라탄력적으로 조절하는 방법 및 장치 |
US7398523B2 (en) * | 2004-08-19 | 2008-07-08 | International Business Machines Corporation | Adaptive class loading |
US20060048122A1 (en) * | 2004-08-30 | 2006-03-02 | International Business Machines Corporation | Method, system and computer program product for hierarchical loop optimization of machine executable code |
US8819639B2 (en) * | 2004-09-15 | 2014-08-26 | Lakeside Software, Inc. | System for selectively blocking execution of applications on a computer system |
US7415021B1 (en) * | 2004-09-22 | 2008-08-19 | Sun Microsystems, Inc. | Method and apparatus for preserving null semantics during use of a forwarding method |
US7653793B1 (en) * | 2004-11-17 | 2010-01-26 | Sun Microsystems, Inc. | Use of memory protection to implement replicating collection in an incremental, copying garbage collector |
FI20041517A0 (fi) * | 2004-11-25 | 2004-11-25 | Nokia Corp | Menetelmä elektroniikkalaitteiden ohjelmien turvalliseen tulkintaan |
US20060123397A1 (en) * | 2004-12-08 | 2006-06-08 | Mcguire James B | Apparatus and method for optimization of virtual machine operation |
TWI257053B (en) * | 2005-01-20 | 2006-06-21 | Via Tech Inc | System and method used to automatically reload and manage hyperlinks |
US7379943B2 (en) * | 2005-01-28 | 2008-05-27 | Microsoft Corporation | Method and system for bidirectionally data binding a control of a template |
US7730016B2 (en) * | 2005-01-31 | 2010-06-01 | Oracle International Corporation | Identification of false ambiguous roots in a stack conservative garbage collector |
WO2006092079A1 (en) * | 2005-03-03 | 2006-09-08 | Intel Corporation | Mining for performance data for systems with dynamic compilers |
US7574702B2 (en) * | 2005-03-18 | 2009-08-11 | Microsoft Corporation | Method and apparatus for hybrid stack walking |
US7574700B2 (en) * | 2005-03-31 | 2009-08-11 | Sun Microsystems, Inc. | Supporting dynamically-typed languages in typed assembly languages |
US7661095B2 (en) * | 2005-04-14 | 2010-02-09 | Hewlett-Packard Development Company, L.P. | System and method to build a callgraph for functions with multiple entry points |
CA2604113C (en) * | 2005-04-18 | 2012-02-21 | Research In Motion Limited | System and method of waste management |
US20060271542A1 (en) * | 2005-05-25 | 2006-11-30 | Harris Steven T | Clustered object state using logical actions |
GB2426840A (en) * | 2005-06-04 | 2006-12-06 | Transitive Ltd | Method of executing program code where a portion of the target code calls a native code portion which then calls a second target code portion. |
US20060277541A1 (en) * | 2005-06-07 | 2006-12-07 | Sony Computer Entertainment America Inc. | Relocatable component file format |
US20060288341A1 (en) * | 2005-06-15 | 2006-12-21 | Microsoft Corporation | Patch-impact assessment through runtime insertion of code path instrumentation |
EP1752874A1 (de) * | 2005-07-19 | 2007-02-14 | Alcatel | Adaptives evolutionäres Computerprogramm |
US9230029B2 (en) * | 2005-07-26 | 2016-01-05 | Creative Technology Ltd | System and method for modifying media content playback based on an intelligent random selection |
JP4068106B2 (ja) * | 2005-08-05 | 2008-03-26 | 三菱電機株式会社 | リアルタイム組込み簡易モニタプログラム |
US20070083783A1 (en) * | 2005-08-05 | 2007-04-12 | Toru Ishihara | Reducing power consumption at a cache |
US8516300B2 (en) * | 2005-08-29 | 2013-08-20 | The Invention Science Fund I, Llc | Multi-votage synchronous systems |
US8209524B2 (en) * | 2005-08-29 | 2012-06-26 | The Invention Science Fund I, Llc | Cross-architecture optimization |
US8375247B2 (en) * | 2005-08-29 | 2013-02-12 | The Invention Science Fund I, Llc | Handling processor computational errors |
US7779213B2 (en) | 2005-08-29 | 2010-08-17 | The Invention Science Fund I, Inc | Optimization of instruction group execution through hardware resource management policies |
US7725693B2 (en) | 2005-08-29 | 2010-05-25 | Searete, Llc | Execution optimization using a processor resource management policy saved in an association with an instruction group |
US7647487B2 (en) * | 2005-08-29 | 2010-01-12 | Searete, Llc | Instruction-associated processor resource optimization |
US20070050606A1 (en) * | 2005-08-29 | 2007-03-01 | Searete Llc, A Limited Liability Corporation Of The State Of Delaware | Runtime-based optimization profile |
US7627739B2 (en) | 2005-08-29 | 2009-12-01 | Searete, Llc | Optimization of a hardware resource shared by a multiprocessor |
US20070050605A1 (en) * | 2005-08-29 | 2007-03-01 | Bran Ferren | Freeze-dried ghost pages |
US8423824B2 (en) | 2005-08-29 | 2013-04-16 | The Invention Science Fund I, Llc | Power sparing synchronous apparatus |
US7739524B2 (en) * | 2005-08-29 | 2010-06-15 | The Invention Science Fund I, Inc | Power consumption management |
US7512842B2 (en) * | 2005-08-29 | 2009-03-31 | Searete Llc | Multi-voltage synchronous systems |
US8181004B2 (en) | 2005-08-29 | 2012-05-15 | The Invention Science Fund I, Llc | Selecting a resource management policy for a resource available to a processor |
US8255745B2 (en) * | 2005-08-29 | 2012-08-28 | The Invention Science Fund I, Llc | Hardware-error tolerant computing |
US8214191B2 (en) * | 2005-08-29 | 2012-07-03 | The Invention Science Fund I, Llc | Cross-architecture execution optimization |
US7877584B2 (en) | 2005-08-29 | 2011-01-25 | The Invention Science Fund I, Llc | Predictive processor resource management |
US7539852B2 (en) | 2005-08-29 | 2009-05-26 | Searete, Llc | Processor resource management |
US7793299B2 (en) * | 2005-08-30 | 2010-09-07 | International Business Machines Corporation | System and method for scheduling tasks for execution |
US7565365B2 (en) * | 2005-08-31 | 2009-07-21 | Sap Ag | Object storage and synchronization hooks for occasionally-connected devices |
US20070083644A1 (en) * | 2005-10-12 | 2007-04-12 | Microsoft Corporation | Capturing, displaying, and re-creating network conversations and state information |
KR100778001B1 (ko) * | 2005-10-14 | 2007-11-21 | 엘지전자 주식회사 | 멀티미디어 파일을 재생하는 방법 및 그 장치 |
EP1783604A3 (de) * | 2005-11-07 | 2007-10-03 | Slawomir Adam Janczewski | Objektorientiertes, parallelsprachiges Verfahren zum Programmieren eines Multiprozessor-Computers |
US7774843B1 (en) | 2005-11-16 | 2010-08-10 | Mcafee, Inc. | System, method and computer program product for preventing the execution of unwanted code |
JP4732874B2 (ja) * | 2005-11-28 | 2011-07-27 | 株式会社エヌ・ティ・ティ・ドコモ | ソフトウェア動作モデル化装置、ソフトウェア動作監視装置、ソフトウェア動作モデル化方法及びソフトウェア動作監視方法 |
EP1963963A2 (de) * | 2005-12-06 | 2008-09-03 | Boston Circuits, Inc. | Verfahren und vorrichtung zur mehrkernverarbeitung mit eigenem thread-management |
US7739675B2 (en) * | 2005-12-16 | 2010-06-15 | International Business Machines Corporation | Dynamically computing a degradation analysis of waiting threads in a virtual machine |
FR2895103B1 (fr) * | 2005-12-19 | 2008-02-22 | Dxo Labs Sa | Procede et systeme de traitement de donnees numeriques |
US9830174B2 (en) * | 2005-12-22 | 2017-11-28 | Synopsys, Inc. | Dynamic host code generation from architecture description for fast simulation |
US9009688B2 (en) * | 2005-12-30 | 2015-04-14 | Intel Corporation | Type checking for object-oriented programming languages |
US20070201270A1 (en) * | 2005-12-30 | 2007-08-30 | Stmicroelectronics Pvt. Ltd. | Read only memory device with bitline leakage reduction |
US8601160B1 (en) | 2006-02-09 | 2013-12-03 | Mcafee, Inc. | System, method and computer program product for gathering information relating to electronic content utilizing a DNS server |
US8769511B2 (en) * | 2006-02-16 | 2014-07-01 | The Regents Of The University Of California | Dynamic incremental compiler and method |
KR100763199B1 (ko) * | 2006-02-20 | 2007-10-04 | 삼성전자주식회사 | 가상 머신 환경에서의 메소드 호출 방법 및 상기 방법을수행하는 가상 머신이 탑재된 시스템 |
US8266605B2 (en) * | 2006-02-22 | 2012-09-11 | Wind River Systems, Inc. | Method and system for optimizing performance based on cache analysis |
US8615743B2 (en) * | 2006-02-27 | 2013-12-24 | Microsoft Corporation | Adaptive compiled code |
US8099724B2 (en) * | 2006-02-28 | 2012-01-17 | Oracle America, Inc. | Fast patch-based method calls |
US7840950B2 (en) * | 2006-03-09 | 2010-11-23 | International Business Machines Corporation | Programmatic compiler optimization of glacial constants |
US8291395B2 (en) * | 2006-03-31 | 2012-10-16 | Apple Inc. | Fast function call dispatching |
CN103646009B (zh) | 2006-04-12 | 2016-08-17 | 索夫特机械公司 | 对载明并行和依赖运算的指令矩阵进行处理的装置和方法 |
US7581089B1 (en) | 2006-04-20 | 2009-08-25 | The United States Of America As Represented By The Director Of The National Security Agency | Method of protecting a computer stack |
GB0609843D0 (en) * | 2006-05-18 | 2006-06-28 | Ibm | Launcher for software applications |
US7756911B2 (en) * | 2006-06-09 | 2010-07-13 | International Business Machines Corporation | Method and system for executing a task and medium storing a program therefor |
US7480782B2 (en) | 2006-06-14 | 2009-01-20 | Sun Microsystems, Inc. | Reference-updating using per-chunk referenced-address ranges in a compacting garbage collector |
US20080052691A1 (en) * | 2006-06-29 | 2008-02-28 | Naveen Neelakantam | Communicating with and recovering state information from a dynamic translator |
GB0613275D0 (en) * | 2006-07-04 | 2006-08-16 | Codeplay Software Ltd | Distributed computer system |
US8405662B2 (en) * | 2006-07-04 | 2013-03-26 | Iti Scotland Limited | Generation of video |
US20090150872A1 (en) * | 2006-07-04 | 2009-06-11 | George Russell | Dynamic code update |
US20090144713A1 (en) * | 2006-07-04 | 2009-06-04 | George Russell | Techniques for program performance analysis |
US20080126625A1 (en) * | 2006-07-17 | 2008-05-29 | International Business Machines Corporation | Just-in-time buffer allocation for use in event completion style input/output models |
EP1881404A1 (de) * | 2006-07-20 | 2008-01-23 | Gemplus | Verfahren zum dynamischen Schutz der Daten während der Ausführung eines Programmcodes in einer Zwischensprache in einem Rechner |
CN101110020B (zh) | 2006-07-21 | 2011-01-26 | 国际商业机器公司 | 维护关于可编辑对象中的元素的与原创性有关的信息的方法和系统 |
US8020149B2 (en) * | 2006-08-04 | 2011-09-13 | Apple Inc. | System and method for mitigating repeated crashes of an application resulting from supplemental code |
US7506218B2 (en) * | 2006-08-18 | 2009-03-17 | International Business Machines Corporation | Timeout request scheduling using grouping and nonsynchronized processing to enhance performance |
CA2557343C (en) * | 2006-08-28 | 2015-09-22 | Ibm Canada Limited-Ibm Canada Limitee | Runtime code modification in a multi-threaded environment |
US8479004B2 (en) | 2006-08-31 | 2013-07-02 | Ricoh Co., Ltd | Paper-based document logging |
US9665970B2 (en) * | 2006-09-19 | 2017-05-30 | Imagination Technologies Limited | Variable-sized concurrent grouping for multiprocessing |
US8799876B2 (en) * | 2006-09-29 | 2014-08-05 | Intel Corporation | Method and apparatus for assigning subroutines |
US7913236B2 (en) * | 2006-09-29 | 2011-03-22 | Intel Corporation | Method and apparatus for performing dynamic optimization for software transactional memory |
US8065670B2 (en) * | 2006-10-03 | 2011-11-22 | Oracle America, Inc. | Method and apparatus for enabling optimistic program execution |
US8082542B2 (en) * | 2006-10-04 | 2011-12-20 | International Business Machines Corporation | Load time in-lining of subroutines |
US7934208B2 (en) * | 2006-10-13 | 2011-04-26 | International Business Machines Corporation | Method for transparent on-line dynamic binary optimization |
CN101165684A (zh) * | 2006-10-18 | 2008-04-23 | 国际商业机器公司 | 指示内容查找结果的方法和装置 |
US20080126766A1 (en) | 2006-11-03 | 2008-05-29 | Saurabh Chheda | Securing microprocessors against information leakage and physical tampering |
CN101627365B (zh) | 2006-11-14 | 2017-03-29 | 索夫特机械公司 | 多线程架构 |
US8683453B2 (en) * | 2006-11-30 | 2014-03-25 | Motorola Mobility Llc | System for overriding interpreted byte-code with native code |
US8370818B2 (en) * | 2006-12-02 | 2013-02-05 | Time Warner Cable Inc. | Methods and apparatus for analyzing software interface usage |
US7783681B1 (en) * | 2006-12-15 | 2010-08-24 | Oracle America, Inc. | Method and system for pre-marking objects for concurrent garbage collection |
US9645915B2 (en) * | 2006-12-27 | 2017-05-09 | The Mathworks, Inc. | Continuous evaluation of program code and saving state information associated with program code |
FR2911971B1 (fr) * | 2007-01-26 | 2009-04-24 | Commissariat Energie Atomique | Procede et systeme de verification de proprietes d'un programme informatique. |
US8413125B2 (en) * | 2007-01-26 | 2013-04-02 | Oracle International Corporation | Asynchronous dynamic compilation based on multi-session profiling to produce shared native code |
US8006094B2 (en) | 2007-02-21 | 2011-08-23 | Ricoh Co., Ltd. | Trustworthy timestamps and certifiable clocks using logs linked by cryptographic hashes |
EP2118823B1 (de) * | 2007-03-01 | 2020-04-15 | Zipcar, Inc. | Mehrstufiger flottenverwaltungs-cache |
US8495708B2 (en) * | 2007-03-22 | 2013-07-23 | The Invention Science Fund I, Llc | Resource authorizations dependent on emulation environment isolation policies |
JP4339371B2 (ja) * | 2007-03-22 | 2009-10-07 | 株式会社ソニー・コンピュータエンタテインメント | 情報処理装置および情報処理方法 |
US8874425B2 (en) * | 2007-03-22 | 2014-10-28 | The Invention Science Fund I, Llc | Implementing performance-dependent transfer or execution decisions from service emulation indications |
US20080235000A1 (en) * | 2007-03-22 | 2008-09-25 | Searete Llc, A Limited Liability Corporation Of The State Of Delaware | Implementing security control practice omission decisions from service emulation indications |
US8438609B2 (en) * | 2007-03-22 | 2013-05-07 | The Invention Science Fund I, Llc | Resource authorizations dependent on emulation environment isolation policies |
US9378108B2 (en) * | 2007-03-22 | 2016-06-28 | Invention Science Fund I, Llc | Implementing performance-dependent transfer or execution decisions from service emulation indications |
US9558019B2 (en) * | 2007-03-22 | 2017-01-31 | Invention Science Fund I, Llc | Coordinating instances of a thread or other service in emulation |
US8996483B2 (en) * | 2007-03-28 | 2015-03-31 | Ricoh Co., Ltd. | Method and apparatus for recording associations with logs |
US20080243688A1 (en) * | 2007-03-28 | 2008-10-02 | Hart Peter E | Method and Apparatus for Recording Transactions with a Portable Logging Device |
US7937695B2 (en) * | 2007-04-27 | 2011-05-03 | International Business Machines Corporation | Reducing number of exception checks |
US8332819B2 (en) * | 2007-05-03 | 2012-12-11 | Siemens Industry, Inc. | Diagnostic and trouble-shooting methods in a wireless control and sensor network |
US7937620B2 (en) * | 2007-05-07 | 2011-05-03 | Intel Corporation | Transient fault detection by integrating an SRMT code and a non SRMT code in a single application |
US7937621B2 (en) * | 2007-05-07 | 2011-05-03 | Intel Corporation | Transient fault detection by integrating an SRMT code and a non SRMT code in a single application |
US7685182B2 (en) * | 2007-05-08 | 2010-03-23 | Microsoft Corporation | Interleaved garbage collections |
TW200912753A (en) * | 2007-05-22 | 2009-03-16 | Koninkl Philips Electronics Nv | Compiler and compiling method for a networked control system comprising a plurality of devices |
US8819673B1 (en) * | 2007-05-24 | 2014-08-26 | United Services Automobile Association (Usaa) | Systems and methods for java virtual machine management |
US8533686B2 (en) * | 2007-06-14 | 2013-09-10 | Red Hat, Inc. | Methods and systems for porting Sysprof |
US7949637B1 (en) * | 2007-06-27 | 2011-05-24 | Emc Corporation | Storage management for fine grained tiered storage with thin provisioning |
EP2176755A4 (de) | 2007-07-20 | 2013-01-23 | Qualcomm Atheros Inc | Diagnosevorrichtung mit fernzugriff und verfahren dafür |
US8024315B2 (en) * | 2007-07-20 | 2011-09-20 | International Business Machines Corporation | Method of dynamically providing a compound object's source information during its development |
US8291393B2 (en) * | 2007-08-20 | 2012-10-16 | International Business Machines Corporation | Just-in-time compiler support for interruptible code |
US8266607B2 (en) * | 2007-08-27 | 2012-09-11 | International Business Machines Corporation | Lock reservation using cooperative multithreading and lightweight single reader reserved locks |
US9483405B2 (en) * | 2007-09-20 | 2016-11-01 | Sony Interactive Entertainment Inc. | Simplified run-time program translation for emulating complex processor pipelines |
US20090089772A1 (en) * | 2007-09-28 | 2009-04-02 | International Business Machines Corporation | Arrangement for scheduling jobs with rules and events |
GB2454885B (en) * | 2007-11-21 | 2012-06-06 | Advanced Risc Mach Ltd | Interrupt jitter suppression |
US8196110B2 (en) * | 2007-11-30 | 2012-06-05 | International Business Machines Corporation | Method and apparatus for verifying a suspect return pointer in a stack |
WO2009073949A1 (en) * | 2007-12-13 | 2009-06-18 | Redknee Inc. | Method and system for storage |
US8321840B2 (en) * | 2007-12-27 | 2012-11-27 | Intel Corporation | Software flow tracking using multiple threads |
US20090182689A1 (en) * | 2008-01-15 | 2009-07-16 | Microsoft Corporation | Rule-based dynamic operation evaluation |
US8839225B2 (en) | 2008-01-23 | 2014-09-16 | International Business Machines Corporation | Generating and applying patches to a computer program code concurrently with its execution |
US9298568B2 (en) * | 2008-02-07 | 2016-03-29 | International Business Machines Corporation | Method and apparatus for device driver state storage during diagnostic phase |
US8539468B2 (en) * | 2008-02-18 | 2013-09-17 | International Business Machines Corporation | System and methods for replacing software application classes using transparent object adapters |
US20090217246A1 (en) * | 2008-02-27 | 2009-08-27 | Nce Technologies, Inc. | Evaluating Software Programming Skills |
US8566797B2 (en) * | 2008-02-27 | 2013-10-22 | Red Hat, Inc. | Heuristic backtracer |
US20090228875A1 (en) * | 2008-03-04 | 2009-09-10 | Devries Alex | Method and System for Reducing Disk Allocation by Profiling Symbol Usage |
US8239836B1 (en) * | 2008-03-07 | 2012-08-07 | The Regents Of The University Of California | Multi-variant parallel program execution to detect malicious code injection |
US8869109B2 (en) * | 2008-03-17 | 2014-10-21 | Microsoft Corporation | Disassembling an executable binary |
US8434064B2 (en) * | 2008-03-28 | 2013-04-30 | Microsoft Corporation | Detecting memory errors using write integrity testing |
US8473935B2 (en) * | 2008-04-21 | 2013-06-25 | Microsoft Corporation | Just-ahead-of-time compilation |
US7987215B2 (en) * | 2008-04-22 | 2011-07-26 | Microsoft Corporation | Efficiently marking objects with large reference sets |
US8453129B2 (en) * | 2008-04-24 | 2013-05-28 | International Business Machines Corporation | Using hardware interrupts to drive dynamic binary code recompilation |
US8386664B2 (en) * | 2008-05-22 | 2013-02-26 | International Business Machines Corporation | Reducing runtime coherency checking with global data flow analysis |
US8281295B2 (en) * | 2008-05-23 | 2012-10-02 | International Business Machines Corporation | Computer analysis and runtime coherency checking |
US8166041B2 (en) | 2008-06-13 | 2012-04-24 | Microsoft Corporation | Search index format optimizations |
US8099721B2 (en) * | 2008-06-17 | 2012-01-17 | Microsoft Corporation | Parsing of declarations in all branches of preprocessor conditionals |
CN104407518B (zh) | 2008-06-20 | 2017-05-31 | 因文西斯系统公司 | 对用于过程控制的实际和仿真设施进行交互的系统和方法 |
US7921280B2 (en) * | 2008-06-27 | 2011-04-05 | Intel Corporation | Selectively powered retirement unit using a partitioned allocation array and a partitioned writeback array |
US8793671B2 (en) * | 2008-06-28 | 2014-07-29 | Microsoft Corporation | Interface optimization in a closed system |
US8065349B2 (en) * | 2008-06-30 | 2011-11-22 | Oracle America, Inc. | Method and apparatus for performing concurrent garbage collection |
US20100017246A1 (en) * | 2008-07-20 | 2010-01-21 | Farrell Glenn H | Software user interface for specification of project task dependencies and deadlines |
US8285670B2 (en) | 2008-07-22 | 2012-10-09 | International Business Machines Corporation | Dynamically maintaining coherency within live ranges of direct buffers |
WO2010018613A1 (ja) * | 2008-08-11 | 2010-02-18 | 富士通株式会社 | ガーベジコレクションプログラム、及びガーベジコレクション方法、ならびにガーベジコレクションシステム |
US8307353B2 (en) * | 2008-08-12 | 2012-11-06 | Oracle America, Inc. | Cross-domain inlining in a system virtual machine |
US20100064061A1 (en) * | 2008-09-05 | 2010-03-11 | Apple Inc. | Providing substantially immediate action in response to input event |
US8301672B2 (en) * | 2008-09-22 | 2012-10-30 | Advanced Micro Devices, Inc. | GPU assisted garbage collection |
US8185733B2 (en) * | 2008-10-02 | 2012-05-22 | Ricoh Co., Ltd. | Method and apparatus for automatically publishing content based identifiers |
US8914781B2 (en) * | 2008-10-24 | 2014-12-16 | Microsoft Corporation | Scalability analysis for server systems |
US8417903B2 (en) | 2008-12-19 | 2013-04-09 | International Business Machines Corporation | Preselect list using hidden pages |
US8307350B2 (en) * | 2009-01-14 | 2012-11-06 | Microsoft Corporation | Multi level virtual function tables |
US8776032B2 (en) * | 2009-01-29 | 2014-07-08 | Microsoft Corporation | Automatic region-based verification of garbage collectors |
US8341602B2 (en) * | 2009-01-29 | 2012-12-25 | Microsoft Corporation | Automated verification of a type-safe operating system |
US8782607B2 (en) * | 2009-02-20 | 2014-07-15 | Microsoft Corporation | Contract failure behavior with escalation policy |
US8239842B2 (en) * | 2009-02-24 | 2012-08-07 | Microsoft Corporation | Implicit line continuation |
US9134973B2 (en) * | 2009-02-26 | 2015-09-15 | Red Hat, Inc. | Dynamic compiling and loading at runtime |
US9052984B2 (en) * | 2009-02-26 | 2015-06-09 | International Business Machines Corporation | Exception declaration refactoring to reduce memory footprint |
US10152504B2 (en) | 2009-03-11 | 2018-12-11 | Actian Netherlands B.V. | Column-store database architecture utilizing positional delta tree update system and methods |
US8397219B2 (en) * | 2009-03-31 | 2013-03-12 | Oracle America, Inc. | Method and apparatus for tracking enregistered memory locations |
US8112674B2 (en) * | 2009-04-01 | 2012-02-07 | International Business Machines Corporation | Device activity triggered device diagnostics |
KR101663545B1 (ko) * | 2009-04-06 | 2016-10-07 | 시게이트 테크놀로지 엘엘씨 | 코드의 동적 재배치 방법 및 이를 이용한 디스크 드라이브 |
US8139504B2 (en) * | 2009-04-07 | 2012-03-20 | Raytheon Bbn Technologies Corp. | System, device, and method for unifying differently-routed networks using virtual topology representations |
US8949103B2 (en) * | 2009-05-01 | 2015-02-03 | Microsoft Corporation | Program code simulator |
US8103850B2 (en) * | 2009-05-05 | 2012-01-24 | International Business Machines Corporation | Dynamic translation in the presence of intermixed code and data |
US20100306751A1 (en) * | 2009-05-28 | 2010-12-02 | James Paul Schneider | Execution result caching and searching |
US8127060B2 (en) | 2009-05-29 | 2012-02-28 | Invensys Systems, Inc | Methods and apparatus for control configuration with control objects that are fieldbus protocol-aware |
US8463964B2 (en) | 2009-05-29 | 2013-06-11 | Invensys Systems, Inc. | Methods and apparatus for control configuration with enhanced change-tracking |
US9117071B2 (en) | 2009-06-03 | 2015-08-25 | Apple Inc. | Methods and apparatuses for secure compilation |
US8677329B2 (en) * | 2009-06-03 | 2014-03-18 | Apple Inc. | Methods and apparatuses for a compiler server |
TWM376919U (en) * | 2009-06-08 | 2010-03-21 | Hon Hai Prec Ind Co Ltd | Antenna |
US8572589B2 (en) * | 2009-06-30 | 2013-10-29 | Agilent Technologies, Inc. | Programming language translator and enabling translation of machine-centric commands for controlling instrument |
US8473900B2 (en) * | 2009-07-01 | 2013-06-25 | Advanced Micro Devices, Inc. | Combining classes referenced by immutable classes into a single synthetic class |
US20110099439A1 (en) * | 2009-10-23 | 2011-04-28 | Infineon Technologies Ag | Automatic diverse software generation for use in high integrity systems |
US9355144B2 (en) * | 2009-12-10 | 2016-05-31 | Nokia Technologies Oy | Method and apparatus for recycling information fragments in information spaces |
US8972994B2 (en) | 2009-12-23 | 2015-03-03 | Intel Corporation | Method and apparatus to bypass object lock by speculative execution of generated bypass code shell based on bypass failure threshold in managed runtime environment |
EP2519876A1 (de) | 2009-12-28 | 2012-11-07 | Hyperion Core, Inc. | Optimierung von kreisen und datenflussabschnitten |
US8578343B2 (en) * | 2010-01-15 | 2013-11-05 | Oracle America, Inc. | System and method for overflow detection using partial evaluations |
CN102147734B (zh) * | 2010-02-10 | 2016-01-13 | 甲骨文国际公司 | 运行时类提取的方法和系统 |
US8397217B2 (en) * | 2010-02-22 | 2013-03-12 | International Business Machines Corporation | Integrating templates into tests |
US20110208948A1 (en) * | 2010-02-23 | 2011-08-25 | Infineon Technologies Ag | Reading to and writing from peripherals with temporally separated redundant processor execution |
US8327109B2 (en) * | 2010-03-02 | 2012-12-04 | Advanced Micro Devices, Inc. | GPU support for garbage collection |
US20110252216A1 (en) * | 2010-04-12 | 2011-10-13 | Tatu Ylonen Oy Ltd | Thread-local hash table based write barrier buffers |
CN102662827B (zh) * | 2010-04-13 | 2015-02-04 | 张溟 | 一种软件探测方法 |
CN102622299B (zh) * | 2010-04-13 | 2014-10-01 | 张溟 | 一种软件探测系统的工作方法 |
CN101923510B (zh) * | 2010-04-13 | 2012-07-04 | 张克东 | 软件探测方法和应用该方法的软件探测器及软件探测系统 |
US8365156B2 (en) * | 2010-04-17 | 2013-01-29 | Microsoft Corporation | Intermediate language support for change resilience |
US8375373B2 (en) | 2010-04-19 | 2013-02-12 | Microsoft Corporation | Intermediate language support for change resilience |
US8997049B1 (en) * | 2010-05-21 | 2015-03-31 | Cadence Design Systems, Inc. | Method and system for debugging of compiled code using an interpreter |
US9038038B1 (en) * | 2010-06-01 | 2015-05-19 | Google Inc. | Just in time cloud compilation |
FR2961922B1 (fr) | 2010-06-29 | 2013-12-13 | Flexycore | Procede de compilation selective, dispositif et produit programme d'ordinateur correspondant. |
US8331855B2 (en) | 2010-07-12 | 2012-12-11 | Invensys Systems, Inc. | Methods and apparatus for process control with improved communication links |
US9095002B2 (en) | 2010-07-12 | 2015-07-28 | Invensys Systems, Inc. | Methods and apparatus for process control with improved communication links |
US8516356B2 (en) | 2010-07-20 | 2013-08-20 | Infineon Technologies Ag | Real-time error detection by inverse processing |
US9195486B2 (en) * | 2010-07-30 | 2015-11-24 | Apple Inc. | Observation and analysis based code optimization |
US8862613B2 (en) * | 2010-07-30 | 2014-10-14 | Sap Ag | Extensibility of business process and application logic |
US9146759B2 (en) * | 2010-07-30 | 2015-09-29 | Apple Inc. | Assumption-based compilation |
JP5583514B2 (ja) * | 2010-08-11 | 2014-09-03 | インターナショナル・ビジネス・マシーンズ・コーポレーション | バイナリコードを最適化するコンパイル方法、及びそのコンパイラシステム、並びにコンピュータ・プログラム |
US8893306B2 (en) | 2010-08-31 | 2014-11-18 | International Business Machines Corporation | Resource management and security system |
US20120054773A1 (en) * | 2010-08-31 | 2012-03-01 | International Business Machines Corporation | Processor support for secure device driver architecture |
US8359496B1 (en) * | 2010-08-31 | 2013-01-22 | Google Inc. | Fault-resistant just-in-time compiler |
US8495750B2 (en) | 2010-08-31 | 2013-07-23 | International Business Machines Corporation | Filesystem management and security system |
EP3156896B1 (de) | 2010-09-17 | 2020-04-08 | Soft Machines, Inc. | Mehrfach verzweigte einzelzyklusvorhersage mit einem latenten cache für frühe und entfernte verzweigungsvorhersage |
JP5148674B2 (ja) * | 2010-09-27 | 2013-02-20 | 株式会社東芝 | プログラム並列化装置およびプログラム |
CA2719653A1 (en) * | 2010-11-05 | 2011-01-18 | Ibm Canada Limited - Ibm Canada Limitee | Partial inlining with software based restart |
CN102479155B (zh) * | 2010-11-30 | 2014-07-02 | 国际商业机器公司 | 用于网络应用服务器系统的内存过载管理的方法和系统 |
US8806465B2 (en) | 2010-12-03 | 2014-08-12 | International Busines Machines Corporation | Refactor exception class hierarchy for reduced footprint and faster application start |
KR101166803B1 (ko) | 2010-12-31 | 2012-07-26 | 세종대학교산학협력단 | 비휘발성 메모리 및 휘발성 메모리를 포함하는 메모리 시스템 및 그 시스템을 이용한 처리 방법 |
WO2012103253A2 (en) * | 2011-01-27 | 2012-08-02 | Soft Machines, Inc. | Multilevel conversion table cache for translating guest instructions to native instructions |
WO2012103367A2 (en) | 2011-01-27 | 2012-08-02 | Soft Machines, Inc. | Guest to native block address mappings and management of native code storage |
CN108874693B (zh) | 2011-01-27 | 2022-09-23 | 英特尔公司 | 使用处理器的转换后备缓冲器的基于客户指令到本机指令范围的映射 |
WO2012103359A2 (en) | 2011-01-27 | 2012-08-02 | Soft Machines, Inc. | Hardware acceleration components for translating guest instructions to native instructions |
WO2012103245A2 (en) | 2011-01-27 | 2012-08-02 | Soft Machines Inc. | Guest instruction block with near branching and far branching sequence construction to native instruction block |
US8595701B2 (en) * | 2011-02-04 | 2013-11-26 | Fujitsu Limited | Symbolic execution and test generation for GPU programs |
US9280439B2 (en) * | 2011-02-11 | 2016-03-08 | Sap Se | Usage analysis of productive environment to establish new data source for process optimization and project planning |
US8782644B2 (en) * | 2011-02-15 | 2014-07-15 | Oracle International Corporation | Preventing unsafe sharing through confinement of mutable captured variables |
US20120233605A1 (en) * | 2011-03-07 | 2012-09-13 | Microsoft Corporation | Application Compatibility Leveraging Successful Resolution of Issues |
US9069893B2 (en) * | 2011-03-23 | 2015-06-30 | International Business Machines Corporation | Automatic verification of determinism for parallel programs |
CN103635875B (zh) | 2011-03-25 | 2018-02-16 | 英特尔公司 | 用于通过使用由可分区引擎实例化的虚拟核来支持代码块执行的存储器片段 |
WO2012135041A2 (en) | 2011-03-25 | 2012-10-04 | Soft Machines, Inc. | Register file segments for supporting code block execution by using virtual cores instantiated by partitionable engines |
EP2689327B1 (de) | 2011-03-25 | 2021-07-28 | Intel Corporation | Ausführung von befehlsfolgen-codeblocks mittels durch partitionierbare engines realisierter virtueller kerne |
CA2738422C (en) * | 2011-04-28 | 2018-11-20 | Ibm Canada Limited-Ibm Canada Limitee | Examining concurrent system states |
US9183111B2 (en) * | 2011-05-10 | 2015-11-10 | Microsoft Technology Licensing, Llc | Methods and computer program products for collecting storage resource performance data using file system hooks |
TWI603198B (zh) | 2011-05-20 | 2017-10-21 | 英特爾股份有限公司 | 以複數個引擎作資源與互連結構的分散式分配以支援指令序列的執行 |
KR101639854B1 (ko) | 2011-05-20 | 2016-07-14 | 소프트 머신즈, 인크. | 복수의 엔진에 의해 명령어 시퀀스들의 실행을 지원하기 위한 상호접속 구조 |
US9063749B2 (en) * | 2011-05-27 | 2015-06-23 | Qualcomm Incorporated | Hardware support for hashtables in dynamic languages |
US8650537B2 (en) | 2011-05-30 | 2014-02-11 | International Business Machines Corporation | Optimizing an object-oriented program by transforming invocations of synthetic accessor methods |
US8578080B2 (en) * | 2011-07-01 | 2013-11-05 | Intel Corporation | Secure handling of interrupted events utilizing a virtual interrupt definition table |
US9116685B2 (en) * | 2011-07-19 | 2015-08-25 | Qualcomm Incorporated | Table call instruction for frequently called functions |
US8527544B1 (en) | 2011-08-11 | 2013-09-03 | Pure Storage Inc. | Garbage collection in a storage system |
US8549498B2 (en) * | 2011-08-23 | 2013-10-01 | International Business Machines Corporation | Integration of trace selection and trace profiling in dynamic optimizers |
CN102955735A (zh) * | 2011-08-24 | 2013-03-06 | 英业达股份有限公司 | 基本输入输出系统测试方法 |
US9063673B2 (en) * | 2011-08-30 | 2015-06-23 | Uniquesoft, Llc | System and method for implementing application code from application requirements |
US8819649B2 (en) * | 2011-09-09 | 2014-08-26 | Microsoft Corporation | Profile guided just-in-time (JIT) compiler and byte code generation |
US9053017B2 (en) | 2011-09-09 | 2015-06-09 | Microsoft Technology Licensing, Llc | Managing object lifetime in a cyclic graph |
US8990546B2 (en) | 2011-10-31 | 2015-03-24 | Freescale Semiconductor, Inc. | Data processing system with safe call and return |
US9043765B2 (en) * | 2011-11-09 | 2015-05-26 | Microsoft Technology Licensing, Llc | Simultaneously targeting multiple homogeneous and heterogeneous runtime environments |
US20130132061A1 (en) * | 2011-11-18 | 2013-05-23 | Michael J. Rieschl | Just-in-time static translation system for emulated computing environments |
KR101703401B1 (ko) | 2011-11-22 | 2017-02-06 | 소프트 머신즈, 인크. | 다중 엔진 마이크로프로세서용 가속 코드 최적화기 |
US20150039859A1 (en) | 2011-11-22 | 2015-02-05 | Soft Machines, Inc. | Microprocessor accelerated code optimizer |
US9411616B2 (en) * | 2011-12-09 | 2016-08-09 | Ca, Inc. | Classloader/instrumentation approach for invoking non-bound libraries |
US8789033B2 (en) | 2012-02-03 | 2014-07-22 | International Business Machines Corporation | Reducing application startup time by optimizing spatial locality of instructions in executables |
US20130205282A1 (en) * | 2012-02-07 | 2013-08-08 | Microsoft Corporation | Transferring program execution from compiled code to interpreted code |
US9155139B2 (en) | 2012-03-09 | 2015-10-06 | Rockwell Automation Technologies, Inc. | LED driver circuits and methods |
US9922090B1 (en) | 2012-03-27 | 2018-03-20 | Actian Netherlands, B.V. | System and method for automatic vertical decomposition of a table for improving input/output and memory utilization in a database |
GB2500707B (en) * | 2012-03-30 | 2014-09-17 | Cognovo Ltd | Multiprocessor system, apparatus and methods |
US10559123B2 (en) | 2012-04-04 | 2020-02-11 | Qualcomm Incorporated | Patched shading in graphics processing |
US9628438B2 (en) * | 2012-04-06 | 2017-04-18 | Exablox | Consistent ring namespaces facilitating data storage and organization in network infrastructures |
EP2839369B2 (de) * | 2012-04-20 | 2020-10-14 | NXP USA, Inc. | Informationsverarbeitungsvorrichtung und verfahren zum schutz von daten in einem aufrufstapel |
JP2013235386A (ja) * | 2012-05-08 | 2013-11-21 | Internatl Business Mach Corp <Ibm> | 最適化装置、最適化方法、及び最適化プログラム |
US20130332434A1 (en) * | 2012-06-11 | 2013-12-12 | Actian Netherlands, B.V. | System and method using partial just-in-time complation to resolve memory access pattern problems in hash table probing |
US8782620B2 (en) * | 2012-06-12 | 2014-07-15 | International Business Machines Corporation | Processing reified generics in object-based programming environments |
US9182984B2 (en) | 2012-06-15 | 2015-11-10 | International Business Machines Corporation | Local clearing control |
US8881126B2 (en) * | 2012-07-31 | 2014-11-04 | Oracle International Corporation | Systems and methods for testing a compiler through compile-time decision feedback |
US9274772B2 (en) | 2012-08-13 | 2016-03-01 | Microsoft Technology Licensing, Llc. | Compact type layouts |
TWI477970B (zh) * | 2012-08-24 | 2015-03-21 | Realtek Semiconductor Corp | 電子裝置的模式切換方法與相關的電子裝置 |
JP5998764B2 (ja) * | 2012-09-04 | 2016-09-28 | 富士通株式会社 | 情報処理装置、ログ出力方法およびログ出力プログラム |
US20150199228A1 (en) * | 2012-09-06 | 2015-07-16 | Google Inc. | Conditional branch programming technique |
US9753846B2 (en) * | 2012-09-06 | 2017-09-05 | Red Hat, Inc. | Adjusting the operating memory used by a virtual machine during runtime |
US8826240B1 (en) | 2012-09-29 | 2014-09-02 | Appurify, Inc. | Application validation through object level hierarchy analysis |
US10387294B2 (en) | 2012-10-12 | 2019-08-20 | Vmware, Inc. | Altering a test |
US8949794B2 (en) | 2012-10-12 | 2015-02-03 | Vmware, Inc. | Binding a software item to a plain english control name |
US9292416B2 (en) | 2012-10-12 | 2016-03-22 | Vmware, Inc. | Software development kit testing |
US9069902B2 (en) | 2012-10-12 | 2015-06-30 | Vmware, Inc. | Software test automation |
US9684587B2 (en) | 2012-10-12 | 2017-06-20 | Vmware, Inc. | Test creation with execution |
US10067858B2 (en) | 2012-10-12 | 2018-09-04 | Vmware, Inc. | Cloud-based software testing |
US8839202B2 (en) * | 2012-10-12 | 2014-09-16 | Vmware, Inc. | Test environment managed within tests |
US9292422B2 (en) | 2012-10-12 | 2016-03-22 | Vmware, Inc. | Scheduled software item testing |
US8839201B2 (en) * | 2012-10-12 | 2014-09-16 | Vmware, Inc. | Capturing test data associated with error conditions in software item testing |
US9015832B1 (en) | 2012-10-19 | 2015-04-21 | Google Inc. | Application auditing through object level code inspection |
US9231615B2 (en) * | 2012-10-24 | 2016-01-05 | Seagate Technology Llc | Method to shorten hash chains in Lempel-Ziv compression of data with repetitive symbols |
KR20140054948A (ko) * | 2012-10-30 | 2014-05-09 | 한국전자통신연구원 | 임베디드 시스템을 위한 오픈씨엘 응용 소프트웨어 개발 지원 도구 구성 및 방법 |
US9389868B2 (en) * | 2012-11-01 | 2016-07-12 | International Business Machines Corporation | Confidence-driven selective predication of processor instructions |
US9727338B2 (en) | 2012-11-05 | 2017-08-08 | Nvidia Corporation | System and method for translating program functions for correct handling of local-scope variables and computing system incorporating the same |
US8826254B2 (en) * | 2012-11-08 | 2014-09-02 | Concurix Corporation | Memoizing with read only side effects |
US9113358B1 (en) | 2012-11-19 | 2015-08-18 | Google Inc. | Configurable network virtualization |
US8984542B2 (en) * | 2012-11-30 | 2015-03-17 | Facebook, Inc. | Method and system for binding objects in dynamic programming languages using caching techniques |
US9268668B1 (en) | 2012-12-20 | 2016-02-23 | Google Inc. | System for testing markup language applications |
US9274935B1 (en) | 2013-01-15 | 2016-03-01 | Google Inc. | Application testing system with application programming interface |
US10496775B2 (en) * | 2013-01-31 | 2019-12-03 | General Electric Company | Method and system for use in dynamically configuring data acquisition systems |
US9052888B2 (en) * | 2013-02-21 | 2015-06-09 | International Business Machines Corporation | Vectorization in an optimizing compiler |
US11507574B1 (en) | 2013-03-13 | 2022-11-22 | Actian Netherlands B.V. | Adaptive selection of a processing method based on observed performance for improved and robust system efficiency |
US10275255B2 (en) | 2013-03-15 | 2019-04-30 | Intel Corporation | Method for dependency broadcasting through a source organized source view data structure |
US9886279B2 (en) | 2013-03-15 | 2018-02-06 | Intel Corporation | Method for populating and instruction view data structure by using register template snapshots |
CN105122206B (zh) | 2013-03-15 | 2018-11-09 | 英特尔公司 | 用于支持推测的访客返回地址栈仿真的方法和装置 |
US9904625B2 (en) | 2013-03-15 | 2018-02-27 | Intel Corporation | Methods, systems and apparatus for predicting the way of a set associative cache |
WO2014150806A1 (en) | 2013-03-15 | 2014-09-25 | Soft Machines, Inc. | A method for populating register view data structure by using register template snapshots |
US9569216B2 (en) | 2013-03-15 | 2017-02-14 | Soft Machines, Inc. | Method for populating a source view data structure by using register template snapshots |
US9811342B2 (en) | 2013-03-15 | 2017-11-07 | Intel Corporation | Method for performing dual dispatch of blocks and half blocks |
US9632825B2 (en) | 2013-03-15 | 2017-04-25 | Intel Corporation | Method and apparatus for efficient scheduling for asymmetrical execution units |
KR102083390B1 (ko) | 2013-03-15 | 2020-03-02 | 인텔 코포레이션 | 네이티브 분산된 플래그 아키텍처를 이용하여 게스트 중앙 플래그 아키텍처를 에뮬레이션하는 방법 |
US10140138B2 (en) | 2013-03-15 | 2018-11-27 | Intel Corporation | Methods, systems and apparatus for supporting wide and efficient front-end operation with guest-architecture emulation |
US9891924B2 (en) | 2013-03-15 | 2018-02-13 | Intel Corporation | Method for implementing a reduced size register view data structure in a microprocessor |
WO2014150991A1 (en) | 2013-03-15 | 2014-09-25 | Soft Machines, Inc. | A method for implementing a reduced size register view data structure in a microprocessor |
WO2014150971A1 (en) | 2013-03-15 | 2014-09-25 | Soft Machines, Inc. | A method for dependency broadcasting through a block organized source view data structure |
KR101708591B1 (ko) | 2013-03-15 | 2017-02-20 | 소프트 머신즈, 인크. | 블록들로 그룹화된 멀티스레드 명령어들을 실행하기 위한 방법 |
WO2014151652A1 (en) | 2013-03-15 | 2014-09-25 | Soft Machines Inc | Method and apparatus to allow early dependency resolution and data forwarding in a microprocessor |
US9021443B1 (en) | 2013-04-12 | 2015-04-28 | Google Inc. | Test automation API for host devices |
US9552382B2 (en) | 2013-04-23 | 2017-01-24 | Exablox Corporation | Reference counter integrity checking |
US9298433B2 (en) * | 2013-05-02 | 2016-03-29 | Facebook, Inc. | Optimizing intermediate representation of script code for fast path execution |
US10127138B2 (en) | 2013-06-06 | 2018-11-13 | Microsoft Technology Licensing, Llc. | Debugging native code by transitioning from execution in native mode to execution in interpreted mode |
JP2016526717A (ja) | 2013-06-12 | 2016-09-05 | エグザブロックス・コーポレーション | ハイブリッドガベージコレクション |
EP3011428A4 (de) | 2013-06-19 | 2017-02-22 | Exablox Corporation | Datenbereinigung in clusterbasierten speichersystemen |
US9934242B2 (en) | 2013-07-10 | 2018-04-03 | Exablox Corporation | Replication of data between mirrored data sites |
US10453534B2 (en) * | 2013-08-07 | 2019-10-22 | Qualcomm Technologies International, Ltd. | Patching of programmable memory |
US9268670B1 (en) | 2013-08-08 | 2016-02-23 | Google Inc. | System for module selection in software application testing including generating a test executable based on an availability of root access |
US9740716B2 (en) * | 2013-08-21 | 2017-08-22 | Oracle International Corporation | System and method for dynamically selecting a garbage collection algorithm based on the contents of heap regions |
US9229858B2 (en) | 2013-10-08 | 2016-01-05 | Red Hat, Inc. | Concurrent garbage collector thread |
US10248556B2 (en) | 2013-10-16 | 2019-04-02 | Exablox Corporation | Forward-only paged data storage management where virtual cursor moves in only one direction from header of a session to data field of the session |
US9053228B1 (en) | 2013-10-22 | 2015-06-09 | The Mathworks, Inc. | Determining when to evaluate program code and provide results in a live evaluation programming environment |
US9985829B2 (en) | 2013-12-12 | 2018-05-29 | Exablox Corporation | Management and provisioning of cloud connected devices |
DE102013021655A1 (de) * | 2013-12-18 | 2015-06-18 | Giesecke & Devrient Gmbh | Verfahren und Vorrichtung zur Bearbeitung von Wertdokumenten |
US20150186168A1 (en) * | 2013-12-30 | 2015-07-02 | Unisys Corporation | Dedicating processing resources to just-in-time compilers and instruction processors in a dynamic translator |
US9524178B2 (en) * | 2013-12-30 | 2016-12-20 | Unisys Corporation | Defining an instruction path to be compiled by a just-in-time (JIT) compiler |
US9213563B2 (en) * | 2013-12-30 | 2015-12-15 | Unisys Corporation | Implementing a jump instruction in a dynamic translator that uses instruction code translation and just-in-time compilation |
WO2015102631A1 (en) * | 2014-01-02 | 2015-07-09 | Hewlett Packard Development Company, L.P. | Distributed kernel thread list processing for kernel patching |
US9367415B1 (en) | 2014-01-20 | 2016-06-14 | Google Inc. | System for testing markup language applications on a device |
US9491229B1 (en) | 2014-01-24 | 2016-11-08 | Google Inc. | Application experience sharing system |
US9170922B1 (en) | 2014-01-27 | 2015-10-27 | Google Inc. | Remote application debugging |
US9774582B2 (en) | 2014-02-03 | 2017-09-26 | Exablox Corporation | Private cloud connected device cluster architecture |
US9830324B2 (en) | 2014-02-04 | 2017-11-28 | Exablox Corporation | Content based organization of file systems |
JP5988444B2 (ja) | 2014-02-14 | 2016-09-07 | インターナショナル・ビジネス・マシーンズ・コーポレーションInternational Business Machines Corporation | 最適化したバイナリー・モジュールをテストする方法、並びに、当該最適化したバイナリー・モジュールをテストするためのコンピュータ及びそのコンピュータ・プログラム |
US9703948B2 (en) * | 2014-03-28 | 2017-07-11 | Intel Corporation | Return-target restrictive return from procedure instructions, processors, methods, and systems |
WO2015163931A1 (en) * | 2014-04-24 | 2015-10-29 | Hewlett-Packard Development Company, L.P. | Dynamically applying a patch to a computer application |
US10261889B2 (en) | 2014-06-25 | 2019-04-16 | Microsoft Technology Licensing, Llc | Techniques for edit-and-continue and enhanced optimized debugging on optimized code |
US9690626B2 (en) * | 2014-06-27 | 2017-06-27 | Vmware, Inc. | Processing workloads in single-threaded environments |
KR101703984B1 (ko) * | 2014-07-18 | 2017-02-09 | 주식회사 큐램 | 메모리 처리 방법, 및 메모리 처리 시스템 |
US10338914B2 (en) * | 2014-09-01 | 2019-07-02 | Hewlett Packard Enterprise Development Lp | Dynamically applying a patch to a shared library |
US9268543B1 (en) * | 2014-09-23 | 2016-02-23 | International Business Machines Corporation | Efficient code cache management in presence of infrequently used complied code fragments |
US9772824B2 (en) * | 2015-03-25 | 2017-09-26 | International Business Machines Corporation | Program structure-based blocking |
US9389851B1 (en) * | 2015-06-02 | 2016-07-12 | Oracle International Corporation | System and method for providing consistency between software library repositories |
US9880787B2 (en) * | 2015-08-06 | 2018-01-30 | Dialog Semiconductor B.V. | System and method for memory patching circuits |
US20170060924A1 (en) | 2015-08-26 | 2017-03-02 | Exablox Corporation | B-Tree Based Data Model for File Systems |
US9632755B1 (en) | 2015-10-06 | 2017-04-25 | International Business Machines Corporation | Interface method resolution in object oriented programming models |
KR102079499B1 (ko) * | 2015-10-20 | 2020-02-21 | 엘에스산전 주식회사 | Plc 위치 결정 시스템의 축별 제어주기 독립 할당 방법 |
US9864655B2 (en) | 2015-10-30 | 2018-01-09 | Google Llc | Methods and apparatus for mobile computing device security in testing facilities |
US9733930B2 (en) * | 2015-12-21 | 2017-08-15 | Successfactors, Inc. | Logical level difference detection between software revisions |
US9696973B1 (en) * | 2016-02-24 | 2017-07-04 | Semmle Limited | Compilation cache with imports scanner |
US9846553B2 (en) | 2016-05-04 | 2017-12-19 | Exablox Corporation | Organization and management of key-value stores |
FR3056782B1 (fr) * | 2016-09-26 | 2019-12-13 | Airbus Operations | Generation de codes applicatifs a partir d'une specification formelle |
JP6433468B2 (ja) * | 2016-09-28 | 2018-12-05 | 本田技研工業株式会社 | プログラム作成支援方法 |
US10108404B2 (en) | 2016-10-24 | 2018-10-23 | International Business Machines Corporation | Compiling optimized entry points for local-use-only function pointers |
US10169016B2 (en) * | 2016-10-24 | 2019-01-01 | International Business Machines Corporation | Executing optimized local entry points |
US10108406B2 (en) * | 2016-10-24 | 2018-10-23 | International Business Machines Corporation | Linking optimized entry points for local-use-only function pointers |
US10169011B2 (en) * | 2016-10-24 | 2019-01-01 | International Business Machines Corporation | Comparisons in function pointer localization |
US10108407B2 (en) * | 2016-10-24 | 2018-10-23 | International Business Machines Corporation | Loading optimized local entry points for local-use-only function pointers |
US10338932B2 (en) | 2016-11-15 | 2019-07-02 | Google Llc | Bootstrapping profile-guided compilation and verification |
US10025694B1 (en) * | 2016-12-22 | 2018-07-17 | SafeDK Mobile Ltd. | Monitoring activity of software development kits using stack trace analysis |
US10244010B2 (en) * | 2017-02-16 | 2019-03-26 | Nokia Of America Corporation | Data processing apparatus configured to recover a network connection, a method, a system and a non-transitory computer readable medium configured to perform same |
US20180275976A1 (en) * | 2017-03-22 | 2018-09-27 | Qualcomm Innovation Center, Inc. | Link time optimization in presence of a linker script using path based rules |
US10846196B1 (en) | 2017-06-09 | 2020-11-24 | Azul Systems, Inc. | Code optimization for connected managed runtime environments |
CN107562775B (zh) * | 2017-07-14 | 2020-04-24 | 创新先进技术有限公司 | 一种基于区块链的数据处理方法及设备 |
US10642971B2 (en) * | 2017-09-04 | 2020-05-05 | Cisco Technology, Inc. | Methods and systems for ensuring program code flow integrity |
CN109710396B (zh) * | 2017-10-26 | 2023-08-22 | 华为技术有限公司 | 一种信息采集及内存释放的方法及装置 |
US10564955B2 (en) * | 2018-01-03 | 2020-02-18 | Huawei Technologies Co., Ltd. | Method to manage multiple versions of parts of a software application and to retire older versions in a dynamically updatable software system |
US10402320B1 (en) | 2018-02-27 | 2019-09-03 | Oracle International Corporation | Verifying the validity of a transition from a current tail template to a new tail template for a fused object |
US10613864B2 (en) * | 2018-03-16 | 2020-04-07 | Texas Instruments Incorporated | Processor with hardware supported memory buffer overflow detection |
US11716558B2 (en) | 2018-04-16 | 2023-08-01 | Charter Communications Operating, Llc | Apparatus and methods for integrated high-capacity data and wireless network services |
US10908910B2 (en) | 2018-07-27 | 2021-02-02 | Oracle International Corporation | Lazy copying of runtime-managed stack frames |
CN110908790B (zh) * | 2018-09-14 | 2022-02-22 | 旺宏电子股份有限公司 | 存储器存储装置及其操作方法 |
US11175802B2 (en) * | 2018-09-21 | 2021-11-16 | Sap Se | Configuration object deletion manager |
EP3864917A4 (de) | 2018-10-12 | 2022-07-06 | Charter Communications Operating, LLC | Vorrichtung und verfahren zur identifizierung von zellen in drahtlosen netzwerken |
KR20200053318A (ko) * | 2018-11-08 | 2020-05-18 | 삼성전자주식회사 | 인공 신경망의 연산 처리 그래프를 관리하는 시스템 및 이를 이용한 연산 처리 그래프를 관리하는 방법 |
US10956133B2 (en) * | 2018-11-28 | 2021-03-23 | International Business Machines Corporation | Static optimization of production code for dynamic profiling |
US11182205B2 (en) * | 2019-01-02 | 2021-11-23 | Mellanox Technologies, Ltd. | Multi-processor queuing model |
US11129171B2 (en) | 2019-02-27 | 2021-09-21 | Charter Communications Operating, Llc | Methods and apparatus for wireless signal maximization and management in a quasi-licensed wireless system |
US11048549B2 (en) | 2019-04-04 | 2021-06-29 | Google Llc | Transferral of process state and/or components in computing environments |
CN112015491B (zh) * | 2019-05-30 | 2022-08-09 | 华为技术有限公司 | 实现函数跳转的方法、装置及计算机存储介质 |
JPWO2021014962A1 (de) * | 2019-07-19 | 2021-01-28 | ||
WO2021021126A1 (en) * | 2019-07-30 | 2021-02-04 | Hewlett-Packard Development Company, L.P. | Hash map of executable control blocks |
CN110443053B (zh) * | 2019-07-31 | 2023-03-14 | 四川效率源信息安全技术股份有限公司 | 一种基于密钥循环表及映射表的密钥生成方法 |
US11070420B2 (en) * | 2019-09-13 | 2021-07-20 | Pacific Track, LLC | System, device, and method for configuring the handling of events |
US11182149B2 (en) * | 2019-09-30 | 2021-11-23 | International Business Machines Corporation | Just-in-time code patching |
US11526358B2 (en) * | 2019-10-15 | 2022-12-13 | Raytheon Company | Deterministic execution replay for multicore systems |
US11026205B2 (en) | 2019-10-23 | 2021-06-01 | Charter Communications Operating, Llc | Methods and apparatus for device registration in a quasi-licensed wireless system |
US11301221B2 (en) * | 2019-12-13 | 2022-04-12 | Sap Se | Rapid code compiling system |
RU2729210C1 (ru) * | 2020-01-28 | 2020-08-05 | Акционерное общество «Информационные спутниковые системы» имени академика М.Ф. Решетнёва» | Комплекс тестирования программного обеспечения электронных устройств |
CN111680289B (zh) * | 2020-04-29 | 2023-04-14 | 中国科学院信息工程研究所 | 一种链式哈希栈运算方法及装置 |
EP3940565A1 (de) * | 2020-07-15 | 2022-01-19 | Hewlett-Packard Development Company, L.P. | Systemverwaltungszustände |
US11573894B2 (en) | 2020-10-29 | 2023-02-07 | Oracle International Corporation | Tracking garbage collection states of references |
US11513954B2 (en) | 2021-03-25 | 2022-11-29 | Oracle International Corporation | Consolidated and concurrent remapping and identification for colorless roots |
US11875193B2 (en) | 2021-03-25 | 2024-01-16 | Oracle International Corporation | Tracking frame states of call stack frames including colorless roots |
US11573794B2 (en) | 2021-03-25 | 2023-02-07 | Oracle International Corporation | Implementing state-based frame barriers to process colorless roots during concurrent execution |
CN113127001B (zh) * | 2021-04-28 | 2024-03-08 | 上海米哈游璃月科技有限公司 | 一种代码编译过程监控方法、装置、设备和介质 |
US11507503B1 (en) | 2021-05-19 | 2022-11-22 | Oracle International Corporation | Write barrier for remembered set maintenance in generational Z garbage collector |
CN113190466A (zh) * | 2021-06-08 | 2021-07-30 | 科东(广州)软件科技有限公司 | 自动化测试方法、装置、设备及介质 |
WO2023272567A1 (en) * | 2021-06-30 | 2023-01-05 | Huawei Technologies Co., Ltd. | Method and system for providing context-sensitive, non-intrusive data processing optimization framework |
US11847035B2 (en) | 2021-08-23 | 2023-12-19 | International Business Machines Corporation | Functional test of processor code modification operations |
Citations (53)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4675829A (en) * | 1984-07-27 | 1987-06-23 | Intellicorp Corporation | Method and apparatus for building knowledge-based systems |
US4924408A (en) * | 1988-08-19 | 1990-05-08 | International Business Machines Corporation | Technique for compilation of knowledge bases |
US5210876A (en) * | 1988-06-06 | 1993-05-11 | Nec Corporation | Method for calling interpreter language procedure from compiler language procedure |
US5293614A (en) * | 1991-04-08 | 1994-03-08 | Texas Instruments Incorporated | System and method for hard real-time garbage collection requiring a write barrier but no read barrier |
US5301260A (en) * | 1990-08-06 | 1994-04-05 | Matsushita Electric Industrial, Co., Ltd. | Inference processor using data consistency holder |
US5301325A (en) * | 1991-03-07 | 1994-04-05 | Digital Equipment Corporation | Use of stack depth to identify architechture and calling standard dependencies in machine code |
US5339436A (en) * | 1989-08-31 | 1994-08-16 | Yokogawa Electric Corporation | Method of implementing a relocated compiled library program with an interpreter to control a manufacturing line |
US5367685A (en) * | 1992-12-22 | 1994-11-22 | Firstperson, Inc. | Method and apparatus for resolving data references in generated code |
US5442792A (en) * | 1992-08-07 | 1995-08-15 | Hughes Aircraft Company | Expert system compilation method |
US5450575A (en) * | 1991-03-07 | 1995-09-12 | Digital Equipment Corporation | Use of stack depth to identify machine code mistakes |
US5452457A (en) * | 1993-01-29 | 1995-09-19 | International Business Machines Corporation | Program construct and methods/systems for optimizing assembled code for execution |
US5469574A (en) * | 1993-06-18 | 1995-11-21 | International Business Machines Corporation | Method and system for interfacing interpreted applications with compiled procedures using signature files |
US5551040A (en) * | 1993-06-02 | 1996-08-27 | Lucent Technologies Inc. | Methods and apparatus for specifying the contexts of names in callback-style programming |
US5590332A (en) * | 1995-01-13 | 1996-12-31 | Baker; Henry G. | Garbage collection, tail recursion and first-class continuations in stack-oriented languages |
US5598561A (en) * | 1991-07-25 | 1997-01-28 | Nec Corporation | Optimizing compiler which generates multiple instruction streams to be executed in parallel |
US5603030A (en) * | 1993-01-07 | 1997-02-11 | Microsoft Corporation | Method and system for destruction of objects using multiple destructor functions in an object-oriented computer system |
US5613120A (en) * | 1994-10-20 | 1997-03-18 | Silicon Graphics, Inc. | System and method for enabling, without recompilation, modification of class definitions and implementations in an object-oriented computer program |
US5632034A (en) * | 1993-06-01 | 1997-05-20 | International Business Machines Corporation | Controlling method invocation sequence through virtual functions in an object-oriented class library |
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 |
US5675804A (en) * | 1995-08-31 | 1997-10-07 | International Business Machines Corporation | System and method for enabling a compiled computer program to invoke an interpretive computer program |
US5721854A (en) * | 1993-11-02 | 1998-02-24 | International Business Machines Corporation | Method and apparatus for dynamic conversion of computer instructions |
US5761513A (en) * | 1996-07-01 | 1998-06-02 | Sun Microsystems, Inc. | System and method for exception handling in dynamically linked programs |
US5764989A (en) * | 1996-02-29 | 1998-06-09 | Supercede, Inc. | Interactive software development system |
US5815501A (en) * | 1992-06-05 | 1998-09-29 | Washington University | ATM-ethernet portal/concentrator |
US5815720A (en) * | 1996-03-15 | 1998-09-29 | Institute For The Development Of Emerging Architectures, L.L.C. | Use of dynamic translation to collect and exploit run-time information in an optimizing compilation system |
US5835958A (en) * | 1996-10-29 | 1998-11-10 | Sun Microsystems, Inc. | Method and apparatus for dynamically sizing non-contiguous runtime stacks |
US5835771A (en) * | 1995-06-07 | 1998-11-10 | Rogue Wave Software, Inc. | Method and apparatus for generating inline code using template metaprograms |
US5842016A (en) * | 1997-05-29 | 1998-11-24 | Microsoft Corporation | Thread synchronization in a garbage-collected system using execution barriers |
US5848274A (en) * | 1996-02-29 | 1998-12-08 | Supercede, Inc. | Incremental byte code compilation system |
US5857104A (en) * | 1996-11-26 | 1999-01-05 | Hewlett-Packard Company | Synthetic dynamic branch prediction |
US5873104A (en) * | 1997-06-26 | 1999-02-16 | Sun Microsystems, Inc. | Bounded-pause time garbage collection system and method including write barrier associated with source and target instances of a partially relocated object |
US5873105A (en) * | 1997-06-26 | 1999-02-16 | Sun Microsystems, Inc. | Bounded-pause time garbage collection system and method including write barrier associated with a source instance of a partially relocated object |
US5872978A (en) * | 1995-12-21 | 1999-02-16 | U.S. Philips Corporation | Method and apparatus for improved translation of program data into machine code format |
US5892944A (en) * | 1993-07-20 | 1999-04-06 | Kabushiki Kaisha Toshiba | Program execution and operation right management system suitable for single virtual memory scheme |
US5950221A (en) * | 1997-02-06 | 1999-09-07 | Microsoft Corporation | Variably-sized kernel memory stacks |
US5953530A (en) * | 1995-02-07 | 1999-09-14 | Sun Microsystems, Inc. | Method and apparatus for run-time memory access checking and memory leak detection of a multi-threaded program |
US6047295A (en) * | 1998-05-05 | 2000-04-04 | International Business Machines Corporation | Computer system, program product and method of managing weak references with a concurrent mark sweep collector |
US6138210A (en) * | 1997-06-23 | 2000-10-24 | Sun Microsystems, Inc. | Multi-stack memory architecture |
US6148391A (en) * | 1998-03-26 | 2000-11-14 | Sun Microsystems, Inc. | System for simultaneously accessing one or more stack elements by multiple functional units using real stack addresses |
US6175916B1 (en) * | 1997-05-06 | 2001-01-16 | Microsoft Corporation | Common-thread inter-process function calls invoked by jumps to invalid addresses |
US6199075B1 (en) * | 1997-05-30 | 2001-03-06 | Sun Microsystems, Inc. | Method and apparatus for generational garbage collection of a heap memory shared by multiple processors |
US6223202B1 (en) * | 1998-06-05 | 2001-04-24 | International Business Machines Corp. | Virtual machine pooling |
US6253215B1 (en) * | 1998-08-17 | 2001-06-26 | Sun Microsystems | Method, apparatus, and article of manufacture for facilitating resource management for applications having two types of program code |
US6269425B1 (en) * | 1998-08-20 | 2001-07-31 | International Business Machines Corporation | Accessing data from a multiple entry fully associative cache buffer in a multithread data processing system |
US20010013117A1 (en) * | 1998-09-15 | 2001-08-09 | David Ungar | Method and apparatus for finding bugs related to garbage collection in a virtual machine |
US6304949B1 (en) * | 1997-08-22 | 2001-10-16 | U.S. Philips Corporation | Data processor with localized memory reclamation |
US20010039609A1 (en) * | 1997-08-22 | 2001-11-08 | Koninklijke Philips Electronics N.V. | Data processor with localised memory reclamation |
US6317816B1 (en) * | 1999-01-29 | 2001-11-13 | International Business Machines Corporation | Multiprocessor scaleable system and method for allocating memory from a heap |
US6353829B1 (en) * | 1998-12-23 | 2002-03-05 | Cray Inc. | Method and system for memory allocation in a multiprocessing environment |
US6389540B1 (en) * | 1998-02-26 | 2002-05-14 | Sun Microsystems, Inc. | Stack based access control using code and executor identifiers |
US6629113B1 (en) * | 1999-06-30 | 2003-09-30 | International Business Machines Corporation | Method and system for dynamically adjustable and configurable garbage collector |
US20040039758A1 (en) * | 2002-08-22 | 2004-02-26 | Xiaofeng Li | Methods and apparatus for concurrent enumeration of an object reference root set |
US6845385B1 (en) * | 1994-07-13 | 2005-01-18 | Object Technology Licensing Corp. | Real-time computer “garbage collector” |
Family Cites Families (116)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4367685A (en) * | 1980-09-08 | 1983-01-11 | Frame Scott W | Process and apparatus for precisely metering quantities of granular or pulverulent solids |
US4525780A (en) * | 1981-05-22 | 1985-06-25 | Data General Corporation | Data processing system having a memory using object-based information and a protection scheme for determining access rights to such information |
JPS6260037A (ja) * | 1985-09-09 | 1987-03-16 | Nec Corp | コンパイラの目的プログラムの自動検査方式 |
US4831517A (en) * | 1986-10-10 | 1989-05-16 | International Business Machines Corporation | Branch and return on address instruction and methods and apparatus for implementing same in a digital data processing system |
JPH01155438A (ja) * | 1987-12-12 | 1989-06-19 | Hitachi Ltd | コンパイラ試験方式 |
JPH03186945A (ja) * | 1989-12-18 | 1991-08-14 | Oki Electric Ind Co Ltd | プログラム実行特性の測定方法 |
JPH04540A (ja) * | 1990-04-17 | 1992-01-06 | Toshiba Corp | デバック装置 |
JPH044434A (ja) * | 1990-04-21 | 1992-01-08 | Mitsubishi Electric Corp | プログラムのトレース方法 |
JP2901720B2 (ja) * | 1990-08-10 | 1999-06-07 | 株式会社日立製作所 | オブジェクトコード比較方法 |
JPH04287134A (ja) * | 1991-03-15 | 1992-10-12 | Nec Corp | 簡易トレース情報取得方式 |
US5193180A (en) * | 1991-06-21 | 1993-03-09 | Pure Software Inc. | System for modifying relocatable object code files to monitor accesses to dynamically allocated memory |
JPH05233326A (ja) * | 1991-12-19 | 1993-09-10 | Internatl Business Mach Corp <Ibm> | コンピュータシステムにおいて事象を取り扱う方法及びシステム |
JPH05324399A (ja) * | 1992-03-23 | 1993-12-07 | Toshiba Corp | 情報監視装置 |
US5515538A (en) * | 1992-05-29 | 1996-05-07 | Sun Microsystems, Inc. | Apparatus and method for interrupt handling in a multi-threaded operating system kernel |
JPH06119203A (ja) * | 1992-10-06 | 1994-04-28 | Oki Electric Ind Co Ltd | デバック行削除装置 |
DE59302131D1 (de) * | 1992-10-15 | 1996-05-09 | Siemens Ag | Verfahren zur durchfürhung von tests an auf einem rechner parallel ablauffähigen objekten eines objektorientierten programmes |
JPH06187143A (ja) * | 1992-10-23 | 1994-07-08 | Sony Corp | 電子装置 |
JPH06139107A (ja) * | 1992-10-30 | 1994-05-20 | Nec Corp | ブレイクアドレス検出回路 |
JP3199876B2 (ja) * | 1992-11-20 | 2001-08-20 | 株式会社東芝 | プログラム解析システムおよび方法 |
JPH06168111A (ja) * | 1992-11-30 | 1994-06-14 | Fuji Facom Corp | デバッグ文の自動作成方式 |
DE69327448T2 (de) | 1992-12-21 | 2004-03-04 | Sun Microsystems, Inc., Mountain View | Verfahren und Vorrichtung für Teilaufgaben in verteiltem Verarbeitungssystem |
US5560003A (en) * | 1992-12-21 | 1996-09-24 | Iowa State University Research Foundation, Inc. | System and hardware module for incremental real time garbage collection and memory management |
JPH06222952A (ja) * | 1993-01-27 | 1994-08-12 | Toshiba Corp | デバッグ支援装置 |
JPH06274375A (ja) * | 1993-03-20 | 1994-09-30 | Hitachi Ltd | システム評価装置 |
US5537573A (en) * | 1993-05-28 | 1996-07-16 | Rambus, Inc. | Cache system and method for prefetching of data |
US6126329A (en) * | 1993-06-08 | 2000-10-03 | Rational Software Coporation | Method and apparatus for accurate profiling of computer programs |
US5748961A (en) * | 1993-07-12 | 1998-05-05 | Digital Equipment Corporation | Efficient method and apparatus for compiling and linking modules of computer code in a large software system |
JP3480973B2 (ja) * | 1993-11-30 | 2003-12-22 | 富士通株式会社 | 並列処理システムの動作解析装置 |
US5761511A (en) * | 1994-01-28 | 1998-06-02 | Sun Microsystems, Inc. | Method and apparatus for a type-safe framework for dynamically extensible objects |
US5590329A (en) * | 1994-02-04 | 1996-12-31 | Lucent Technologies Inc. | Method and apparatus for detecting memory access errors |
US5732273A (en) * | 1995-08-11 | 1998-03-24 | Digital Equipment Corporation | System for monitoring compute system performance |
JPH07262044A (ja) * | 1994-03-25 | 1995-10-13 | Hitachi Ltd | イベントトレース解析方法 |
JPH07271631A (ja) * | 1994-03-31 | 1995-10-20 | Fujitsu Ltd | デバッガ |
AUPM519694A0 (en) * | 1994-04-19 | 1994-05-12 | Griffith University | Method for testing and debugging computer programs |
US5835743A (en) * | 1994-06-30 | 1998-11-10 | Sun Microsystems, Inc. | Application binary interface and method of interfacing binary application program to digital computer |
US6006033A (en) * | 1994-08-15 | 1999-12-21 | International Business Machines Corporation | Method and system for reordering the instructions of a computer program to optimize its execution |
US5511190A (en) * | 1995-01-20 | 1996-04-23 | Tandem Computers, Inc. | Hash-based database grouping system and method |
JPH08202579A (ja) * | 1995-01-23 | 1996-08-09 | Toshiba Corp | プログラミング支援装置及びプログラミング支援方法 |
US5619698A (en) * | 1995-05-05 | 1997-04-08 | Apple Computer, Inc. | Method and apparatus for patching operating systems |
JPH08320795A (ja) * | 1995-05-24 | 1996-12-03 | Fuji Xerox Co Ltd | プログラム制御システム |
US5805899A (en) * | 1995-07-06 | 1998-09-08 | Sun Microsystems, Inc. | Method and apparatus for internal versioning of objects using a mapfile |
US6301652B1 (en) * | 1996-01-31 | 2001-10-09 | International Business Machines Corporation | Instruction cache alignment mechanism for branch targets based on predicted execution frequencies |
US6151703A (en) * | 1996-05-20 | 2000-11-21 | Inprise Corporation | Development system with methods for just-in-time compilation of programs |
US5815718A (en) | 1996-05-30 | 1998-09-29 | Sun Microsystems, Inc. | Method and system for loading classes in read-only memory |
US5946487A (en) * | 1996-06-10 | 1999-08-31 | Lsi Logic Corporation | Object-oriented multi-media architecture |
US6189048B1 (en) * | 1996-06-26 | 2001-02-13 | Sun Microsystems, Inc. | Mechanism for dispatching requests in a distributed object system |
US6067577A (en) * | 1996-09-30 | 2000-05-23 | Apple Computer, Inc. | Dynamic method resolution for native methods in a dynamic object-oriented programming language |
US6041179A (en) * | 1996-10-03 | 2000-03-21 | International Business Machines Corporation | Object oriented dispatch optimization |
JPH10240581A (ja) * | 1997-02-28 | 1998-09-11 | Fujitsu Ltd | Cpu時間測定装置 |
US5905855A (en) * | 1997-02-28 | 1999-05-18 | Transmeta Corporation | Method and apparatus for correcting errors in computer systems |
US5948059A (en) * | 1997-03-21 | 1999-09-07 | International Business Machines Corporation | Method and apparatus for synchronizing multimedia messages in different servers |
US5920876A (en) | 1997-04-23 | 1999-07-06 | Sun Microsystems, Inc. | Performing exact garbage collection using bitmaps that identify pointer values within objects |
US5757690A (en) * | 1997-04-23 | 1998-05-26 | Exponential Technology, Inc. | Embedded ROM with RAM valid bits for fetching ROM-code updates from external memory |
JP3138658B2 (ja) * | 1997-04-28 | 2001-02-26 | 日本電気アイシーマイコンシステム株式会社 | タスク・トレース装置 |
US6330659B1 (en) * | 1997-11-06 | 2001-12-11 | Iready Corporation | Hardware accelerator for an object-oriented programming language |
US6094664A (en) | 1997-05-30 | 2000-07-25 | Sun Microsystems | Method and apparatus for optimizing the null pointer exception in an object-oriented programming environment with statically typed variables |
US6105040A (en) | 1997-06-30 | 2000-08-15 | Sun Microsystems, Inc. | Method and apparatus for managing stored objects |
US6513156B2 (en) * | 1997-06-30 | 2003-01-28 | Sun Microsystems, Inc. | Interpreting functions utilizing a hybrid of virtual and native machine instructions |
US6317872B1 (en) * | 1997-07-11 | 2001-11-13 | Rockwell Collins, Inc. | Real time processor optimized for executing JAVA programs |
US6173276B1 (en) * | 1997-08-21 | 2001-01-09 | Scicomp, Inc. | System and method for financial instrument modeling and valuation |
US6112304A (en) * | 1997-08-27 | 2000-08-29 | Zipsoft, Inc. | Distributed computing architecture |
US6275938B1 (en) * | 1997-08-28 | 2001-08-14 | Microsoft Corporation | Security enhancement for untrusted executable code |
US6366876B1 (en) * | 1997-09-29 | 2002-04-02 | Sun Microsystems, Inc. | Method and apparatus for assessing compatibility between platforms and applications |
US6072953A (en) * | 1997-09-30 | 2000-06-06 | International Business Machines Corporation | Apparatus and method for dynamically modifying class files during loading for execution |
US6047125A (en) * | 1997-10-01 | 2000-04-04 | Sun Microsystems, Inc. | Garbage collection system for improved use of memory by removal of reference conflicts |
US5933635A (en) * | 1997-10-06 | 1999-08-03 | Sun Microsystems, Inc. | Method and apparatus for dynamically deoptimizing compiled activations |
US5970249A (en) * | 1997-10-06 | 1999-10-19 | Sun Microsystems, Inc. | Method and apparatus for performing byte-code optimization during pauses |
US6079018A (en) * | 1997-10-08 | 2000-06-20 | Agorics, Inc. | System and method for generating unique secure values for digitally signing documents |
GB9721659D0 (en) * | 1997-10-14 | 1997-12-10 | Philips Electronics Nv | Space-limited marking structure for tracing garbage collectors |
US6260077B1 (en) * | 1997-10-24 | 2001-07-10 | Sun Microsystems, Inc. | Method, apparatus and program product for interfacing a multi-threaded, client-based API to a single-threaded, server-based API |
US5966702A (en) | 1997-10-31 | 1999-10-12 | Sun Microsystems, Inc. | Method and apparatus for pre-processing and packaging class files |
JP3377419B2 (ja) * | 1997-11-11 | 2003-02-17 | インターナショナル・ビジネス・マシーンズ・コーポレーション | 命令列生成方法及び装置、変換方法、及びコンピュータ |
US6170083B1 (en) * | 1997-11-12 | 2001-01-02 | Intel Corporation | Method for performing dynamic optimization of computer code |
US6664978B1 (en) * | 1997-11-17 | 2003-12-16 | Fujitsu Limited | Client-server computer network management architecture |
US6175957B1 (en) * | 1997-12-09 | 2001-01-16 | International Business Machines Corporation | Method of, system for, and computer program product for providing efficient utilization of memory hierarchy through code restructuring |
US6108797A (en) * | 1997-12-11 | 2000-08-22 | Winbond Electronics Corp. | Method and system for loading microprograms in partially defective memory |
US6349406B1 (en) * | 1997-12-12 | 2002-02-19 | International Business Machines Coporation | Method and system for compensating for instrumentation overhead in trace data by computing average minimum event times |
US6081665A (en) * | 1997-12-19 | 2000-06-27 | Newmonics Inc. | Method for efficient soft real-time execution of portable byte code computer programs |
US6412105B1 (en) * | 1997-12-31 | 2002-06-25 | Elbrus International Limited | Computer method and apparatus for compilation of multi-way decisions |
US6044403A (en) * | 1997-12-31 | 2000-03-28 | At&T Corp | Network server platform for internet, JAVA server and video application server |
US6141768A (en) * | 1998-03-12 | 2000-10-31 | Winbond Electronics Corp. | Self-corrective memory system and method |
US6658492B1 (en) | 1998-03-20 | 2003-12-02 | Sun Microsystems, Inc. | System and method for reducing the footprint of preloaded classes |
DE69911104T2 (de) * | 1998-03-24 | 2004-07-08 | Sun Microsystems, Inc., Palo Alto | Statische Bindung von dynamisch abgesendeten Anrufen in Anwesenheit von dynamischer Verknüpfung und Ladung |
US6704927B1 (en) * | 1998-03-24 | 2004-03-09 | Sun Microsystems, Inc. | Static binding of dynamically-dispatched calls in the presence of dynamic linking and loading |
US6052739A (en) * | 1998-03-26 | 2000-04-18 | Sun Microsystems, Inc. | Method and apparatus for object-oriented interrupt system |
US6374286B1 (en) * | 1998-04-06 | 2002-04-16 | Rockwell Collins, Inc. | Real time processor capable of concurrently running multiple independent JAVA machines |
US6189141B1 (en) * | 1998-05-04 | 2001-02-13 | Hewlett-Packard Company | Control path evaluating trace designator with dynamically adjustable thresholds for activation of tracing for high (hot) activity and low (cold) activity of flow control |
US6098080A (en) * | 1998-05-05 | 2000-08-01 | International Business Machines Corporation | Computer system, program product and method of collecting interned data with a mark sweep collector |
US6735761B1 (en) * | 1998-05-15 | 2004-05-11 | International Business Machines Corporation | Compile method frame detection method and device code discarding method and computer |
US6209066B1 (en) * | 1998-06-30 | 2001-03-27 | Sun Microsystems, Inc. | Method and apparatus for memory allocation in a multi-threaded virtual machine |
US6205465B1 (en) * | 1998-07-22 | 2001-03-20 | Cisco Technology, Inc. | Component extensible parallel execution of multiple threads assembled from program components specified with partial inter-component sequence information |
JP2002521749A (ja) * | 1998-07-24 | 2002-07-16 | サン・マイクロシステムズ・インコーポレーテッド | コンピュータ・システムにおける決定論的メモリ割り当て応答の達成方法および装置 |
US6327704B1 (en) * | 1998-08-06 | 2001-12-04 | Hewlett-Packard Company | System, method, and product for multi-branch backpatching in a dynamic translator |
DE19843640A1 (de) * | 1998-09-23 | 2000-03-30 | Siemens Ag | Verfahren zum Konfigurieren eines konfigurierbaren Hardware-Blocks |
US6499137B1 (en) * | 1998-10-02 | 2002-12-24 | Microsoft Corporation | Reversible load-time dynamic linking |
US6381735B1 (en) * | 1998-10-02 | 2002-04-30 | Microsoft Corporation | Dynamic classification of sections of software |
US6317756B1 (en) * | 1998-10-07 | 2001-11-13 | International Business Machines Corporation | On-the-fly garbage collector |
US6308318B2 (en) * | 1998-10-07 | 2001-10-23 | Hewlett-Packard Company | Method and apparatus for handling asynchronous exceptions in a dynamic translation system |
US6654953B1 (en) * | 1998-10-09 | 2003-11-25 | Microsoft Corporation | Extending program languages with source-program attribute tags |
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 |
US6625635B1 (en) * | 1998-11-02 | 2003-09-23 | International Business Machines Corporation | Deterministic and preemptive thread scheduling and its use in debugging multithreaded applications |
US6351844B1 (en) * | 1998-11-05 | 2002-02-26 | Hewlett-Packard Company | Method for selecting active code traces for translation in a caching dynamic translator |
GB9825102D0 (en) * | 1998-11-16 | 1999-01-13 | Insignia Solutions Plc | Computer system |
US6463580B1 (en) * | 1998-11-18 | 2002-10-08 | Intel Corporation | Parallel processing utilizing highly correlated data values |
US6412081B1 (en) * | 1999-01-15 | 2002-06-25 | Conexant Systems, Inc. | System and method for providing a trap and patch function to low power, cost conscious, and space constrained applications |
US7111290B1 (en) * | 1999-01-28 | 2006-09-19 | Ati International Srl | Profiling program execution to identify frequently-executed portions and to assist binary translation |
US6338133B1 (en) * | 1999-03-12 | 2002-01-08 | International Business Machines Corporation | Measured, allocation of speculative branch instructions to processor execution units |
US6480862B1 (en) * | 1999-04-23 | 2002-11-12 | International Business Machines Corporation | Relation-based ordering of objects in an object heap |
US6381738B1 (en) * | 1999-07-16 | 2002-04-30 | International Business Machines Corporation | Method for optimizing creation and destruction of objects in computer programs |
US6539396B1 (en) * | 1999-08-31 | 2003-03-25 | Accenture Llp | Multi-object identifier system and method for information service pattern environment |
US6615253B1 (en) * | 1999-08-31 | 2003-09-02 | Accenture Llp | Efficient server side data retrieval for execution of client side applications |
US6529948B1 (en) * | 1999-08-31 | 2003-03-04 | Accenture Llp | Multi-object fetch component |
US6529909B1 (en) * | 1999-08-31 | 2003-03-04 | Accenture Llp | Method for translating an object attribute converter in an information services patterns environment |
US6457111B1 (en) * | 1999-12-14 | 2002-09-24 | International Business Machines Corporation | Method and system for allocation of a persistence indicator for an object in an object-oriented environment |
US6671795B1 (en) * | 2000-01-21 | 2003-12-30 | Intel Corporation | Method and apparatus for pausing execution in a processor or the like |
US6651248B1 (en) * | 2000-09-01 | 2003-11-18 | International Business Machines Corporation | Method and apparatus for efficient interface method dispatch |
-
1998
- 1998-11-16 GB GBGB9825102.8A patent/GB9825102D0/en not_active Ceased
-
1999
- 1999-03-16 JP JP2000582880A patent/JP2003526135A/ja not_active Withdrawn
- 1999-03-16 WO PCT/GB1999/000788 patent/WO2000029937A2/en active IP Right Grant
- 1999-03-16 AU AU28469/99A patent/AU2846999A/en not_active Abandoned
- 1999-03-16 DE DE69939495T patent/DE69939495D1/de not_active Expired - Fee Related
- 1999-03-16 EP EP99909100A patent/EP1208425B1/de not_active Expired - Lifetime
-
2001
- 2001-05-16 US US09/858,827 patent/US7080366B2/en not_active Expired - Lifetime
- 2001-05-16 US US09/859,133 patent/US6862728B2/en not_active Expired - Lifetime
- 2001-05-16 US US09/858,578 patent/US7069549B2/en not_active Expired - Lifetime
- 2001-05-16 US US09/859,134 patent/US7039738B2/en not_active Expired - Lifetime
- 2001-05-16 US US09/859,072 patent/US6901587B2/en not_active Expired - Lifetime
- 2001-05-16 US US09/859,161 patent/US6766513B2/en not_active Expired - Lifetime
- 2001-05-16 US US09/859,162 patent/US6691303B2/en not_active Expired - Lifetime
- 2001-05-16 US US09/858,426 patent/US7007005B2/en not_active Expired - Lifetime
- 2001-05-16 US US09/859,135 patent/US7058929B2/en not_active Expired - Lifetime
- 2001-05-16 US US09/858,826 patent/US6925637B2/en not_active Expired - Lifetime
- 2001-05-16 US US09/859,163 patent/US20020032719A1/en not_active Abandoned
-
2007
- 2007-06-29 US US11/771,629 patent/US8127280B2/en not_active Expired - Fee Related
-
2010
- 2010-07-09 JP JP2010156628A patent/JP4783471B2/ja not_active Expired - Lifetime
-
2012
- 2012-02-03 US US13/365,936 patent/US8631219B2/en not_active Expired - Fee Related
Patent Citations (54)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4675829A (en) * | 1984-07-27 | 1987-06-23 | Intellicorp Corporation | Method and apparatus for building knowledge-based systems |
US5210876A (en) * | 1988-06-06 | 1993-05-11 | Nec Corporation | Method for calling interpreter language procedure from compiler language procedure |
US4924408A (en) * | 1988-08-19 | 1990-05-08 | International Business Machines Corporation | Technique for compilation of knowledge bases |
US5339436A (en) * | 1989-08-31 | 1994-08-16 | Yokogawa Electric Corporation | Method of implementing a relocated compiled library program with an interpreter to control a manufacturing line |
US5301260A (en) * | 1990-08-06 | 1994-04-05 | Matsushita Electric Industrial, Co., Ltd. | Inference processor using data consistency holder |
US5301325A (en) * | 1991-03-07 | 1994-04-05 | Digital Equipment Corporation | Use of stack depth to identify architechture and calling standard dependencies in machine code |
US5450575A (en) * | 1991-03-07 | 1995-09-12 | Digital Equipment Corporation | Use of stack depth to identify machine code mistakes |
US5293614A (en) * | 1991-04-08 | 1994-03-08 | Texas Instruments Incorporated | System and method for hard real-time garbage collection requiring a write barrier but no read barrier |
US5598561A (en) * | 1991-07-25 | 1997-01-28 | Nec Corporation | Optimizing compiler which generates multiple instruction streams to be executed in parallel |
US5815501A (en) * | 1992-06-05 | 1998-09-29 | Washington University | ATM-ethernet portal/concentrator |
US5442792A (en) * | 1992-08-07 | 1995-08-15 | Hughes Aircraft Company | Expert system compilation method |
US5367685A (en) * | 1992-12-22 | 1994-11-22 | Firstperson, Inc. | Method and apparatus for resolving data references in generated code |
US5603030A (en) * | 1993-01-07 | 1997-02-11 | Microsoft Corporation | Method and system for destruction of objects using multiple destructor functions in an object-oriented computer system |
US5530964A (en) * | 1993-01-29 | 1996-06-25 | International Business Machines Corporation | Optimizing assembled code for execution using execution statistics collection, without inserting instructions in the code and reorganizing the code based on the statistics collected |
US5452457A (en) * | 1993-01-29 | 1995-09-19 | International Business Machines Corporation | Program construct and methods/systems for optimizing assembled code for execution |
US5632034A (en) * | 1993-06-01 | 1997-05-20 | International Business Machines Corporation | Controlling method invocation sequence through virtual functions in an object-oriented class library |
US5551040A (en) * | 1993-06-02 | 1996-08-27 | Lucent Technologies Inc. | Methods and apparatus for specifying the contexts of names in callback-style programming |
US5469574A (en) * | 1993-06-18 | 1995-11-21 | International Business Machines Corporation | Method and system for interfacing interpreted applications with compiled procedures using signature files |
US5892944A (en) * | 1993-07-20 | 1999-04-06 | Kabushiki Kaisha Toshiba | Program execution and operation right management system suitable for single virtual memory scheme |
US5721854A (en) * | 1993-11-02 | 1998-02-24 | International Business Machines Corporation | Method and apparatus for dynamic conversion of computer instructions |
US6845385B1 (en) * | 1994-07-13 | 2005-01-18 | Object Technology Licensing Corp. | Real-time computer “garbage collector” |
US5613120A (en) * | 1994-10-20 | 1997-03-18 | Silicon Graphics, Inc. | System and method for enabling, without recompilation, modification of class definitions and implementations in an object-oriented computer program |
US5590332A (en) * | 1995-01-13 | 1996-12-31 | Baker; Henry G. | Garbage collection, tail recursion and first-class continuations in stack-oriented languages |
US5953530A (en) * | 1995-02-07 | 1999-09-14 | Sun Microsystems, Inc. | Method and apparatus for run-time memory access checking and memory leak detection of a multi-threaded program |
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 |
US5835771A (en) * | 1995-06-07 | 1998-11-10 | Rogue Wave Software, Inc. | Method and apparatus for generating inline code using template metaprograms |
US5675804A (en) * | 1995-08-31 | 1997-10-07 | International Business Machines Corporation | System and method for enabling a compiled computer program to invoke an interpretive computer program |
US5872978A (en) * | 1995-12-21 | 1999-02-16 | U.S. Philips Corporation | Method and apparatus for improved translation of program data into machine code format |
US5764989A (en) * | 1996-02-29 | 1998-06-09 | Supercede, Inc. | Interactive software development system |
US5848274A (en) * | 1996-02-29 | 1998-12-08 | Supercede, Inc. | Incremental byte code compilation system |
US5815720A (en) * | 1996-03-15 | 1998-09-29 | Institute For The Development Of Emerging Architectures, L.L.C. | Use of dynamic translation to collect and exploit run-time information in an optimizing compilation system |
US5761513A (en) * | 1996-07-01 | 1998-06-02 | Sun Microsystems, Inc. | System and method for exception handling in dynamically linked programs |
US5835958A (en) * | 1996-10-29 | 1998-11-10 | Sun Microsystems, Inc. | Method and apparatus for dynamically sizing non-contiguous runtime stacks |
US5857104A (en) * | 1996-11-26 | 1999-01-05 | Hewlett-Packard Company | Synthetic dynamic branch prediction |
US5950221A (en) * | 1997-02-06 | 1999-09-07 | Microsoft Corporation | Variably-sized kernel memory stacks |
US6175916B1 (en) * | 1997-05-06 | 2001-01-16 | Microsoft Corporation | Common-thread inter-process function calls invoked by jumps to invalid addresses |
US5842016A (en) * | 1997-05-29 | 1998-11-24 | Microsoft Corporation | Thread synchronization in a garbage-collected system using execution barriers |
US6199075B1 (en) * | 1997-05-30 | 2001-03-06 | Sun Microsystems, Inc. | Method and apparatus for generational garbage collection of a heap memory shared by multiple processors |
US6138210A (en) * | 1997-06-23 | 2000-10-24 | Sun Microsystems, Inc. | Multi-stack memory architecture |
US5873105A (en) * | 1997-06-26 | 1999-02-16 | Sun Microsystems, Inc. | Bounded-pause time garbage collection system and method including write barrier associated with a source instance of a partially relocated object |
US5873104A (en) * | 1997-06-26 | 1999-02-16 | Sun Microsystems, Inc. | Bounded-pause time garbage collection system and method including write barrier associated with source and target instances of a partially relocated object |
US6304949B1 (en) * | 1997-08-22 | 2001-10-16 | U.S. Philips Corporation | Data processor with localized memory reclamation |
US20010039609A1 (en) * | 1997-08-22 | 2001-11-08 | Koninklijke Philips Electronics N.V. | Data processor with localised memory reclamation |
US6389540B1 (en) * | 1998-02-26 | 2002-05-14 | Sun Microsystems, Inc. | Stack based access control using code and executor identifiers |
US6148391A (en) * | 1998-03-26 | 2000-11-14 | Sun Microsystems, Inc. | System for simultaneously accessing one or more stack elements by multiple functional units using real stack addresses |
US6047295A (en) * | 1998-05-05 | 2000-04-04 | International Business Machines Corporation | Computer system, program product and method of managing weak references with a concurrent mark sweep collector |
US6223202B1 (en) * | 1998-06-05 | 2001-04-24 | International Business Machines Corp. | Virtual machine pooling |
US6253215B1 (en) * | 1998-08-17 | 2001-06-26 | Sun Microsystems | Method, apparatus, and article of manufacture for facilitating resource management for applications having two types of program code |
US6269425B1 (en) * | 1998-08-20 | 2001-07-31 | International Business Machines Corporation | Accessing data from a multiple entry fully associative cache buffer in a multithread data processing system |
US20010013117A1 (en) * | 1998-09-15 | 2001-08-09 | David Ungar | Method and apparatus for finding bugs related to garbage collection in a virtual machine |
US6353829B1 (en) * | 1998-12-23 | 2002-03-05 | Cray Inc. | Method and system for memory allocation in a multiprocessing environment |
US6317816B1 (en) * | 1999-01-29 | 2001-11-13 | International Business Machines Corporation | Multiprocessor scaleable system and method for allocating memory from a heap |
US6629113B1 (en) * | 1999-06-30 | 2003-09-30 | International Business Machines Corporation | Method and system for dynamically adjustable and configurable garbage collector |
US20040039758A1 (en) * | 2002-08-22 | 2004-02-26 | Xiaofeng Li | Methods and apparatus for concurrent enumeration of an object reference root set |
Cited By (59)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7096238B2 (en) | 1999-08-19 | 2006-08-22 | Sun Microsystems, Inc. | Dynamic feedback for determining collection-set size |
US20060090063A1 (en) * | 2002-06-24 | 2006-04-27 | Jean-Paul Theis | Method for executing structured symbolic machine code on a microprocessor |
US6999980B2 (en) * | 2002-08-23 | 2006-02-14 | Sun Microsystems, Inc. | Eliminating write barriers for young objects |
US20040039759A1 (en) * | 2002-08-23 | 2004-02-26 | Detlefs David L. | Eliminating write barriers for young objects |
US20040088277A1 (en) * | 2002-11-05 | 2004-05-06 | Garthwaite Alexander T. | Placement of allocation trains in the train algorithm |
US20040088339A1 (en) * | 2002-11-05 | 2004-05-06 | Garthwaite Alexander T. | Efficient encoding of references into a collection set |
US7539713B2 (en) | 2002-11-05 | 2009-05-26 | Sun Microsystems, Inc. | Allocation of likely popular objects in the train algorithm |
US7188129B2 (en) | 2002-11-15 | 2007-03-06 | Sun Microsystems, Inc. | Merging trains in a collector based on the train algorithm |
US7209935B2 (en) | 2002-11-27 | 2007-04-24 | Sun Microsystems, Inc. | Avoiding remembered-set maintenance overhead for memory segments known to be in a collection set |
US20040103126A1 (en) * | 2002-11-27 | 2004-05-27 | Garthwaite Alexander T. | Avoiding remembered-set maintenance overhead for memory segments known to be in a collection set |
US7143124B2 (en) | 2002-12-06 | 2006-11-28 | Sun Microsystems, Inc. | Detection of dead regions during incremental collection |
US7069280B2 (en) | 2002-12-06 | 2006-06-27 | Sun Microsystems, Inc. | Collection-tick mechanism for a collector based on the train algorithm |
US20040111450A1 (en) * | 2002-12-06 | 2004-06-10 | Garthwaite Alexander T. | Better placement of objects reachable from special objects during collection based on the train algorithm |
US20040111444A1 (en) * | 2002-12-06 | 2004-06-10 | Garthwaite Alexander T. | Advancing cars in trains managed by a collector based on the train algorithm |
US7031990B2 (en) | 2002-12-06 | 2006-04-18 | Sun Microsystems, Inc. | Combining external and intragenerational reference-processing in a garbage collector based on the train algorithm |
US7085790B2 (en) | 2002-12-06 | 2006-08-01 | Sun Microsystems, Inc. | Advancing cars in trains managed by a collector based on the train algorithm |
US7146390B2 (en) | 2003-02-24 | 2006-12-05 | Sun Microsystems, Inc. | Staging the processing of remembered-set entries as part of collection based on the train algorithm |
US7069281B2 (en) | 2003-02-24 | 2006-06-27 | Sun Microsystems, Inc. | Efficient collocation of evacuated objects in a copying garbage collector using variably filled local allocation buffers |
US7062519B2 (en) | 2003-02-27 | 2006-06-13 | Sun Microsystems, Inc. | Incremental scanning of enormous objects to improve scheduling and pause-time behavior of garbage collection |
US20040172507A1 (en) * | 2003-02-27 | 2004-09-02 | Garthwaite Alexander T. | Better placement of objects promoted into a generation managed by the train algorithm |
US20040199556A1 (en) * | 2003-02-27 | 2004-10-07 | Garthwaite Alexander T. | Incremental scanning of enormous objects to improve scheduling and pause-time behavior of garbage collection |
US20040186863A1 (en) * | 2003-03-21 | 2004-09-23 | Garthwaite Alexander T. | Elision of write barriers for stores whose values are in close proximity |
US7080172B1 (en) | 2003-05-27 | 2006-07-18 | Marvell Luternational Ltd. | Management of memory, hardware and associated device drivers using stacks |
US7089272B1 (en) | 2003-06-18 | 2006-08-08 | Sun Microsystems, Inc. | Specializing write-barriers for objects in a garbage collected heap |
US7149762B1 (en) | 2003-08-20 | 2006-12-12 | Sun Microsystems, Inc. | Handling futile collections in the train algorithm through selective extension of the collection set |
US20050050135A1 (en) * | 2003-08-25 | 2005-03-03 | Josef Hallermeier | Handheld digital multimedia workstation and method |
US7404182B1 (en) | 2003-10-03 | 2008-07-22 | Sun Microsystems, Inc. | Deferring and combining write barriers for a garbage-collected heap |
US20050149585A1 (en) * | 2004-01-05 | 2005-07-07 | International Business Machines Corporation | Method and apparatus for scheduling and performing garbage collection in a real-time system with guaranteed space bounds |
US7996446B2 (en) * | 2004-01-05 | 2011-08-09 | International Business Machines Corporation | Scheduling and performing garbage collection in a real-time system with guaranteed space bounds |
US20090300086A1 (en) * | 2004-01-05 | 2009-12-03 | International Business Machines Corporation | Scheduling and performing garbage collection in a real-time system with guaranteed space bounds |
US7624137B2 (en) * | 2004-01-05 | 2009-11-24 | International Business Machines Corporation | Method and apparatus for scheduling and performing garbage collection in a real-time system with guaranteed space bounds |
US7620943B1 (en) | 2004-06-30 | 2009-11-17 | Sun Microsystems, Inc. | Using class properties to segregate objects in a generation managed by the train algorithm |
US7752610B2 (en) | 2004-07-27 | 2010-07-06 | Texas Instruments Incorporated | Method and system for thread abstraction |
US20060026565A1 (en) * | 2004-07-27 | 2006-02-02 | Texas Instruments Incorporated | Method and system for implementing an interrupt handler |
US20060026566A1 (en) * | 2004-07-27 | 2006-02-02 | Texas Instruments Incorporated | Method and system for thread abstraction |
US7743384B2 (en) * | 2004-07-27 | 2010-06-22 | Texas Instruments Incorporated | Method and system for implementing an interrupt handler |
US7676801B1 (en) | 2004-08-31 | 2010-03-09 | Sun Microsystems, Inc. | Scanning of evacuated objects in a generation managed by the train algorithm |
US7321909B1 (en) | 2004-12-23 | 2008-01-22 | Sun Microsystems, Inc. | Method and apparatus for forwarding references to objects concurrently with space-incremental garbage collection |
US20060206901A1 (en) * | 2005-03-08 | 2006-09-14 | Oracle International Corporation | Method and system for deadlock detection in a distributed environment |
US7735089B2 (en) * | 2005-03-08 | 2010-06-08 | Oracle International Corporation | Method and system for deadlock detection in a distributed environment |
US20140330781A1 (en) * | 2005-06-29 | 2014-11-06 | Cisco Technology, Inc. | Parallel Filesystem Traversal For Transparent Mirroring of Directories and Files |
US20100293553A1 (en) * | 2005-08-30 | 2010-11-18 | Alexey Kukanov | Fair scalable reader-writer mutual exclusion |
US20070067774A1 (en) * | 2005-08-30 | 2007-03-22 | Alexey Kukanov | Fair scalable reader-writer mutual exclusion |
US7730491B2 (en) * | 2005-08-30 | 2010-06-01 | Intel Corporation | Fair scalable reader-writer mutual exclusion |
US8127303B2 (en) | 2005-08-30 | 2012-02-28 | Intel Corporation | Fair scalable reader-writer mutual exclusion |
US8707324B2 (en) | 2005-08-30 | 2014-04-22 | Intel Corporation | Fair scalable reader-writer mutual exclusion |
US7533236B1 (en) * | 2006-05-11 | 2009-05-12 | Nvidia Corporation | Off-chip out of order memory allocation for a unified shader |
US7533237B1 (en) * | 2006-05-11 | 2009-05-12 | Nvidia Corporation | Off-chip memory allocation for a unified shader |
US7739473B1 (en) | 2006-05-11 | 2010-06-15 | Nvidia Corporation | Off-chip memory allocation for a unified shader |
US8407443B1 (en) | 2006-05-11 | 2013-03-26 | Nvidia Corporation | Off-chip out of order memory allocation for a unified shader |
US8566812B1 (en) * | 2006-08-31 | 2013-10-22 | Oracle America, Inc. | Using observed object patterns to dynamically tune a virtual machine for responsiveness |
US8578347B1 (en) * | 2006-12-28 | 2013-11-05 | The Mathworks, Inc. | Determining stack usage of generated code from a model |
US20090063595A1 (en) * | 2007-09-05 | 2009-03-05 | Mark Graham Stoodley | Method and apparatus for updating references to objects in a garbage collection operation |
US20090210379A1 (en) * | 2008-02-14 | 2009-08-20 | Sun Microsystems, Inc. | Dynamic multiple inheritance method dispatch and type extension testing by frugal perfect hashing |
US7925640B2 (en) * | 2008-02-14 | 2011-04-12 | Oracle America, Inc. | Dynamic multiple inheritance method dispatch data structure including an m-table size, i-table containing one or more holder addressor regions and type extension testing by frugal perfect hashing |
US20110225213A1 (en) * | 2010-03-10 | 2011-09-15 | Microsoft Corporation | Loop control flow diversion |
US8887142B2 (en) * | 2010-03-10 | 2014-11-11 | Microsoft Corporation | Loop control flow diversion |
US8856761B2 (en) | 2011-03-18 | 2014-10-07 | Fujitsu Limited | Instruction processing method, instruction processing apparatus, and instruction processing program |
US11537429B2 (en) * | 2019-12-19 | 2022-12-27 | Red Hat, Inc. | Sub-idle thread priority class |
Also Published As
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US7007005B2 (en) | Method and structure for reducing search times | |
US6966057B2 (en) | Static compilation of instrumentation code for debugging support | |
US6093216A (en) | Method of run-time tracking of object references in Java programs | |
US6968546B2 (en) | Debugging support using dynamic re-compilation | |
US6463582B1 (en) | Dynamic optimizing object code translator for architecture emulation and dynamic optimizing object code translation method | |
US6199095B1 (en) | System and method for achieving object method transparency in a multi-code execution environment | |
US20040255279A1 (en) | Block translation optimizations for program code conversation | |
JP2002527811A (ja) | オンスタックリプレースメントを伴うことなくバーチャルコールを直接にインライン化する方法 | |
US6931638B2 (en) | Method and apparatus to facilitate sharing optimized instruction code in a multitasking virtual machine | |
KR100577366B1 (ko) | 이종의 자바 메소드를 실행하는 방법 및 장치 | |
US7496897B1 (en) | Multiple code sets for multiple execution contexts | |
Pollack et al. | Supporting Ada memory management in the iAPX-432 | |
Siebert et al. | Deterministic execution of Java's primitive bytecode operations | |
Shivkumar et al. | Real-time MLton: A Standard ML runtime for real-time functional programs | |
Duvvuru | Monaco: a high performance implementation of FGHC on shared-memory multiprocessors | |
Reig Galilea | Compiler architecture using a portable intermediate language | |
Win32 et al. | 2 Java ME Virtual Machines | |
Deacon | A Generic Approach to Object Migration using Specialised Methods | |
Sargeant et al. | Exploiting implicit parallelism in functional programs with SLAM |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: INSIGNIA SOLUTIONS, PLC, UNITED KINGDOM Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:THOMAS, STEPHEN PAUL;CHARNELL, WILLIAM THOMAS;DARNELL, STEPHEN;AND OTHERS;REEL/FRAME:012093/0225 Effective date: 20010731 |
|
AS | Assignment |
Owner name: INSIGNIA SOLUTIONS, PLC, UNITED KINGDOM Free format text: THIS IS A CORRECTION TO THE ADDRESS OF THE ASSIGNEE. IT SHOULD READ WOOBURN NOT WOOBUN.;ASSIGNORS:THOMAS, STEPHEN PAUL;CHARNELL, WILLIAM THOMAS;DARNELL, STEPHEN;AND OTHERS;REEL/FRAME:012339/0938 Effective date: 20010731 |
|
AS | Assignment |
Owner name: ESMERTEC AG, SWITZERLAND Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:INSIGNIA SOLUTIONS, PLC;REEL/FRAME:014250/0761 Effective date: 20030703 |
|
AS | Assignment |
Owner name: ESMERTEC AG, SWITZERLAND Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:INSIGNIA SOLUTIONS, INC.;REEL/FRAME:014852/0297 Effective date: 20031217 |
|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION |
|
AS | Assignment |
Owner name: RPX CORPORATION, CALIFORNIA Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MYRIAD GROUP, AG;REEL/FRAME:044087/0323 Effective date: 20170927 |