Entries |
Document | Title | Date |
20080222621 | Method 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 |
20080229294 | Method 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 |
20080250399 | Evaluation 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 |
20080271003 | Balancing 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 |
20080271004 | COMPUTER-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 |
20080301654 | Program 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 |
20080307402 | SIMD 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 |
20080313620 | SYSTEM 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 |
20090019431 | OPTIMISED 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 |
20090031292 | COPY-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 |
20090055811 | REDUCING 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 |
20090089769 | CODE 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 |
20090106744 | Compiling 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 |
20090119653 | INSTRUMENTING 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 |
20090125893 | METHOD 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 |
20090144711 | SYSTEM 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 |
20090150874 | BINARY 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 |
20090164983 | PROGRAMMING 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 |
20090178032 | Mining 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 |
20090193405 | Method 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 |
20090199167 | Hardware 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 |
20090199168 | PROGRAM 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 |
20090249318 | Data 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 |
20090271775 | Optimizing 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 |
20090293047 | Reducing 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 |
20090293048 | Computer 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 |
20090313614 | METHOD 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 |
20090320006 | LEARNING 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 |
20090320007 | LOCAL 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 |
20090320008 | Sharing 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 |
20100042982 | OPTIMIZATION 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 |
20100058302 | SYSTEM, 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 |
20100088687 | Variable 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 |
20100088688 | INSTRUCTION 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 |
20100125835 | HIGH 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 |
20100125836 | COMPILING 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 |
20100131937 | OPTIMIZATION 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 |
20100153938 | Computation 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 |
20100175056 | COMPILER 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 |
20100180269 | DOMAINS 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 |
20100192139 | EFFICIENT 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 |
20100223605 | APPARATUS 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 |
20100251227 | BINARY 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 |
20100275192 | Generating 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 |
20100275193 | REDUCING 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 |
20110004869 | PROGRAM, 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 |
20110010696 | DUPLICATE 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 |
20110145802 | ACCELERATING 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 |
20110185346 | AUTOMATED 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 |
20110191758 | Optimized 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 |
20110191759 | Interactive 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 |
20110202909 | TIER 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 |
20110219364 | Mechanism 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 |
20110246975 | CONTROL 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 |
20110265069 | METHODS 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 |
20110276954 | SIMULTANEOUS 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 |
20110296389 | Mechanism 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 |
20110307875 | TRACKING 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 |
20110314459 | COMPILER 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 |
20110314460 | COMPILE 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 |
20120017204 | STRING 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 |
20120030659 | CONSTRUCTING 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 |
20120042306 | COMPILING 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 |
20120047496 | SYSTEM 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 |
20120084762 | FINE-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 |
20120084763 | IDENTIFYING 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 |
20120102473 | ABSTRACT 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 |
20120110561 | STRUCTURE 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 |
20120174082 | REFACTORING 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 |
20120198427 | Ensuring 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 |
20120204163 | System 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 |
20120260240 | SOFTWARE 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 |
20120272224 | INLINE 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 |
20120284701 | EFFICIENT 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 |
20120297373 | METHODS 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 |
20120311549 | NON-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 |
20120311550 | METHOD 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 |
20120317559 | Thin-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 |
20120317560 | METHOD 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 |
20120324430 | ALIASING 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 |
20130019231 | DISTRIBUTED 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 |
20130019232 | MANAGING 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 |
20130061214 | PROGRAMMABLE 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 |
20130067444 | RECONFIGURABLE 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 |
20130086567 | Execution 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 |
20130104112 | Pre-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 |
20130117735 | ALGORITHM FOR 64-BIT ADDRESS MODE OPTIMIZATION - One embodiment of the present invention sets forth a technique for extracting a memory address offset from a 64-bit type-conversion expression included in high-level source code of a computer program. The technique involves receiving the 64-bit type-conversion expression, where the 64-bit type-conversion expression includes one or more 32-bit expressions, determining a range for each of the one or more 32-bit expressions, calculating a total range by summing the ranges of the 32-bit expressions, determining that the total range is a subset of a range for a 32-bit unsigned integer, calculating the memory address offset based on the ranges for the one or more 32-bit expressions, and generating at least one assembly-level instruction that references the memory address offset. | 05-09-2013 |
20130145354 | SHARING 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 |
20130167129 | SYSTEMS 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 |
20130185704 | PROVIDING 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 |
20130198729 | AUTOMATED 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 |
20130205284 | OWNERSHIP 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 |
20130205285 | METHODS 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 |
20130205286 | RUNTIME 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 |
20130290942 | METHOD, COMPUTER, AND COMPUTER PROGRAM FOR SPECULATIVELY OPTIMIZING CODE - A method, computer, and computer program for speculatively optimizing a code. The method includes speculatively optimizing the code characterized by searching in a predetermined order in at least one dictionary; extracting a value associated with a symbol name from a dictionary using the symbol name as a key; performing optimization to replace a symbol in the code with the value; compiling the code to be compiled including some or all of the optimized code; comparing, in response to detection of a change related to one dictionary among at least one dictionary, an order m in the predetermined order of the dictionary with the detected change to an order n of the dictionary with the extracted value; and invalidating the optimized code in the compiled code associated with the dictionary having the detected change in response to the results from the orders comparison and the type of change. | 10-31-2013 |
20130318510 | COMPILING CODE FOR AN ENHANCED APPLICATION BINARY INTERFACE (ABI) WITH DECODE TIME INSTRUCTION OPTIMIZATION - Generating decode time instruction optimization (DTIO) object code that enables a DTIO enabled processor to optimize execution of DTIO instructions. A code sequence configured to facilitate DTIO in a DTIO enabled processor is identified by a computer. The code sequence includes an internal representation (IR) of a first instruction and an IR of a second instruction. The second instruction is dependent on the first instruction. A schedule associated with at least one of the IR of the first instruction and the IR of the second instruction is modified. The modifying includes generating a modified schedule that is configured to place the first instruction next to the second instruction. An object file is generated based on the modified schedule. The object file includes the first instruction placed next to the second instruction. The object file is emitted. | 11-28-2013 |
20130346953 | OPENCL COMPILATION - Systems and methods for increasing speed and reducing processing power of a compile process of programmable logic of an integrated circuit (IC) are provided. For example, in one embodiment, a method includes obtaining a high level program, comprising computer-readable instructions for implementation on programmable logic of an integrated circuit (IC); translating the high level program into low level code representative of functional components needed to execute functionalities of the high level program; generating a host program comprising computer-readable instructions for implementing the low level code based upon the high level program; obtaining modifications to the high level program; determining whether the modifications can be implemented by a new host program utilizing the low level code; and generating the new host program to implement the modifications, when the modifications can be implemented by the new host program utilizing the low level code. | 12-26-2013 |
20140047422 | COMPILER-GUIDED SOFTWARE ACCELERATOR FOR ITERATIVE HADOOP JOBS - Various methods are provided directed to a compiler-guided software accelerator for iterative HADOOP jobs. A method includes identifying intermediate data, generated by an iterative HADOOP application, below a predetermined threshold size and used less than a predetermined threshold time period. The intermediate data is stored in a memory device. The method further includes minimizing input, output, and synchronization overhead for the intermediate data by selectively using at any given time any one of a Message Passing Interface and Distributed File System as a communication layer. The Message Passing Interface is co-located with the HADOOP Distributed File System. | 02-13-2014 |
20140089908 | Decision Tree Ensemble Compilation - In one embodiment, a decision tree is evaluated in interpreted mode while statistics are collected. The decision tree is then represented as source code, and each decision in the decision tree is annotated with instructions determined based on the collected statistics. The source code is compiled into machine code, and the machine code is optimized based on the instructions annotating each decision in the decision tree. | 03-27-2014 |
20140130025 | COMPILER OPTIMIZATION BASED ON COLLECTIVITY ANALYSIS - An embodiment is directed to determining, by a compiler, that a call to a named barrier is matched across all of a plurality of threads, and based at least in part on determining that the call to the named barrier is matched across all of the plurality of threads, replacing, by the compiler, the named barrier with an unnamed barrier. | 05-08-2014 |
20140130026 | OPERAND AND LIMITS OPTIMIZATION FOR BINARY TRANSLATION SYSTEM - Methods and systems for optimizing generation of natively executable code from non-native binary code are disclosed. One method includes receiving a source file including binary code configured for execution according to a non-native instruction set architecture. The method also includes translating one or more code blocks included in the executable binary code to source code, and applying an optimizing algorithm to instructions in the one or more code blocks. The optimizing algorithm is selected to reduce a number of memory address translations performed when translating the source code to native executable binary code, thereby resulting in one or more optimized code blocks. The method further includes compiling the source code to generate an output file comprising natively executable binary code including the one or more optimized code blocks. | 05-08-2014 |
20140130027 | DATA PLACEMENT FOR EXECUTION OF AN EXECUTABLE - According to one embodiment, a system including a compiler to produce an executable module to be executed by a computer system including a main processor and active memory devices is provided. The system configured to perform a method including dividing source code into code sections, identifying a first code section to be executed by the active memory devices and identifying data structures that are used by the first code section. The method also includes classifying the data structures based on pre-defined attributes, formulating, by the compiler, a storage mapping plan for the data structures based on the classifying and generating, by the compiler, mapping code that implements the storage mapping plan, wherein the mapping code is part of the executable module and wherein the mapping code maps storing of the data structures to storage locations in the active memory devices. | 05-08-2014 |
20140157248 | CONVERSION APPARATUS, METHOD OF CONVERTING, AND NON-TRANSIENT COMPUTER-READABLE RECORDING MEDIUM HAVING CONVERSION PROGRAM STORED THEREON - A conversion apparatus for converting a source code into a machine language code, includes an information obtainment unit that obtains profile information from the source code; a determination unit that determines an optimal position of a prefetch command for access to a multi-dimensional array of multiple loops having a nest level of two or greater, on the basis of the profile information; and a placement unit that places the prefetch command at the optimal position. | 06-05-2014 |
20140165047 | METHODS AND APPARATUS FOR DATA TRANSFER OPTIMIZATION - Methods, apparatus and computer software product for optimization of data transfer between two memories includes determining access to master data stored in one memory and/or to local data stored in another memory such that either or both of the size of total data transferred and the number of data transfers required to transfer the total data can be minimized. The master and/or local accesses are based on, at least in part, respective structures of the master and local data. | 06-12-2014 |
20140189665 | System For Applying Transformation To Improve Graph Analysis - A method for performing a neighbor-flipping transformation is provided. In one embodiment, a graph analysis program for computing a function relating to nodes in a directed graph is obtained and analyzed for neighborhood iterating operations, in which a function is computed over sets of nodes in the graph. For any detected neighborhood iterating operation, the method transforms the iterating operation by reversing the neighbor node relationship between the nodes in the operation. The transformed operation computes the same value for the function as the operation prior to transformation. The method alters the neighbor node relationship automatically, so that a user does not have to recode the graph analysis program. In some cases, the method includes construction of edges in the reverse direction while retaining the original edges in addition to performing the transformation. | 07-03-2014 |
20140245273 | PROTECTING THE INTEGRITY OF BINARY TRANSLATED CODE - The technologies provided herein relate to protecting the integrity of original code that has been optimized. For example, a processor may perform a fetch operation to obtain specified code from a memory. During execution, the code may be optimized and stored in a portion of the memory. The processor may obtain the optimized code from the portion of the memory. An entry of a first table may be modified to indicate a relationship between the particular code and the optimized code. One or more entries of a second table may be modified to specify the one or more physical memory locations. Each of the one or more entries of the second table may correspond to the entry of the first table. The processor may execute the optimized code when each of the one or more entries of the second table are valid. | 08-28-2014 |
20140245274 | DETERMINING A METHOD TO INLINE USING AN ACTUAL FOOTPRINT CALCULATION - Techniques for calculating the actual footprint of a computer-implemented method are disclosed. An example computer-implemented method includes a computer creating a map indicating to which code method each instruction included in compiled code belongs. This computer-implemented method also includes the computer sampling instructions executed using a hardware performance counter. This computer-implemented method also includes the computer mapping the sampled instructions to the code methods to which the instructions belong using the map. This computer-implemented method also includes the computer calculating the actual footprint of each code method as the total number of instructions sampled at least once among the instructions belonging to the code methods. | 08-28-2014 |
20140258996 | REDUCING EXCESSIVE COMPILATION TIMES - In one example, a device includes one or more processors configured to determine an allocated time for execution of an optimization pass for optimizing code for a software program, execute at least some instructions of the optimization pass on the code, and, in response to determining that an actual time for execution of the optimization pass has exceeded the allocated time for execution, preventing execution of subsequent instructions of the optimization pass. | 09-11-2014 |
20140258997 | DYNAMIC RECONFIGURABLE COMPILER - In one example, a device includes one or more processors configured to determine a set of optimization pass configuration data for code of a software program to be compiled, wherein the optimization pass configuration data defines a sequence of optimization passes for the software program during compilation, and execute the sequence of optimization passes on code for the software program based on the set of optimization pass configuration data. | 09-11-2014 |
20140282450 | SOFTWARE BUILD OPTIMIZATION - A method for optimization of a software build includes collecting first data representative of inputs for a build process obtained by a set of data accessing operations implemented during a first execution of the build process, the set including a file accessing operation and a non-file accessing operation. A redirection routine embedded within the build process captures the inputs. The first data is compared with second data representative of the inputs obtained in connection with a second execution of the build process. If the first and second data do not match, the second data is recorded in a data store and output data generated by the second execution of the build process is stored. If the first and second data match, output data generated by the first execution of the build process is used as an output for the second execution of the build process. | 09-18-2014 |
20140282451 | IDENTIFICATION AND MANAGEMENT OF UNSAFE OPTIMIZATIONS - Techniques for implementing identification and management of unsafe optimizations are disclosed. A method of the disclosure includes receiving, by a managed runtime environment (MRE) executed by a processing device, a notice of misprediction of optimized code, the misprediction occurring during a runtime of the optimized code, determining, by the MRE, whether a local misprediction counter (LMC) associated with a code region of the optimized code causing the misprediction exceeds a local misprediction threshold (LMT) value, and when the LMC exceeds the LMT value, compiling, by the MRE, native code of the optimized code to generate a new version of the optimized code, wherein the code region in the new version of the optimized code is not optimized. | 09-18-2014 |
20140310696 | TOOL-LEVEL AND HARDWARE-LEVEL CODE OPTIMIZATION AND RESPECTIVE HARDWARE MODIFICATION - The present invention relates to a method for compiling high-level software code into hardware, transforming each instruction into a respective hardware block and using an execution control signal representing the program pointer for triggering the execution within each respective hardware block. | 10-16-2014 |
20140317608 | METHOD FOR OPTIMIZING BINARY CODE IN LANGUAGE HAVING ACCESS TO BINARY CODED DECIMAL VARIABLE, AND COMPUTER AND COMPUTER PROGRAM - A method for optimizing binary code in a language having access to binary coded decimal variable. The method includes: generating a first compiler expression of the binary code; analyzing a use-definition and/or a definition-use for the first compiler expression; generating a second compiler expression by identifying logical binary coded decimal (BCD) variables in the first compiler expression; assigning temporary variables to the logical BCD variables, wherein the second compiler expression includes packed decimal operations and the assigned temporary variables; and converting a packed decimal operation in the second compiler expression and an assigned temporary variable to a decimal floating point (DFP) if sign information and precision information are not lost during conversion from BCD to DFP, wherein identifying logical BCD variables includes: in the use-definition and/or definition-use of operands, regarding an operand of definition and an operand of use as the same logical BCD variables. | 10-23-2014 |
20140331215 | INSERTING IMPLICIT SEQUENCE POINTS INTO COMPUTER PROGRAM CODE TO SUPPORT DEBUG OPERATIONS - Arrangements described herein relate to inserting implicit sequence points into computer program code to support debug operations. Optimization of the computer program code can be performed during compilation of the computer program code and, during the optimization, implicit sequence points can be inserted into the computer program code. The implicit sequence points can be configured to provide virtual reads of symbols contained in the computer program code when the implicit sequence points are reached during execution of the computer program code during a debug operation performed on the computer program code after the computer program code is optimized and compiled. | 11-06-2014 |
20140351801 | FORMAL VERIFICATION APPARATUS AND METHOD FOR SOFTWARE-DEFINED NETWORKING - The present invention relates to a formal technique-based verification apparatus and method for verifying software-defined networking. In accordance with an embodiment, a formal verification apparatus for Software-Defined Networking (SDN), includes a formal language creation unit for collecting flow table information for an entire network topology in response to a request of a SDN control unit, and creating description code in a predefined formal language based on the collected flow table information. A Symbolic Transition Graph (STG) generation unit generates a symbolic transition graph using the created description code in the formal language. A verification execution unit performs verification by applying formal verification technology to the symbolic transition graph. | 11-27-2014 |
20140359591 | DYNAMIC OPTIMIZATION OF PIPELINED SOFTWARE - In an embodiment, a system includes a processor including at least one core to execute operations of a loop that includes S stages. The system also includes stage insertion means for adding a delay stage to the loop to increase a lifetime of a corresponding register associated with a first variable of the loop and to delay storage of contents of the register. The system also includes a dynamic random access memory (DRAM). Other embodiments are described and claimed. | 12-04-2014 |
20140372996 | COMPILER OPTIMIZATION FOR MEMOIZATION OF PURE FUNCTION ARGUMENTS - Exemplary embodiments of the present invention disclose a method and system for replacing an unevaluated input that is constant at runtime to a group of instructions that calculates an output and can not modify the unevaluated input with invocation code that calls evaluation code. In a step, an exemplary embodiment identifies a group of instructions with an unevaluated input that is constant at runtime that calculates an output and can not modify the unevaluated input. In another step, an exemplary embodiment identifies an unevaluated input to the group of instructions that is constant at runtime. In another step, an exemplary embodiment generates an evaluation code that evaluates the unevaluated input. In another step, an exemplary embodiment replaces the unevaluated input with an invocation code that invokes the evaluation code. | 12-18-2014 |
20150026670 | Decision Tree Ensemble Compilation - In one embodiment, a decision tree is evaluated in interpreted mode while statistics are collected. The decision tree is then represented as source code, and each decision in the decision tree is annotated with instructions determined based on the collected statistics. The source code is compiled into machine code, and the machine code is optimized based on the instructions annotating each decision in the decision tree. | 01-22-2015 |
20150033214 | METHOD AND SYSTEM FOR COMPILER OPTIMIZATION - Aspects of the disclosure provide a method for code compilation. The method includes receiving instructions of a loop code for compiling, allocating one or more registers to variables before compiling the instructions into a loop body for the loop code, and compiling the instructions into the loop body based on the allocated registers. | 01-29-2015 |
20150317139 | METHODS TO ELIMINATE EXTRA MEMORY LOADS WHILE ACCESSING GLOBAL VARIABLES IN POSITION INDEPENDENT CODE - Methods for reducing memory loads for accessing global variables (globals) when creating executables for position independent (PI) code are disclosed. A first method includes compiling PI code, identifying globals, and determining whether globals are defined in the executable. If a global is not defined in the executable, a definition is created in the executable. A second method includes receiving a list of defined globals from instrumented PI code binary and comparing the list with globals in the PI code. Memory loads are created for globals that are unlisted. A third method includes compiling PI code with special relocations for globals and determining whether globals are defined in the executable. If the global is defined in the executable, the special relocation is replaced with a direct load of the global. If not, the special relocation is replaced with a two-instruction sequence that loads the global's address and then the global's value. | 11-05-2015 |
20150324213 | METHOD AND APPARATUS FOR PROVIDING HARDWARE SUPPORT FOR SELF-MODIFYING CODE - A method and apparatus for providing support for self modifying guest code. The apparatus includes a memory, a hardware buffer, and a processor. The processor is configured to convert guest code to native code and store converted native code equivalent of the guest code into a code cache portion of the processor. The processor is further configured to maintain the hardware buffer configured for tracking respective locations of converted code in a code cache. The hardware buffer is updated based a respective access to a respective location in the memory associated with a respective location of converted code in the code cache. The processor is further configured to perform a request to modify a memory location after accessing the hardware buffer. | 11-12-2015 |
20150339110 | GENERATING SIMD CODE FROM CODE STATEMENTS THAT INCLUDE NON-ISOMORPHIC CODE STATEMENTS - Generating SIMD code from code statements that include non-isomorphic code statements. Code statements are received, each code statement has one or more operators in a respective operator order and each operator has a type and associated operands. At least two code statements among the code statements received have an operator of the same type in a different operator order position. A first operator order position is identified for the operators of the same type in each of the code statements. For each of the code statements, code is generated for operators and their associated operands having operator order positions preceding the first operator order positions. SIMD code is generated at least based on the identified first operator order positions, the corresponding operator type, and the operands associated with the operator type at the identified operator order positions. | 11-26-2015 |
20150347104 | EXTENSIBLE 3D ASSET PLUG-IN FRAMEWORK - An extensible three-dimensional (3D) asset plug-in framework is disclosed. In various embodiments, files having different 3D file formats may be processed by respective plug-ins. The plug-ins may be configured to be downloaded and installed, to receive input files describing one or more 3D models and having a respective 3D file format, to read the respective 3D file format, and to generate and return a common 3D description to be previewed and manipulated by an application or an operating system. The different 3D file formats and their respective plug-ins may be proprietary or developed by third parties. | 12-03-2015 |
20150355891 | COMPUTER-BASED DISTRIBUTION OF LARGE SETS OF REGULAR EXPRESSIONS TO A FIXED NUMBER OF STATE MACHINE ENGINES FOR PRODUCTS AND SERVICES - A method for distributing sets of regular expressions to a fixed number of state machine engines includes combining, with a processing device, a plurality of regular expressions into a single compound regular expression, creating a single nondeterministic finite automaton (NFA) including a plurality of NFA states based on the compound regular expression, performing an interference analysis for each pair of NFA states to identify all pairs of NFA states that would potentially interfere in an equivalent deterministic finite automaton (DFA), creating an interference graph representing the regular expressions associated with potentially interfering NFA states based on the results of the interference analysis, and performing a graph coloring algorithm on the interference graph to assign a different color to each represented regular expression in the graph. | 12-10-2015 |
20150378695 | REPLACING ANNOTATED PROGRAM CODE IN A NETWORKED COMPUTING ENVIRONMENT - An approach for replacing one program code library (or method(s) thereof) with another program code library (or method(s) thereof) during execution is provided. Specifically, an annotation (e.g., comprising a runtime optimization request and associated performance/measurement criteria) within a program code file will be detected, analyzed, and used to monitor/assess the performance of a running set of methods of the program code file or the like (e.g., a set of initial/original methods). As this is occurring, a set of substitute methods will be identified from a program code library (e.g., based on similarities to the original set of methods) and likewise monitored/assessed. Based on the monitored performance, one or more alternate method(s) may be substituted for the original method(s) in the program code file. Such a capability allows for methods to be evaluated during runtime, and for performance to be optimized by utilizing the highest performing methods. | 12-31-2015 |
20160019034 | METHOD AND APPARATUS FOR COMPILING REGULAR EXPRESSIONS - Apparatus, systems, and methods for a compiler are described. One such compiler converts source code into an automaton comprising states and transitions between the states, wherein the states in the automaton include a special purpose state that corresponds to a special purpose hardware element. The compiler converts the automaton into a netlist, and places and routes the netlist to provide machine code for configuring a target device. | 01-21-2016 |
20160019037 | MANAGING PARAMETER TYPES FOR GENERIC FUNCTIONS - Embodiments are directed towards embodiments are directed towards managing parameter types for generic functions. During ahead-of-time (AOT) compilation of an application one or more generic functions may be encountered during compilation of the application. The AOT compiler may generate machine code for the encountered generic function. If parameter types associated with the encountered generic function are indefinite the AOT compiler may generate machine code that normalizes each parameter of the encountered generic function to conform to a shared version of the encountered generic function. Machine code may be generated for calling the shared version of the generic function with the normalized parameters. Machine code for calling the shared version of the generic function may be inserted and/or placed inside the machine code for the encountered generic function and inserted into a machine code version of the application. | 01-21-2016 |
20160026446 | CONTEXT-FREE TYPE RECORDING FOR VIRTUAL MACHINES OF DYNAMIC PROGRAMMING LANGUAGES - A method and a computing device for reducing deoptimization in a virtual machine are provided. Source code of a dynamically-typed program is compiled. A context-free type-state recorder records a first data type of a value associated with a particular named memory location within the source code. Optimized code may be generated based on the first data type of the value being a matching data type for global values associated with the particular named memory location. One or more global values associated with the particular named memory location may be type-checked. The context-free type-state recorder may record, if one or more of the global values associated with the particular named memory location is a different data type than the first data type, one or more different data types associated with the particular named memory location. New optimized code may then be generated. | 01-28-2016 |
20160110170 | MESSAGE INLINING - In certain embodiments, source code that includes at least one request to send an asynchronous message between state machines is obtained at a computing system. The computing system determines whether the asynchronous message can be implemented as an inlined message. Executable machine code corresponding to the source code is compiled such that the asynchronous message is compiled as an inlined message. | 04-21-2016 |
20160117156 | OPTIMIZATION OF SOFTWARE SYMBOL TABLES - A method, apparatus, and computer program product for optimizing software are provided. The software includes a plurality of modules which include at least one controllable module, the method comprises: determining a shared symbol defined by the at least one controllable module, the shared symbol being a symbol used by two or more modules of the software; generating a symbol use file indicating the shared symbol defined by the at least one controllable module; and rebuilding the software based on the symbol use file, so that a symbol table in a controllable module of the rebuilt software only contains the shared symbol indicated in the symbol use file. A number of symbols in the symbol table can be reduced accurately and effectively, thereby time needed for loading the symbol table can be reduced and software execution efficiency can be improved. | 04-28-2016 |
20160117157 | EAGER AND OPTIMISTIC EVALUATION OF PROMISES - The invention relates to a method for generating executable code from application source code. The method steps include determining a programmatic expression using the application source code and determining a first value for the programmatic expression. The method steps further include compiling the programmatic expression into a first optimized code portion using the first value, an assumption, and an expression scope. The method steps further include executing the application source code. The method steps further include determining that the programmatic expression is modified outside of the expression scope, invalidating the assumption, and de-optimizing the first optimized code portion. | 04-28-2016 |
20160154635 | METHOD FOR OPTIMIZING BINARY CODE IN LANGUAGE HAVING ACCESS TO BINARY CODED DECIMAL VARIABLE, AND COMPUTER AND COMPUTER PROGRAM | 06-02-2016 |
20160162267 | OPTIMIZING IF STATEMENTS IN COMPUTER PROGRAMMING - A method for optimizing if statements in a program includes obtaining, by a processing device, for each of conditional expressions of a plurality of if statements in the program, a set of conditional expressions having an inclusion relation; computing, for each of the set, a position with low execution frequency in the program as a move destination of a conditional expression having an inclusion relation, using information of the set in which the conditional expression is included; and moving the conditional expression to the computed move destination of the conditional expression. | 06-09-2016 |
20160170724 | INTER-PROCEDURAL TYPE PROPAGATION FOR DEVIRTUALIZATION | 06-16-2016 |
20160179487 | METHOD RANKING BASED ON CODE INVOCATION | 06-23-2016 |
20160196122 | SYSTEMS AND METHODS FOR EFFICIENT DETERMINATION OF TASK DEPENDENCES AFTER LOOP TILING | 07-07-2016 |
20160378444 | Probabilistic Framework for Compiler Optimization with Multithread Power-Gating Controls - A probabilistic framework for compiler optimization with multithread power-gating controls includes scheduling all thread fragments of a multithread computer code with the estimated execution time, logging all time stamps of events, and sorting and unifying the logged time stamps. Time slices are constructed using adjacent time stamps of each thread fragment. A power-gating time having a component turned off for each time slice is determined. Power-gateable windows that reduce energy consumption of the time slice is determined according to the power-gating time. The compiler inserts predicated power-gating instructions at locations corresponding to the selected power-gateable windows into the power-gateable computer code. | 12-29-2016 |
20190146764 | USING COMMENTS OF A PROGRAM TO PROVIDE OPTIMIZATIONS | 05-16-2019 |