Inventors list

Assignees list

Classification tree browser

Top 100 Inventors

Top 100 Assignees


Subclass of:

717 - Data processing: software development, installation, and management


717136000 - Translation of code

717140000 - Compiling code

Patent class list (only not empty are listed)

Deeper subclasses:

Class / Patent application numberDescriptionNumber of patent applications / Date published
717154000 Including analysis of program 143
717159000 Code restructuring 74
717153000 Dynamic (i.e., machine or object level) 33
717152000 Static (source or intermediate level) 12
20110191759Interactive Capacity Planning - Techniques for performing capacity planning for applications running on a computational infrastructure are provided. The techniques include instrumenting an application under development to receive one or more performance metrics under a physical deployment plan, receiving the one or more performance metrics from the computational infrastructure hosting one or more applications that are currently running, using a predictive inference engine to determine how the application under development can be deployed, and using the determination to perform capacity planning for the applications on the computational infrastructure.08-04-2011
20110191758Optimized Memory Allocator By Analyzing Runtime Statistics - A computer readable storage medium including a set of instructions executable by a processor. The set of instructions operable to determine memory allocation parameters for a program executing using a standard memory allocation routine, create an optimized memory allocation routine based on the memory allocation parameters and execute the program using the optimized memory allocation routine.08-04-2011
20090193405Method and apparatus for partitioning programs to balance memory latency - A method of compiling code that includes partitioning instructions in the code among a plurality of processors based on memory access latency associated with the instructions is disclosed. According to one aspect of the invention, partitioning instructions includes partitioning memory access dependence chains. Other embodiments are described and claimed.07-30-2009
20130086567Execution trace trunction - An execution trace of building blocks of computer code includes a head building block at which the execution trace starts, and a tail building block at which the execution trace ends. The building blocks are executable in a sequence from the head building block to the tail building block. The execution trace is truncated at a particular building block of the execution trace, which becomes the tail building block. The particular building block can correspond to a head building block of an additional execution trace, and/or to a loop header building block of a loop within the execution trace and at which the loop is entered. The execution trace is a compilation unit on which basis a trace-based compiler computer program generates an executable version of the code at least by compiling these units.04-04-2013
20110202909TIER SPLITTING FOR OCCASIONALLY CONNECTED DISTRIBUTED APPLICATIONS - Distributed programming is aided by tier splitting single-tier applications into multi-tier applications. Computations and persistent data are split across tiers to generate offlineable or occasionally connected distributed applications. More specifically, computations are divided amongst tiers while preserving the semantics of a single-tier application, and upstream-tier resident data and changes thereto are replicated downstream to facilitate offline work.08-18-2011
20100042982OPTIMIZATION OF IMPERATIVE IMPLEMENTATION OF COMPOSITIONAL CONTENT - Compositional program content is compiled to statements of an imperative application interface in manners that optimize execution and/or resource utilization, among other things. In one instance, a constructor is employed in a manner that obviates a need for extensive memory allocation and parameter copying. Names and namespaces are also cached to avoid expensive table lookup, and redundant namespace declarations are removed and/or moved statically and/or dynamically.02-18-2010
20110010696DUPLICATE VIRTUAL FUNCTION TABLE REMOVAL - One or more embodiments of the present invention relate to a method for duplicate virtual function table removal. The method includes identifying, using a processor of a computer, a first virtual function table formed when a first source code is compiled into a first object code. The method further includes using the processor, identifying a second virtual function table formed when a second source code is compiled into a second object code. The method further includes, independent of linking the first object code to a first executable binary code and the second object code to a second executable binary code, identifying, using the processor, that the first virtual function table and the second virtual function table are identical and, using the processor, deleting the second virtual function table.01-13-2011
20130061214PROGRAMMABLE INTELLIGENT STORAGE ARCHITECTURE BASED ON APPLICATION AND BUSINESS REQUIREMENTS - An Infrastructure Description Language (IDL) includes Service Level Hints (SLHs) and Service Level Requirements (SLRs). The SLHs and SLRs are used to configure at least one hardware resource in a computing system having an intelligent configurator to broker a hardware configuration based on the SLHs and SLRs.03-07-2013
20090271775Optimizing Just-In-Time Compiling For A Java Application Executing On A Compute Node - Methods, systems, and products are disclosed for optimizing just-in-time (‘JIT’) compiling for a Java application executing on a compute node, the compute node having installed upon it a Java Virtual Machine (‘JVM’) capable of supporting the Java application, that include: identifying, by an application manager, a particular portion of the Java application; assigning, by the application manager, a JIT level to the particular portion of the Java application; and jitting, by the JVM installed on the compute node, the particular portion of the Java application in dependence upon the JIT level assigned to that particular portion of the Java application.10-29-2009
20130067444RECONFIGURABLE PROCESSOR, AND APPARATUS AND METHOD FOR CONVERTING CODE THEREOF - An apparatus and method are provided to minimize an overhead caused by mode conversion by processing parts that cannot be subject to software pipelining. A processor is configured to execute code including a first part that is able to be subject to software pipelining in the code, and a second part that is disable to be subject to software pipelining in the code, the second part including a data part and a control part. The processor is further configured to execute the first part, and the data part of the second part in a first execution mode, and to execute the control part of the second part in a second execution mode. When the first part and the data part, the data part and the first part, or different data parts are successively executed, the processor processes the code in the first execution mode without entering the second execution mode.03-14-2013
20120272224INLINE FUNCTION LINKING - In general, techniques are described for performing a form of inline dead code elimination. An apparatus comprising a storage unit and a processor may implement these techniques. The storage unit stores two source files and a destination file. The processor copies a first one of the source files to the destination file. This first source file includes a reference to a portion of a second one of the source files. The processor then evaluates the destination file to determine whether the portion of the second source file referenced in the first source file is used by the destination file. Based on the determination that the portion of the second source file referenced in the first source file is used by the destination file, the processor selectively copies the portion of the second source file to the destination file to generate an updated destination file.10-25-2012
20090320008Sharing Compiler Optimizations in a Multi-Node System - Embodiments of the invention enable application programs running across multiple compute nodes of a highly-parallel system to compile source code into native instructions, and subsequently share the optimizations used to compile the source code with other nodes. For example, determining what optimizations to use may consume significant processing power and memory on a node. In cases where multiple nodes exhibit similar characteristics, it is possible that these nodes may use the same set of optimizations when compiling similar pieces of code. Therefore, when one node compiles source code into native instructions, it may share the optimizations used with other similar nodes, thereby removing the burden for the other nodes to figure out which optimizations to use. Thus, while one node may suffer a performance hit for determining the necessary optimizations, other nodes may be saved from this burden by simply using the optimizations provided to them.12-24-2009
20130167129SYSTEMS AND METHODS FOR DEMARCATING INFORMATION RELATED TO ONE OR MORE BLOCKS IN AN APPLICATION - The invention relates to a system and method for demarcating information related to one or more blocks in an application source code. This invention provides a means to annotate block information in the source code. It parses the application source code to generate an abstract syntax tree and instruments the source code to capture information related to the one or more blocks generated at the time of dynamic analysis of the application. The information related to the one or more blocks are stored in Hash Map and based on this information the abstract syntax tree is modified to add the information related to the one or more blocks and inserting this information in the application source code.06-27-2013
20080301654Program processing apparatus, program processing method and computer readable information recording medium - A program processing apparatus comprising at least any one of an executable file compile possible part configured to carry out a predetermined executable file compile possible process to a program to make it possible to compile into an executable file the program, in such a state that the program has at least a part thereof enciphered, and a removal processing part configured to carry out a predetermined removing process to a program to remove an influence of the predetermined executable file compile possible process, which program has at least a part thereof enciphered and further has undergone the predetermined executable file compile possible process.12-04-2008
20110296389Mechanism for Allocating Statement Frontier Annotations to Source Code Statements - A mechanism for allocating statement frontier annotations to source code statements of a software program is disclosed. A method of embodiments of the invention includes generating statement frontier annotations during translation of source code statements of a software program on a computer system. The method further includes allocating the statement frontier annotations to the source code statements, wherein a statement frontier annotation indicates a frontier of a source code statement to which the statement frontier annotation is allocated.12-01-2011
20090119653INSTRUMENTING A COMPILED SOFTWARE ROUTINE FOR AUGMENTATION - A method for augmenting a compiled software routine in execution, the compiled software routine being instrumented to generate an event at an augmentation point defined therein, the method including receiving the event at a second software routine, the second software routine including software instructions for augmenting the compiled software routine.05-07-2009
20110219364Mechanism for Performing Register Allocation of Program Variables Based on Priority Spills and Assignments - A mechanism for performing register allocation based on priority spills and assignments is disclosed. A method of embodiments of the invention includes repetitively detecting fat points during a compilation process of a software program running on a virtual machine of a computer system, each fat point representing a program point having a high register pressure, the high register pressure occurs when a number of live program variables of the software program living at a given program point of the software program is greater than a number of available processor registers of the computer system. The method further includes choosing a fat point with a highest register pressure, selecting a live program variable having a lowest priority at the chosen fat point, and spilling the lowest priority live program variable to memory of the computer system.09-08-2011
20090313614METHOD FOR HIGH-PERFORMANCE DATA STREAM PROCESSING - Techniques for optimizing data stream processing are provided. The techniques include employing a pattern, wherein the pattern facilitates splitting of one or more incoming streams and distributing processing across one or more operators, obtaining one or mote operators, wherein the one or more operators support at least one group-independent aggregation and join operation on one or more streams, generating code, wherein the code facilitates mapping of the application onto a computational infrastructure to enable workload partitioning, using the one or more operators to decompose each of the application into one or more granular components, and using the code to reassemble the one or more granular components into one or more deployable blocks to map the application to a computational infrastructure, wherein reassembling the one or more granular components to map the application to the computational infrastructure optimizes data stream processing of the application.12-17-2009
20090150874BINARY PROGRAMMABLE METHOD FOR APPLICATION PERFORMANCE DATA COLLECTION - A method for application performance data collection includes steps or acts of: customizing a performance tool for collecting application performance data of an application; modifying the application by inserting the performance tool while the application does not need to be rebuilt from the source; executing the application; and collecting the application execution performance data such that only interesting data is collected. Customizing the performance tool proceeds by implementing at least one configurable tracing function that can be programmed by the user; compiling the function(s) into an object file; and inserting the object file into the performance tool using binary instrumentation.06-11-2009
20090089769CODE OPTIMIZATION WHEN USING MULTIPLE READER LOCKS AND A NON-READER LOCK - Illustrative embodiments provide a way to use multiple-reader locks for those paths where no writes occur. A computer implemented method, data processing system and computer program product provide a capability where only if one of the writing paths executes will a full writer lock be acquired. Illustrative embodiments may be used to create two copies of the critical section comprising a reading version and a writing version. The default execution leads to the reader version, which only acquires a reader-lock. The reader version of the code executes prior to execution of the writer lock only version, otherwise bypassing the writer lock only version. If the execution leads to a path in which a write would occur, the reader only version branches to the beginning of the writer version. The writer version is identical to the original code and obtains a full writer lock. If execution in the reader lock does not lead to a path that writes, then only the reader lock is acquired.04-02-2009
20100088688INSTRUCTION CACHE - Disclosed herein is a method of optimising an executable program to improve instruction cache hit rate when executed on a processor. A method of predicting instruction cache behaviour of an executable program is also disclosed. According to further aspects of the present invention, there is provided a software development tool product comprising code which when executed on a computer will perform the method of optimising an executable program. A linker product and a computer program are also disclosed.04-08-2010
20120297373METHODS FOR GENERATING CODE FOR AN ARCHITECTURE ENCODING AN EXTENDED REGISTER SPECIFICATION - There are provided methods and computer program products for generating code for an architecture encoding an extended register specification. A method for generating code for a fixed-width instruction set includes identifying a non-contiguous register specifier. The method further includes generating a fixed-width instruction word that includes the non-contiguous register specifier.11-22-2012
20080250399Evaluation and Selection of Programming Code - A system for evaluating and selecting programming code is described. A first evaluator measures a first characteristic of a number of input binaries. The evaluator computes a number of first figures of merit for the input binaries, respectively. A binary selector compares the first figures of merit, and selects one of the input binaries as having the highest or lowest overall figure of merit. Other embodiments arc also described and claimed.10-09-2008
20080271004COMPUTER-IMPLEMENTED METHOD, SYSTEM, AND PROGRAM PRODUCT FOR OPTIMIZING A DISTRIBUTED APPLICATION - A computer-implemented method, system, and program product for optimizing a distributed (software) application are provided. Specifically, a configuration of a target computing environment, in which the distributed application is deployed, is discovered upon deployment of the distributed application. Thereafter, based on a set of rules and the discovered configuration, one or more optimization techniques are applied to optimize the distributed application. In a typical embodiment, the set of rules can be embedded in the distributed application, or they can be accessed from an external source such as a repository. Regardless, the optimization techniques applied can include at least one of the following: (1) identification and replacement of an underperforming component of the distributed application with a new component; (2) generation of interface layers (to allow selection of optimal bindings) between distributed objects of the distributed application; and/or (3) execution of code transformation of the distributed application using program analysis techniques.10-30-2008
20080271003Balancing Computational Load Across a Plurality of Processors - Computational load is balanced across a plurality of processors. Source code subtasks are compiled into byte code subtasks whereby the byte code subtasks are translated into processor-specific object code subtasks at runtime. The processor-type selection is based upon one of three approaches which are 1) a brute force approach, 2) higher-level approach, or 3) processor availability approach. Each object code subtask is loaded in a corresponding processor type for execution. In one embodiment, a compiler stores a pointer in a byte code file that references the location of a byte code subtask. In this embodiment, the byte code subtask is stored in a shared library and, at runtime, a runtime loader uses the pointer to identify the location of the byte code subtask in order to translate the byte code subtask.10-30-2008
20090164983PROGRAMMING LIBRARY USAGE CAPTURING AND REPRESENTATION - A computer system may provide various resources to users through one or more programming libraries, such as application programming interfaces (APIs), in order to standardize access to such resources through various general-purpose mechanisms. These programming libraries may be operated by other programs, such as task-specific user interfaces, through which a user may utilize the programming library without having to understand its structure and functions. However, in many scenarios, a user may wish to know the manner of invoking a programming library to achieve an invoked behavior, or may wish to reproduce the behavior without having to utilize the user interface. A user may therefore capture an invocation of the programming library, and may generate an instruction set representing the captured invocation that may be studied, copied, modified, subsequently performed, etc.06-25-2009
20090144711SYSTEM AND METHOD FOR COMMON COMPILER SERVICES BASED ON AN OPEN SERVICES GATEWAY INITIATIVE ARCHITECTURE - A system and method for common compiler services based on an Open Services Gateway initiative (OSGi) architecture are constructed on an OSGi framework for processing and registering a server page source file. The method includes: transmitting a compilation request signal associated with the server page source file to a common compiler bridge interface unit; based on the compilation request signal, enabling the common compiler bridge interface unit to select a support compiler corresponding to the compilation request signal to compile the server page source file so as to obtain a server application file; and using a server application registration unit to complete registration of the server application file.06-04-2009
20090178032Mining for performance data for systems with dynamic compilers - In an example data mining process, performance data for instructions that execute in a data processing system is obtained. The performance data may comprise instruction addresses and corresponding performance information. A dump that comprises the instructions and corresponding instruction addresses may also be obtained. Common code segments in the dump may be automatically identified. A common code segment may comprise an ordered set of multiple instructions that appears multiple times in the dump. Aggregate performance data for the common code segments may be generated, based at least in part on (a) the instruction addresses associated with the common code segments in the dump, and (b) the instruction addresses and the corresponding performance information from the performance data. Other embodiments are described and claimed.07-09-2009
20110145802ACCELERATING UNBOUNDED MEMORY TRANSACTIONS USING NESTED CACHE RESIDENT TRANSACTIONS - Using cache resident transaction hardware to accelerate a software transactional memory system. The method includes identifying a plurality of atomic operations intended to be performed by a software transactional memory system as transactional operations as part of a software transaction. The method further includes selecting at least a portion of the plurality of atomic operations. The method further includes attempting to perform the portion of the plurality of atomic operations as hardware transactions using cache resident transaction hardware.06-16-2011
20090199168PROGRAM CONVERSION METHOD USING HINT INFORMATION THAT INDICATES ASSOCIATION BETWEEN VARIABLES - A program conversion method that can increase variations of applicable optimizations and effects of the optimization, by being provided with characteristics of a variable or an association between two or more variables as hint information for optimization by a programmer or profiler. The program conversion method converts a source program in a computer and includes: obtaining a constraint equation including at least one of a variable in the source program, a constant, an operator, a pseudo variable, and a built-in function and producing a truth-value; and converting the source program by optimizing the constraint.08-06-2009
20090199167Hardware Definition Method - The invention relates to a method for defining hardware, in which a library of parameterizable, executable elements is provided, parameters are selected, the elements comprising selected parameters are compiled, and the compilation is then simplified.08-06-2009
20090320007LOCAL METADATA FOR EXTERNAL COMPONENTS - A system and method for facilitating execution of a computer program in a framework, in which the computer program uses a component external to the framework is provided. The computer program is generated by compiling corresponding source code to produce generated code, extracting metadata corresponding to the external component, and combining the generated code with the metadata. The extracted metadata may be a partial subset of the metadata corresponding to the external component. When the computer program is executed, the combined metadata may be used to invoke or otherwise interact with the external component.12-24-2009
20090055811REDUCING THE RUN-TIME COST OFINVOKING A SERVER PAGE - The present invention is a method, system and apparatus for reducing the run-time cost of invoking a server page. The system can include a server page translation unit configured to translate a server page document into program code. The system also can include a program code compiler configured to compile the program code into a program object. Finally, the system can include an optimization processor programmed to modify the program code to permit direct invocation of the program object by external program objects bypassing a server engine typically used to invoke the server page. Notably, in a preferred aspect of the invention the server page can be a JSP. Similarly, the program code can be Java source code and the program object can be a Java class. Finally, the external program objects can be servlets.02-26-2009
20120198427Ensuring Register Availability for Dynamic Binary Optimization - A compiler compiles code in a target program by reserving at least one register for use by a dynamic binary optimizer during target program execution. When the target program is subsequently executed, the dynamic binary optimizer stores needed state information in the reserved register(s), without affecting register state of the target program. Preferably, the state information in the reserved register(s) includes addressing information for a context save area, used for saving processor state when switching context from the target program to the dynamic binary optimizer.08-02-2012
20090249318Data Transfer Optimized Software Cache for Irregular Memory References - Mechanisms are provided for optimizing irregular memory references in computer code. These mechanisms may parse the computer code to identify memory references in the computer code. These mechanisms may further classify the memory references in the computer code as either regular memory references or irregular memory references. Moreover, the mechanisms may transform the computer code, by a compiler, to generate transformed computer code in which irregular memory references access a storage of a software cache of a data processing system through a transactional cache mechanism of the software cache.10-01-2009
20100192139EFFICIENT PER-THREAD SAFEPOINTS AND LOCAL ACCESS - Some embodiments of the present invention provide a system that implements a safepoint for a thread, which includes a compiler and a runtime environment. During compilation of an application to be executed by the thread, the compiler obtains a register to be associated with the thread and inserts safepoint code into the application, wherein the safepoint code includes an indirect load from a memory location stored in the register to the register. During execution of the application by the thread, the runtime environment writes a thread-specific value for the thread to the register, wherein the thread-specific value corresponds to an enabled value, a triggered value, or a disabled value. In these embodiments, executing the indirect load by the thread causes the thread to trap if the thread-specific value corresponds to the triggered value.07-29-2010
20100125836COMPILING TECHNIQUES FOR PROVIDING LIMITED ACCURACY AND ENHANCED PERFORMANCE GRANULARITY - A programmable compiler detects from source code invocations of math functions that require reduced levels of accuracy, limited variable domains, or enhanced performance. The programmable compiler replaces such invocations with intrinsics from the compiler's own intrinsic library. The math function invocations are compiled into inline object code. The inline object can be subsequently optimized along with other object code through normal compiler optimization. If an accuracy requirement is beyond what any compiler intrinsic can provide, the programmable compiler preserves the invocation of the math function defined in a default library.05-20-2010
20090019431OPTIMISED COMPILATION METHOD DURING CONDITIONAL BRANCHING - The present invention discloses a compilation method of a program code in a digital device in a profile driven compilation. An approach for optimizing the execution of program code by providing additional intelligence to the compiler is provided, where the compiler decides whether to have single decision tree with guarded operations or multiple decision trees. The method of this invention is helpful, in reducing the overhead of conditional code branching to have an optimised program code, both in compiler driven optimisations and in manual optimisations by the programmer.01-15-2009
20080313620SYSTEM AND METHOD FOR SAVING AND RESTORING A SELF-DESCRIBING DATA STRUCTURE IN VARIOUS FORMATS - A system and method for saving and/or restoring a self-describing data structure in various formats is provided. The method includes the steps of executing a data structure engine and an export/import module in a computer system; said export/import module obtaining at least one description set for at least one container data structure from said data structure engine; creating a header for each element in the data structure; declaring the structure by writing its type in a format-specific syntax; outputting each property in the structure and outputting child structures to form an external representation of the self-describing data structure.12-18-2008
20090320006LEARNING AND CACHE MANAGEMENT IN SOFTWARE DEFINED CONTEXTS - A exemplary system and method are provided for learning and cache management in software defined contexts. Exemplary embodiments of the present invention described herein address the problem of the data access wall resulting from processor stalls due to the increasing discrepancies between processor speed and the latency of access to data that is not stored in the immediate vicinity of the processor requesting the data.12-24-2009
20090106744Compiling and translating method and apparatus - Methods and apparatus are described to compile and translate source code. In some embodiments, source code is compiled into source binary code for a source platform; an annotation section associated with the source binary code is generated, wherein the annotation section comprises an annotation for a scope, the scope comprising at least one block of the source binary code having at least one attribute to aid a translator optimization. If the scope comprises a plurality of blocks, the blocks have consecutive addresses with each other and have the at least one attribute in common. In the embodiments, the source binary code is further translated into target binary code for a target platform by utilizing the annotation section.04-23-2009
20100223605APPARATUS AND METHOD FOR AUTOMATICALLY PARALLELIZING NETWORK APPLICATIONS THROUGH PIPELINING TRANSFORMATION - In some embodiments, a method and apparatus for automatically parallelizing a sequential network application through pipeline transformation are described. In one embodiment, the method includes the configuration of a network processor into a D-stage processor pipeline. Once configured, a sequential network application program is transformed into D-pipeline stages. Once transformed, the D-pipeline stages are executed in parallel within the D-stage processor pipeline. In one embodiment, transformation of a sequential application program is performed by modeling the sequential network program as a flow network model and selecting from the flow network model into a plurality of preliminary pipeline stages. Other embodiments are described and claimed.09-02-2010
20100058302SYSTEM, APPARATUS AND METHOD FOR TRANSLATING DATA - A distributed processor-based system comprises a plurality of communicating platforms, wherein a number of platforms in the distributed processor-based system comprise at least one compiler, the at least one compiler being operably coupled to data type translation logic and arranged to generate a memory layout for the respective platform. In response to an indication for a communication to occur between a first platform and a second platform the data type translation logic translates a memory layout using data type attributes for data to be transferred from the first platform to the second platform based on at least one platform-specific characteristic, such that the data does not require translating when received at the second platform.03-04-2010
20100125835HIGH EFFICIENCY COMPILATION FRAMEWORK - A method and system for reducing processing overhead during execution of a code block in a high efficiency compilation framework. The method identifies second code blocks within the code block and separates them out from the first code block during compilation. Further, during compilation, the system converts the second code blocks to kernel program modules, in a form recognizable by the system kernel. The compilation is followed by execution of the first code block, with the compiled object code of the first code block being executed in user mode and the kernel program modules being executed in kernel mode.05-20-2010
20100088687Variable Length Code Table Clustering Method, and Method and Apparatus for Sharing Memory of Multi-Codec by Using the Variable Length Code Table Clustering Method - Provided are a method and apparatus for sharing a memory of a multi-codec. For each of a plurality of codecs, the method and apparatus cluster a variable length code tree into a plurality of groups whereby a level difference between symbols in each group of the plurality of groups is less than a predetermined value, wherein the variable length code tree corresponds to at least one of variable length code tables for each of the plurality of codecs, refer to maximum levels of the symbols in each group of the plurality of groups, and determine a storage capacity of an internal memory shared between the variable length code tables for the plurality of codecs.04-08-2010
20120204163System and Method for Optimizing Software Transactional Memory Operations Using Static Caching of Memory Objects - Systems and methods for optimizing transactional memory operations may employ static analysis of source code and static caching of memory objects to elide redundant transactional accesses. For example, a compiler (or an optimizer thereof) may be configured to analyze code that includes an atomic transaction to determine if any read accesses to shared memory locations are dominated by a previous read or write access to the same locations and/or any write accesses to shared memory locations are post-dominated by a subsequent write access to the same locations. Any access within a transaction that is determined to be redundant (e.g., any access other than the first read of a given shared memory location from within the transaction or the last write to a given shared memory location from within the transaction) may be replaced (by the compiler/optimizer) with a non-transactional access to a cached shadow copy of the shared memory location.08-09-2012
20090125893METHOD AND APPARATUS FOR MANAGING VARIABLE ASSIGNMENTS IN A PROGRAM - The illustrative embodiments described herein provide a computer-implemented method, apparatus, and computer program product for managing variable assignments in a program. The process identifies a set of variable assignments that is live on a portion of paths to form a set of identified variable assignments. Each of the set of identified variable assignments assign a value to at least one variable of a set of variables. The process determines a set of program points at which the set of identified variable assignments is live on all paths. The process also moves the set of identified variable assignments to the set of program points in response to determining that the set of identified variable assignments is movable to the set of program points.05-14-2009
20120311550METHOD FOR OPTIMIZING BINARY CODES IN LANGUAGE HAVING ACCESS TO ZONED DECIMAL TYPE VARIABLE, OPTIMIZATION APPARATUS AND COMPUTER PROGRAM FOR THE SAME - An optimization technique for optimizing binary codes in a language having access to a zoned decimal type variable and applicable to binary codes including instructions which can cause side effects. The optimization technique includes: detecting, for each variable, an area including access to a zoned decimal type variable and not including an instruction that can cause a side effect, from the binary codes read into a memory; and performing, in the detected area, a process for converting a zoned decimal type variable to a binary type variable, a process for deleting such a pack/unpack code that a converted result does not change even in case the pack/unpack code is deleted, from the binary codes, or a process for performing combination of the processes.12-06-2012
20120311549NON-INTRUSIVELY ADAPTING EXISTING PORTFOLIO OPTIMIZER FOR VALUATED DEPENDENCIES - Adapting an existing portfolio optimizer to support one or more valuated dependencies without modifying the existing portfolio optimizer, may include translating one or more original elements and associated dependencies in a portfolio to be optimized based on said one or more valuated dependencies; invoking the existing portfolio optimizer with the translated one or more original elements and associated dependencies; and translating optimization results, if said optimization results contain translated one or more original elements, into a solution characterized in terms of said one or more original elements.12-06-2012
20100180269DOMAINS WITH POLYMORPHIC TYPE IMPLEMENTATIONS - Various domains may wish to specify different implementations of the type; e.g., a compilation domain may describe the type statically, an execution domain may instantiate objects of the given type, while a debugging execution domain may associate additional debugging information such as a symbol name. This may be achieved by specifying a type implementation of a particular type within respective domains which all implement a common type interface. A type binding instruction set may then select a type implementation for the type within the target instruction set according to the domain, and may bind type instances of the type within target instruction set to the selected type implementation for the current domain. This technique yields domain-specific variance in type implementation without having to reconfigure the target instruction set or perform domain-checking logic there-within.07-15-2010
20100153938Computation Table For Block Computation - In response to receiving pre-processed code, a compiler identifies a code section that is not candidate for acceleration and identifying a code block specifying an iterated operation that is a candidate for acceleration. In response to identifying the code section, the compiler generates post-processed code containing one or more lower level instructions corresponding to the identified code section, and in response to identifying the code block, the compiler creates and outputs an operation data structure separate from the post-processed code that identifies the iterated operation. The compiler places a block computation command in the post-processed code that invokes processing of the operation data structure to perform the iterated operation and outputs the post-processed code.06-17-2010
20100251227BINARY RESOURCE FORMAT AND COMPILER - Optimization architecture for applications that uses a localization model in which localizable resources are separated from code. The resources are typically located in separate DLL files as binary blobs in a unique format. The format is designed for optimized performance and to accommodate various requirements of complex office applications. The binary blobs are produced by a resource compiler based on the format. The architecture includes a resource binary format that facilitates resource identification and lookup, optimization of memory paging by grouping and ordering resources according to runtime use, optimization by compressing resources with an optimal algorithm that is fast in decompression, fast reverse lookup of a resource identifier by resource content, resource grouping, resource substitution, branding, and resource runtime metadata (also referred to as user data).09-30-2010
20090293048Computer Analysis and Runtime Coherency Checking - Compiler analysis and runtime coherency checking for reducing coherency problems is provided. Source code is analyzed to identify at least one of a plurality of loops that contains a memory reference. A determination is made as to whether the memory reference is an access to a global memory that should be handled by at least one of a software controlled cache or a direct buffer. A determination is made as to whether there is a data dependence between the memory reference and at least one reference from at least one of other direct buffers or other software controlled caches in response to an indication that the memory reference is an access to the global memory that should be handled by either the software controlled cache or the direct buffer. A direct buffer transformation is applied to the memory reference in response to a negative indication of the data dependence.11-26-2009
20090293047Reducing Runtime Coherency Checking with Global Data Flow Analysis - Reducing runtime coherency checking using global data flow analysis is provided. A determination is made as to whether a call is for at least one of a DMA get operation or a DMA put operation in response to the call being issued during execution of a compiled and optimized code. A determination is made as to whether a software cache write operation has been issued since a last flush operation in response to the call being the DMA get operation. A DMA get runtime coherency check is then performed in response to the software cache write operation being issued since the last flush operation.11-26-2009
20080229294Method and System for Managing Heuristic Properties - A computer implemented method, system and computer program product for managing heuristic properties for controlling an optimization transformation in a compiler or in other heuristically controlled software in a data processing system. A computer implemented method for controlling an optimization transformation in heuristically controlled software includes defining at least one heuristic property for controlling a behavior of an optimization transformation, and creating at least one heuristic property modifier for each desired change in the behavior of the optimization transformation. At least one of the at least one heuristic property is then modified using the at least one heuristic property modifier for achieving each desired change in the behavior of the optimization transformation.09-18-2008
20080307402SIMD Code Generation in the Presence of Optimized Misaligned Data Reorganization - Loop code is generated to execute on Single-Instruction Multiple-Datapath (SIMD) architectures, where the loop operates on datatypes having different lengths. Further, a preferred embodiment of the present invention includes a novel technique to efficiently realign or shift arbitrary streams to an arbitrary offset, regardless whether the alignments or offsets are known at the compile time or not. This technique enables the application of advanced alignment optimizations to runtime alignment. This allows sequential loop code operating on datatypes of disparate length to be transformed (“simdized”) into optimized SIMD code through a fully automated process.12-11-2008
20110307875TRACKING VARIABLE INFORMATION IN OPTIMIZED CODE - Embodiments are directed to tracking variable location information in optimized code and efficiently collecting and storing reaching definition information. A computer system receives a portion of source code at a compiler, where the compiler is configured to compile and optimize the source code for execution. The computer system tags selected variables in the source code with a tag, where the tag is configured to provide location information for the variable. The computer system optimizes the received portion of source code including changing at least one of the tagged variables. The computer system also tracks the tagged variables as the variables are changed by the compiler during code optimization and persists the variable location information, so that the persisted variable location information is available to other compiler components.12-15-2011
20120042306COMPILING SYSTEM AND METHOD FOR OPTIMIZING BINARY CODE - A compiling system and method for optimizing binary code. The method includes the step of replacing a memory access on a stack area in order to save a value of a register with local variable access. The method further includes: giving a call number to a call instruction and an inlined code in response to an inline expansion of a code to be called by the call instruction; creating a parent-child relationship information for at least one of the call number; processing the memory accesses with an escaped stack pointer as a base address if a stack pointer has escaped; prohibiting a replacement of a prohibited memory access if the stack pointer has escaped; and replacing unprohibited memory access with the local variable access if the stack pointer has escaped.02-16-2012
20090031292COPY-ON-WRITE OPTIMIZATION OF IMMUTABLE OBJECTS FOR OBJECT ORIENTED LANGUAGES - A computer implemented method, apparatus, and computer program product for copy-on-write optimization of immutable objects. An immutable object is marked as read-only to form a read-only object. The read-only object is formed to delay copying of the immutable object until a runtime determination is made that a write to the immutable object will be made. In response to an attempt to write to the read-only object, an internal value of the read-only object is copied to read-and-write storage using runtime information to form a writable copy of the read-only object. A set of references for the read-only object is updated to point to the writable copy of the read-only object. Delaying copying of the immutable object optimizes a copy-on-write of the immutable object.01-29-2009
20120017204STRING CACHE FILE FOR OPTIMIZING MEMORY USAGE IN A JAVA VIRTUAL MACHINE - A method, system and computer program product for optimizing memory usage associated with duplicate string objects in a Java virtual machine. The method comprises scanning a heap of the Java virtual machine at the end of the start-up process of the virtual machine to identify duplicate strings associated with the virtual machine, storing the identified strings in a string cache file, and determining whether a new string that needs to be created during start-up already exists in the string cache file. The duplicate strings are added to an interned strings table. A reference to a duplicate string is returned if a string to be created is already in the string cache file.01-19-2012
20120110561STRUCTURE LAYOUT OPTIMIZATIONS - More effective compiler optimizations provide improved cache utilization. The compiler optimizations include a structure layout optimization that leaves the physical layout of the structure fields intact and instead changes the access order to these fields. The compiler optimizations apply to arrays using array remappings analogous to structure layout optimizations in which the array is considered as a structure and the physical layout of the array remains intact and instead the access order to the array changes.05-03-2012
20120317559Thin-Client and Distributed Development Using Data Programming - A system and method of data programming includes declarative rule-based programming in which a distributed program for computers on a network is defined through tabular structures. The tabular structures can store logic, including data (e.g., primitive variables and dynamic data structures) and code (e.g., arguments and functions) that govern operation of the distributed program.12-13-2012
20120317560METHOD FOR OPTIMIZING BINARY CODES IN LANGUAGE HAVING ACCESS TO ZONED DECIMAL TYPE VARIABLE, OPTIMIZATION APPARATUS AND COMPUTER PROGRAM FOR THE SAME - An optimization technique for optimizing binary codes in a language having access to a zoned decimal type variable and applicable to binary codes including instructions which can cause side effects. The optimization technique includes: detecting, for each variable, an area including access to a zoned decimal type variable and not including an instruction that can cause a side effect, from the binary codes read into a memory; and performing, in the detected area, a process for converting a zoned decimal type variable to a binary type variable, a process for deleting such a pack/unpack code that a converted result does not change even in case the pack/unpack code is deleted, from the binary codes, or a process for performing combination of the processes.12-13-2012
20110185346AUTOMATED BUILDING AND RETARGETING OF ARCHITECTURE-DEPENDENT ASSETS - Architecture-dependent assets are automatically built and retargeted. An asset originally built for one architecture is downloaded and automatically retargeted on another architecture. This automatically retargeting may be performed on demand, at runtime.07-28-2011
20100175056COMPILER APPARATUS WITH FLEXIBLE OPTIMIZATION - A compiler comprises an analysis unit that detects directives (options and pragmas) from a user to the compiler, an optimization unit that is made up of a processing unit (a global region allocation unit, a software pipelining unit, a loop unrolling unit, a “if” conversion unit, and a pair instruction generation unit) that performs individual optimization processing designated by options and pragmas from a user, following the directives and the like from the analysis unit, etc. The global region allocation unit performs optimization processing, following designation of the maximum data size of variables to be allocated to a global region, designation of variables to be allocated to the global region, and options and pragmas regarding designation of variables not to be allocated in the global region.07-08-2010
20120174082REFACTORING PROGRAMS FOR FLEXIBLE LOCKING - Disclosed is a novel computer implemented system, on demand service, computer program product and a method that provides a set of lock usages that improves concurrency resulting in execution performance of the software application by reducing lock contention through refactoring. More specifically, disclosed is a method to refactor a software application. The method starts with accessing at least a portion of a software application that can execute in an operating environment where there are more two or more threads of execution. Next, a determination is made if there is at least one lock used in the software application to enforce limits on accessing a resource. In response to determining that there is a lock with a first type of construct with a given set of features, the software application is refactored with the lock to preserve behavior of the software application.07-05-2012
20100275193REDUCING MEMORY USAGE OF KERNEL MEMORY MANAGEMENT STRUCTURES - One aspect of the present invention relates to techniques utilized within an operating system or a similar virtualization environment for reducing overhead of memory management data structures. Memory management data structures are used by operating systems to track the location of hardware pages in physical memory, consuming around 1% of a computer system's physical memory. However, these data structures may be classified as redundant when multiple data structures are used to track the same virtual memory pages stored within physical memory. One embodiment discloses an operation that identifies redundant data structures tracking frames of a single large page that are stored contiguously in the physical memory. Once identified, the redundant data structures may be removed from physical memory, freeing the physical memory for other uses. A further embodiment enables recreation of the removed data structures in physical memory if later accessed within the operating system.10-28-2010
20100275192Generating optimal instruction sequences for bitwise logical expressions - A sequence generator generates a table of optimal instruction sequences for all bitwise expression having a specific number of variables. An index generator generates a bit-string index that corresponds to a particular bitwise expression. The bit-string is generated from a truth table. A table lookup unit is coupled with the index generator. The table lookup unit finds an optimal instruction sequence for the bitwise expression from within the table of optimal instruction sequences based at least in part on the generated bit-string index.10-28-2010
20120284701EFFICIENT CONDITIONAL FLOW CONTROL COMPILATION - In general techniques are described for efficient conditional flow control (CFC) compilation. An apparatus comprising a processor executing a compiler that includes at least one translation module may perform these techniques. The translation module translates a first set of high-level (HL) CFC software to a functionally equivalent but different second set of HL CFC software instructions. The compiler then compiles the first and second sets of high-level CFC software instructions to respective first and second sets of low-level (LL) CFC software instructions. An evaluation module of the compiler evaluates the first and second sets of LL CFC software instructions to determine which of the first and second sets of the low-level CFC software instructions is more efficient as measured in terms of at least one execution metric and outputs the one of the first and second low-level CFC software instructions determined to be most efficient.11-08-2012
20120084763IDENTIFYING CODE THAT WASTES TIME SWITCHING TASKS - A method of detecting portions of code of a computer program that protect resources of a computer system unnecessarily can include identifying threads and synchronization objects that are used by a computer program during execution, determining the number of threads that have accessed each resource while it has been consistently protected by a particular synchronization object, and indicating whether the resource is suited for protection according to the number of threads that have accessed the resource.04-05-2012
20120084762FINE-GRAINED PERFORMANCE CONFIGURATION OF APPLICATION - A method, system and computer program product for performance configuration of an application by setting at least one performance preference for a performance-sensitive class in the application, specifying performance preference propagation policy of the class in the application based on the at least one performance preference, and calling the class to perform performance configuration for application according to the performance preference propagation policy.04-05-2012
20120260240SOFTWARE BUILD OPTIMIZATION - A method or software program that provides an analysis of a build, which can provide a developer with views of the build processes, is disclosed. Data is collected from the build. The collected data can include information regarding file access patterns from determining which files are accessed for read and which files are accessed for write by one or more software build tools and project interdependencies. The collected data can also include certain project properties, build configurations, intermediate directories such as logs, and other metadata of the build. The collected data is injected into a relational database that can be queried. The information developed in a database query can be applied to optimize the build.10-11-2012
20110004869PROGRAM, APPARATUS, AND METHOD OF OPTIMIZING A JAVA OBJECT - An apparatus, method and article of manufacture tangibly embodying computer readable instructions for optimizing a Java object on a target computer program. The apparatus includes: a storage unit for storing a value of the object and management information on the object in association with each other; a code generation unit for generating, from the target computer program, optimized code and unoptimized code; a switching unit for switching from executing the target computer program using the optimized code to executing the target computer program using the unoptimized code in response to an event in which the value of the object is written while the target computer program is executed by using the optimized code; and a management unit for managing the object by accessing the management information by a non-detection write operation in which writing to the object is performed without being detected.01-06-2011
20120324430ALIASING BUFFERS - The present invention extends to methods, systems, and computer program products for aliasing buffers. Embodiment of the inventions supporting buffer aliasing through introduction of a level of indirection between a source program's buffer accesses and the target executable physical buffers, and binding the logical buffer accesses to actual physical buffer accesses at runtime. A variety of techniques for can be used supporting runtime aliasing of buffers, in a system which otherwise disallows such runtime aliasing between separately defined buffers in the target executable code. Binding of logical buffer accesses in the source program to the actual physical buffers defined in the target executable code is delayed until runtime.12-20-2012
20110276954SIMULTANEOUS COMPILER BINARY OPTIMIZATIONS - The present invention provides a method to optimize object code files produced by a compiler for several different types of target processors. The compiler divides the source code to be compiled into several functional modules. Given a specified set of target processors, each functional module is compiled resulting in a target object version for each target processor. Then, for each functional module, a merging process is performed wherein identical target object versions or target object versions with similar contents are merged by deleting the identical or similar versions. After this merging process, a composite object code file is formed containing all of the non-deleted target object versions of the function modules.11-10-2011
20120102473ABSTRACT METHOD REMOVAL FOR REDUCED MEMORY FOOTPRINT WITH OPTIMIZER TOOL - A compiler compiles a set of code to generate compiled code having a first size. Further, an optimization tool, which is operably connected to a processor, automatically removes one or more abstract method definitions from the compiled code by iteratively examining each class file in the complied code and only adding the class file without the one or more abstract method definitions to an output file. The output file has a second size that is less than the first size. In addition, the output file is deployed after the automatic removal of the one or more abstract method definitions.04-26-2012
20100131937OPTIMIZATION HINTS FOR A BUSINESS PROCESS FLOW - In one embodiment, an optimization hint may be included in a business process flow. An executable process may be generated from the business process flow where the optimization hint is included in the executable process. While executing the executable process, the runtime engine encounters an optimization hint and determines an optimization to perform. The optimization hint may be related to an aspect of a business process being orchestrated by the business process flow. The optimization is then performed while executing the executable process. For example, the runtime engine may start pre-processing the branch while the condition is being evaluated. If the condition evaluates such that the pre-processed branch should be executed, then the runtime engine has already started processing of that branch. The processing is thus optimized in that the runtime engine is not sitting idle while waiting for the condition to be evaluated.05-27-2010
20130019232MANAGING ALIASING CONSTRAINTSAANM CUI; SHIMINAACI TORONTOAACO CAAAGP CUI; SHIMIN TORONTO CAAANM SILVERA; RAUL E.AACI WOODBRIDGEAACO CAAAGP SILVERA; RAUL E. WOODBRIDGE CA - An illustrative embodiment of a computer-implemented process for managing aliasing constraints, identifies an object to form an identified object, identifies a scope of the identified object to form an identified scope, and assigns a unique value to the identified object within the identified scope. The computer-implemented process further demarcates an entrance to the identified scope, demarcates an exit to the identified scope, optimizes the identified object using a property of the identified scope and associated aliasing information, tracks the identified object state to form tracked state information; and uses the tracked state information to update the identified object.01-17-2013
20130019231DISTRIBUTED COMPILING PROCESS WITH INSTRUCTION SIGNATURE SUPPORTAANM Mangard; StefanAACI MuenchenAACO DEAAGP Mangard; Stefan Muenchen DEAANM Gammel; BerndtAACI Markt SchwabenAACO DEAAGP Gammel; Berndt Markt Schwaben DEAANM Duve; JuergenAACI HolzkirchenAACO DEAAGP Duve; Juergen Holzkirchen DE - A compiler module for providing instruction signature support to a compiler includes a language construct identifier and a placeholder insertion component. The language construct identifier is configured to identify an instruction signature-relevant language construct in a high level language source code supplied to the compiler. The placeholder insertion component is configured to interact with the compiler for inserting at least one instruction signature-related placeholder based on the instruction signature-related language construct into a compiled code processed by the compiler on the basis of the high level language source code.01-17-2013
20110246975CONTROL ARCHITECTURE AND PROCESS FOR PORTING APPLICATION SOFTWARE FOR EQUIPMENT ON BOARD AN AIRCRAFT TO A CONSUMER STANDARD COMPUTER HARDWARE UNIT - The software unit arrangement method is a step of developing a standardized software-hardware abstraction software layer (10-06-2011
20110265069METHODS AND SYSTEMS FOR EXECUTION OF TENANT CODE IN AN ON-DEMAND SERVICE ENVIRONMENT INCLUDING UTILIZATION OF SHARED RESOURCES AND INLINE GOVERNOR LIMIT ENFORCEMENT - A method for evaluating bytecode in an on-demand service environment. A request to compile source code is received in a multitenant database environment. One or more limit enforcement mechanisms is/are inserted into the source code to monitor utilization of one or more corresponding resources within the multitenant database environment. The source code is compiled to generate executable code. The executable code is executed within the multitenant database environment. Resource utilization is evaluated for the one or more resources in response to executing code corresponding to at least one of the limit enforcement mechanisms.10-27-2011
20080222621Method of Automatically Building a Customised Software Application for a Specific Type of Wireless Computing Device - A customised software application can be built for a specific type of Wireless Computing Device by (a) automatically determining attributes of that type of Wireless Computing Device; (b) automatically determining which Software Components from a library of Software Components are compatible with that type of Wireless Computing Device based on values of the attributes determined in (a); and (c) automatically combining the compatible Software Components together to generate a customised build of the application, compatible for that type of Wireless Computing Device. The attributes can be metadata. This approach enables rich Network Applications to be automatically built for Wireless Computing Devices of a wide variety of types.09-11-2008
20130104112Pre-Parsed Headers for Compilation - Disclosed herein are methods and systems for creating and using pre-parsed headers. One or more header files may be scanned into tokens. These tokens may then be parsed into abstract syntax trees. The abstract syntax trees may then be serialized in a modular form into pre-parsed headers on a storage device. Based upon directives in one or more source files, the pre-parsed headers may then be deserialized into abstract syntax trees and loaded from the storage device. The loaded abstract syntax trees may then be used in the compilation of the source files.04-25-2013
20130145354SHARING AND PERSISTING CODE CACHES - Computer code from an application program comprising a plurality of modules that each comprise a separately loadable file is code cached in a shared and persistent caching system. A shared code caching engine receives native code comprising at least a portion of a single module of the application program, and stores runtime data corresponding to the native code in a cache data file in the non-volatile memory. The engine then converts cache data file into a code cache file and enables the code cache file to be pre-loaded as a runtime code cache. These steps are repeated to store a plurality of separate code cache files at different locations in non-volatile memory.06-06-2013
20130185704PROVIDING PERFORMANCE TUNED VERSIONS OF COMPILED CODE TO A CPU IN A SYSTEM OF HETEROGENEOUS CORES - A compiler may optimize source code and any referenced libraries to execute on a plurality of different processor architecture implementations. For example, if a compute node has three different types of processors with three different architecture implementations, the compiler may compile the source code and generate three versions of object code where each version is optimized for one of the three different processor types. After compiling the source code, the resultant executable code may contain the necessary information for selecting between the three versions. For example, when a program loader assigns the executable code to the processor, the system determines the processor's type and ensures only the optimized version that corresponds to that type is executed. Thus, the operating system is free to assign the executable code to any processor based on, for example, the current status of the processor (i.e., whether its CPU is being fully utilized) and still enjoy the benefits of executing code that is optimized for whichever processor is assigned the executable code.07-18-2013
20110314460COMPILE TIME INTERPRETATION OF MARKUP CODES - The present invention extends to methods, systems, and computer program products for compile time interpretation of markup codes. Embodiments of the invention can be used to specify custom behaviors to be taken in response to any of a number of ways that markup codes (e.g., XML data) can be constructed and in response to any number of ways that markup codes can be accessed. At compile time, the construction of objects and/or the modes of access for objects using mark up codes are known. As such, the compiler, type-system and development environment can use a known set of custom behaviors to regulate or give feedback on what constructions or modes of access are allowed, and what their characteristics are.12-22-2011
20110314459COMPILER WITH USER-DEFINED TYPE INFERENCE RULES - Performance of a program written in dynamic languages is improved through the use of a compiler that provides type inference for methods having a user-defined element. The user-defined element may be an input in a user-defined type. Though, the user-defined element may reflect that the method is user-defined. Type inference may be performed based on a user-defined mapping, relating input types to output types for one or more methods. The mapping may be specified as a data table provided to the compiler or as one or more functions that register with the compiler such that, as the compiler processes portions of a source program and detects a method with a user-defined element, the compiler may access the mapping and infer the type of an output of the method. The inferred type may then be used to optimize code dependent on that output.12-22-2011
20120030659CONSTRUCTING RUNTIME STATE FOR INLINED CODE - Techniques for processing computer code are disclosed. In one example, an indication that a computer code is to begin execution at a portion of code other than a starting portion of the code is received, and a runtime state associated with the portion of the code at which execution is to begin is constructed. In some examples, execution of the portion of code is initiated. In some examples, a program counter associated with the portion of the code is used to initiate execution of the code. In some examples, the computer code comprises a fallback code associated with a previously executing code.02-02-2012
20130198729AUTOMATED IMPROVEMENT OF EXECUTABLE APPLICATIONS BASED ON EVALUATING INDEPENDENT EXECUTION HEURISTICS - In one embodiment, a method comprises generating a first executable program optimized for an executable system based on compiling a program relative to an initial set of independent optimization metrics; determining first performance metrics based on the executable system executing the first executable program; adjusting the initial set of independent optimization metrics based on the first performance metrics to generate a second set of independent optimization metrics; and generating a second executable program, based on compiling the program relative to the second set of independent optimization metrics, for improved execution of the program in the executable system.08-01-2013
20120047496SYSTEM AND METHOD FOR REFERENCE-COUNTING WITH USER-DEFINED STRUCTURE CONSTRUCTORS - A system is provided that includes a code-processing portion, an initializing-processing portion, an ID-processing portion, a request-processing portion and a compiling-processing portion. The code-processing portion can embed a code architecture into user-defined data structures, wherein the code architecture can manage a counter. The initializing-processing portion can process code having a user-defined constructor therein and can initialize the counter based on an invocation of the architecture. The ID-processing portion has a memory that can store data therein, wherein the data is defined by the user-defined constructor. The ID-processing portion can associate the data with an identification tag and can generate a processing request. The request-processing portion can process the data based on the processing request. The compiling-processing portion can compile the code architecture. The initializing-processing portion can further update the counter based on the processing request. The memory can further store the processed data. The compiling-processing portion can free a portion of the memory holding the processed data when the counter reaches a predetermined number.02-23-2012
20130205284OWNERSHIP ACQUIRE POLICY SELECTION - There is provided a computer-implemented method of performing ownership acquire policy selection. The method includes compiling an atomic section to generate an instrumented executable. The instrumented executable is configured to generate a runtime abort graph describing a plurality of computer memory accesses made by the instrumented executable. The method also includes selecting each of a plurality of policies based on the runtime abort graph. The plurality of policies include a first policy and a second policy. The first policy is different from the second policy. The method further includes compiling the atomic section to generate a modified executable. The modified executable is configured to perform the computer memory accesses according to the selected policies.08-08-2013
20130205285METHODS AND APPARATUSES FOR AUTOMATIC TYPE CHECKING VIA POISONED POINTERS - A method and an apparatus that modify pointer values pointing to typed data with type information are described. The type information can be automatically checked against the typed data leveraging hardware based safety check mechanisms when performing memory access operations to the typed data via the modified pointer values. As a result, hardware built in logic can be used for a broad class of programming language safety check when executing software codes using modified pointers that are subject to the safety check without executing compare and branch instructions in the software codes.08-08-2013
20130205286RUNTIME OPTIMIZATION USING META DATA FOR DYNAMIC PROGRAMMING LANGUAGES - A method and an apparatus that optimize operations for a key among a collection of key indexed data structures using meta data describing properties of the key with respect to the collection of data structures are described. The meta data may correspond to a cache dynamically updated to indicate invariants which are true for the key in a current state of the collection of data structures. Expensive calculations to search through the collection of data structures for the key may be avoided. For example, costly lookup operations over a collection of data structures may not be required at all if a key is known to always (or to never) reference certain specific values, or for these values to have certain meta-properties, in any of the collection of data structure globally throughout a system at a current state.08-08-2013

Patent applications in class Optimization

Patent applications in all subclasses Optimization