Class / Patent application number | Description | Number of patent applications / Date published |
717145000 | Including recompilation | 21 |
20080276231 | METHOD AND APPARATUS FOR DEPENDENCY INJECTION BY STATIC CODE GENERATION - The illustrative embodiments provide a computer implemented method and apparatus for dependency injection by static transformation. Information about a first software module among several software modules is identified. The first software module has a dependency on at least one other software module among the several software modules. Information about the dependency of the first software module on at least one other software module is identified. Using the information about the first software module and the information about the dependency, code is generated for the first software module to resolve the dependency. | 11-06-2008 |
20080320456 | Targeted patching - Various technologies and techniques are disclosed that provides targeted patching for native generation images. Changed binaries are updated with information that indicates whether or not they contain safe changes. A servicing process can then be provided for a client machine. For any compatible binaries with changes that have been identified as safe, a native generation update is performed that includes recompilation of the compatible binaries with the safe changes, and an updating of binding information for any dependent binaries. For any non-compatible binaries with changes that have been identified as unsafe, a native generation update is performed that includes recompilation of any non-compatible binaries and any dependent binaries. | 12-25-2008 |
20090119651 | SYSTEM AND METHOD FOR DIRECTING RECOMPILATION OF A CLASS WITH A JAVA STATIC VARIABLE - A system and associated method for directing to recompile a class with a static variable of the class in a Java platform are disclosed. The class is defined with at least two implementations that are selectively compiled and executed a value of the static variable. The value of the static variable of the class is modified to a new value depending on characteristics of a runtime environment in which the method is executed. The class is recompiled and the new value is set for the static variable of the class. A debugger performs a hot code replacement of the class with the recompiled class. | 05-07-2009 |
20090193402 | Iterative Compilation Supporting Entity Instance-Specific Compiler Option Variations - Optimizing a computer program by setting a first compiler optimization configuration for a first entity of a computer program, setting a second compiler optimization configuration for a second entity of the computer program, where the first and second entities are of the same type and where the first and second compiler optimization configurations differ, and compiling the computer program in accordance with the compiler optimization configurations, thereby creating a compiled program. | 07-30-2009 |
20090241097 | METHOD AND APPARATUS TO IMPROVE EXECUTION OF A STORED PROGRAM - In one embodiment, the invention provides a method comprising determining metadata encoded in instructions of a stored program; and executing the stored program based on the metadata. | 09-24-2009 |
20090249316 | COMBINING STATIC AND DYNAMIC COMPILATION TO REMOVE DELINQUENT LOADS - A method for combined static and dynamic compilation of program code to remove delinquent loads can include statically compiling source code into executable code with instrumented sections each being suspected of including a delinquent load, and also into a separate intermediate language representation with annotated portions each corresponding to one of the instrumented sections. The method also can include executing the instrumented sections repeatedly and monitoring cache misses for each execution. Finally, the method can include dynamically recompiling selected ones of the instrumented sections using corresponding ones of the annotated portions of the separate intermediate language representation only after a threshold number of executions of the selected ones of the instrumented sections, each recompilation include a pre-fetch directive at a pre-fetch distances tuned to avoid the delinquent load. | 10-01-2009 |
20090271772 | Using hardware interrupts to drive dynamic binary code recompilation - A method, computer system, and computer program product for using one or more hardware interrupts to drive dynamic binary code recompilation. The execution of a plurality of instructions is monitored to detect a problematic instruction. In response to detecting the problematic instruction, a hardware interrupt is thrown to a dynamic interrupt handler. A determination is made whether a threshold for dynamic binary code recompilation is satisfied. If the threshold for dynamic code recompilation is satisfied, the dynamic interrupt handler optimizes at least one of the plurality of instructions. | 10-29-2009 |
20100005457 | METHOD OF REDUCING LOGGING CODE IN A COMPUTING SYSTEM - A computing system for reducing logging code includes a virtual machine configured to control the flow of operations in the computing system and a compiler configured to receive bytecode instructions from the virtual machine and convert the bytecode instructions into machine instructions. The computing system also includes a compilation store configured to receive and store the machine instructions from the compiler and a recompilation store configured to receive and store recompiled machine instructions from the compiler. The system also includes a software transactional memory engine configured to receive instructions from the compilation store or, in the event that the recompilation store has recompiled machine instructions stored therein, from the recompilation store. | 01-07-2010 |
20100333078 | PACKAGING SYSTEM FOR CUSTOMIZING SOFTWARE - In one embodiment, a system for customizing executable software code is provided. The system can include a scan logic configured to scan the executable software code to determine an execution trigger point in the executable software code. A packager logic can be configured to alter the execution trigger point by embedding, into the executable software code, alternative code configured to cause a customized logic to execute at the execution trigger point. | 12-30-2010 |
20110131558 | LINK-TIME RESOURCE ALLOCATION FOR A MULTI-THREADED PROCESSOR ARCHITECTURE - A method comprising: independently compiling a plurality of modules of source code to generate a plurality of respective object modules comprising a plurality of respective parallel threads explicitly designated by a user to be executed in parallel on a target platform; in each of the object modules, inserting at least one symbol indicative of a usage of a resource of the target platform associated with the respective thread; executing a linker to perform a linking process for linking the object modules, wherein the linking process comprises assessing the symbols in conjunction with one another, and based on the assessment generating an indication relating to a usage of the resource required for execution of the threads in parallel. | 06-02-2011 |
20110131559 | COMPILING AND LINKING - A method of generating a computer program, the method comprising: independently compiling a plurality of source code modules to generate a plurality of respective object modules comprising a plurality of respective threads explicitly designated by a user to be executed in parallel; in each of the object modules, inserting at least one symbol indicative of a property of the object module's thread potentially conflicting with a corresponding property of a thread of another of said object module as a result of parallel execution of those threads; executing a linker to perform a linking process on said object modules, the linking process comprising: assessing the symbols in conjunction with one another to determine whether a conflict exists between the threads of two or more of the respective object modules; and linking the object modules to generate a computer program in which said threads are executable in parallel, wherein the linking is performed in dependence on said assessment. | 06-02-2011 |
20110225571 | STRUCTURAL ANALYSER - A method and corresponding tool, the method comprising: generating a lower-level control flow structure representing a portion of an executable program, the lower-level control flow structure comprising a plurality of lower-level nodes representing operations occurring within the program and a plurality of directional edges representing program flow between nodes; generating a higher-level control flow structure by matching a plurality of the lower-level nodes and edges to higher-level structure nodes representing internal structure, each higher-level structure node representing a group of one or more lower-level nodes and one or more associated edges; and using the higher-level control flow structure to estimate a timing property relating to execution of the program on a processor. The higher-level structure nodes are selected exclusively from a predetermined set of structure node patterns, each pattern in the set having at most one entry point and at most one exit point. | 09-15-2011 |
20120227034 | INCREMENTAL GENERATION OF MANAGED ASSEMBLIES - Concepts and technologies are described herein for incremental generation of managed assemblies. In accordance with some of the concepts and technologies disclosed herein, a compiler incrementally generates a managed assembly thereby facilitating a rapid application development environment in which changes to the assembly require recompilation of only a changed portion of the assembly instead of recompilation of the entire assembly. | 09-06-2012 |
20130031535 | PROCESSING TABLE OF CONTENT ACCESS OVERFLOW IN AN APPLICATION - The present disclosure provides a method and system for processing table of content (TOC) access overflow in an application. The method may determine whether there occurs a TOC access overflow within an object file during linking the object file that may be generated from the compiling. If the TOC access overflow occurs within the object file, then the source file corresponding to the object file may be re-compiled so as to generate an object file having no TOC access overflow, and the object file may be re-linked to generate an executable file of the application. The present disclosure may adopt two-pass compiling and a dual-instruction TOC access in a form of two pieces of instructions that may be generated for TOC entries within which TOC overflows generally occur. | 01-31-2013 |
20130086564 | METHODS AND SYSTEMS FOR OPTIMIZING EXECUTION OF A PROGRAM IN AN ENVIRONMENT HAVING SIMULTANEOUSLY PARALLEL AND SERIAL PROCESSING CAPABILITY - An automated method of optimizing execution of a program in a parallel processing environment is disclosed. The program has a plurality of threads and is executable in parallel and serial hardware. The method includes receiving the program at an optimizer and compiling the program to execute in parallel hardware. The execution of the program is observed by the optimizer to identify a subset of memory operations that execute more efficiently on serial hardware than parallel hardware. A subset of memory operations that execute more efficiently on parallel hardware than serial hardware are identified. The program is recompiled so that threads that include memory operations that execute more efficiently on serial hardware than parallel hardware are compiled for serial hardware, and threads that include memory operations that execute more efficiently on parallel hardware than serial hardware are compiled for parallel hardware. Subsequent execution of the program occurs using the recompiled program. | 04-04-2013 |
20140047420 | Value Profiling for Code Optimization - A method and an apparatus to execute a code with value profiling are described. The code may include an access to an untyped variable. During the execution, runtime values of the untyped variable may be randomly inspected. A value profile may be established to predict one or more expected types of future runtime values for the untyped variable. The code may be recompiled according to the value profile to optimize the access of the untyped variable for the future runtime values. | 02-13-2014 |
20140282446 | MODIFICATION OF COMPILED APPLICATIONS AND APPLICATION MANAGEMENT USING RETRIEVABLE POLICIES - A multi-component control technique includes a first component and a second component. The first component is supplemental code or evaluation engine as specified by a modification to a set of received originally compiled executable code. The modification to the original executable code ensures that, upon execution, the supplemental code (such as an evaluation engine) as specified by the modification is executed upon initial instantiation or use of the application. The second component is a retrievable and executable policy such as a set of rules fetched and used by the supplemental code to control the functionality supported by the originally compiled executable code of the corresponding application. An application administrator can produce the retrievable policy to control functionality of the originally compiled executable code. | 09-18-2014 |
20150370544 | METHODS FOR FACILITATING PERSISTENT STORAGE OF IN-MEMORY DATABASES AND DEVICES THEREOF - A method, non-transitory computer readable medium, and application host computing device that parses assembly language code to identify a transaction block including an assignment to a memory location, the assembly language code associated with an application and output by a compiler. The assembly language code is modified to insert an invocation of a plurality of functions collectively configured to facilitate persistent storage of one or more data updates associated with the assignment at run-time. The assembly language code is assembled to generate object code and the object code is linked with at least a run-time library including a definition for each of the plurality of inserted functions to generate an executable file for the application. | 12-24-2015 |
20160092181 | AUTOMATIC SOURCE CODE GENERATION FOR ACCELERATED FUNCTION CALLS - A programming model for a processor accelerator allows accelerated functions to be called from a main program directly without a management API for the accelerator. A compiler automatically generates wrapper source code for each accelerator function called by the application source code. The wrapper code is compiled, together with the accelerator source code, to generate an object file that is linked to an object file for the main program. By automatically generating the wrapper code, a programmer can simply and directly invoke accelerator functions without the use of a complex management API. In addition, because the wrapper code for the accelerator is generated automatically, a standard compiler can be used to compile the main program, using standard linkage conventions. | 03-31-2016 |
20160124725 | IDENTIFYING IMPROVEMENTS TO MEMORY USAGE OF SOFTWARE PROGRAMS - The disclosed embodiments provide a system that facilitates the execution of a software program. During operation, the system determines a structure of a software program and an execution context for the software program from a set of possible execution contexts for the software program, wherein the software program includes one or more object instances. Next, the system uses the structure and the execution context to identify a portion of an object instance from the one or more object instances that is determined to inefficiently use memory space in the software program. The system then provides a refactoring of the object instance that reduces use of the memory space in the object instance. | 05-05-2016 |
20160188352 | SYSTEM AND METHOD FOR COMPILER SUPPORT FOR COMPILE TIME CUSTOMIZATION OF CODE - A system and method for processing source code for compilation. The method includes accessing a portion of host source code and determining whether the portion of the host source code comprises a device lambda expression. The method further includes in response to the portion of host code comprising the device lambda expression, determining a unique placeholder type instantiation based on the device lambda expression and modifying the device lambda expression based on the unique placeholder type instantiation to produce modified host source code. The method further includes sending the modified host source code to a host compiler. | 06-30-2016 |