Entries |
Document | Title | Date |
20080229296 | WORK ANALYSIS DEVICE AND RECORDING MEDIUM RECORDING WORK ANALYSIS PROGRAM - A device analyzes a flow of a computer system by identifying transition relations each representing a relation between two of data sets that have been updated, based upon workflow information. Transition information indicate a number of occurrences of each transition relation, with respect to each analysis unit period. Change information indicates a change in the number of occurrences of each transition relation, by comparing the transition information for each analysis unit period between adjacent ones of the analysis unit periods. | 09-18-2008 |
20080235676 | Optimal Floating-Point Expression Translation Method Based on Pattern Matching - Embodiments of the present invention include code generation methods. In one embodiment, a table of patterns is generated. Each pattern in the table includes an FMA (fused multiply-add) DAG (Directed Acyclic Graph), a canonical form equivalent of the FMA DAG, and a shape corresponding to the canonical form equivalent. Incoming floating-point expressions are matched against the patterns in the table during compilation of a program to obtain optical sequences of FMA, FMS (fused multiply-subtract), and FNMA (fused negate multiply-add) instructions as compiled instructions for computing the floating point expressions. | 09-25-2008 |
20080320458 | Using Memory Usage to Pinpoint Sub-Optimal Code for Gaming Systems - Systems and methods for using memory usage to pinpoint sub-optimal code for gaming systems are provided herein. Memory usage characteristics, such as latency, cache misses, load-hit-store, memory address misuse, and wasted cache bandwidth are presented, preferably in a graphical format, to provide the developer with information for optimizing source code. A trace analysis is performed on source code undergoing optimization. Relevant data is extracted from the trace analysis, sorted as necessary, and presented to the user. The user may be presented with multiple results sorting mechanisms as well as ways to change the presentation of the results. | 12-25-2008 |
20090007086 | Compiler Optimization - Provides effective use of architecture-specific instructions. There is provided a compiler including: a target partial program detecting unit for detecting, from among a partial programs of the program to be optimized, a partial program including instructions corresponding to all instructions included in the pattern to be replaced as a partial program to be optimized; an instruction sequence transforming unit for transforming, in the partial program to be optimized, instructions other than those instructions corresponding to instructions included in the pattern to be replaced and those instructions having execution dependencies different from the pattern to be replaced, so that dependencies between instructions included in the partial program to be optimized match the pattern to be replaced; an instruction sequence replacing unit for replacing the partial program to be optimized transformed by the instruction sequence transforming unit with a target instruction sequence determined in accordance with the pattern to be replaced. | 01-01-2009 |
20090037893 | COVERAGE ANALYSIS TOOL FOR DATABASE-AWARE APPLICATIONS - Embodiments of the invention provide coverage analysis of database elements accessed by a software application, thus providing improved and more complete testing of database-aware applications. In one embodiment, database elements accessed by the software application are determined during a run-time test of the software application. | 02-05-2009 |
20090049436 | METHOD FOR VISUALIZING THE EXECUTION OF A SOFTWARE PROGRAM - A method for visualizing the execution of a software program especially in an embedded system. A plurality of interconnected program modules are displayed on a display device wherein at least one of the modules has at least two mutually exclusive different modes of functionality. A unique color is assigned to each mode of functionality. During the execution of the software program, the mode of functionality for each program module during execution of that module is selected as a function of software parameters of the software program. The color of the software module on the display device is then changed to correspond to the color assigned to the selected mode of functionality for the program modules during the execution of the program. | 02-19-2009 |
20090055812 | LDAP SERVER PERFORMANCE OBJECT CREATION AND USE THEREOF - A system in which a plurality of performance objects are stored in computer memory, where each performance objects contains at least one input template and a corresponding optimized code path program product. A template matcher intercepts an input set destined to a directory server, and then determines a match between the intercepted input set and one of the templates. A code path selector then retrieves the corresponding optimized code path program product stored in a performance object associated with the matched template. Finally, a code processor executes the retrieved optimized code path program product on the intercepted input set, and stores the result in a tangible computer media through alteration of a physical property of the media. | 02-26-2009 |
20090064117 | Device, System, and Method of Computer Program Optimization - Device, system, and method of computer program optimization. For example, an apparatus to analyze a plurality of versions of computer program includes: a code analyzer to determine one or more code differences between first and second versions of the computer program, based on at least one optimization log associated with at least one of the first and second versions of the computer program. | 03-05-2009 |
20090094589 | OPTIMIZING HEAP MEMORY USAGE - This disclosure provides a computing system and method to profile a program for finding potential optimization in heap usage by reducing lag and drag in lifetimes of heap memory blocks. The process consists of three steps. First, an instrumentation engine analyzes a given program, and inserts additional code at interesting locations to collect needed information. Second, when the instrumented program is executed on a set of test cases, runtime data is collected. Third, since this data could be relatively large for a complex and long running program, data is processed to present it to a user in useful ways so that the programmer can improve the heap utilization in the program. | 04-09-2009 |
20090106745 | Method and Apparatus for Optimizing Software Program Using Inter-Procedural Strength Reduction - Inter-procedural strength reduction is provided by a mechanism of the present invention to optimize software program. During a forward pass, the present invention collects information of global variables and analyzes the information to select candidate computations for optimization. During a backward pass, the present invention replaces costly computations with less costly or weaker computations using pre-computed values and inserts store operations of new global variables to pre-compute the costly computations at definition points of the global variables used in the costly computations. | 04-23-2009 |
20090119654 | COMPILER FOR OPTIMIZING PROGRAM - A compiler system and method for calculating a value to be assigned to a variable for optimizing a program. The apparatus includes a subrange analysis unit for analyzing, for an instruction to assign a value to a variable in the program, a range of the value being assignable to the variable by the instruction, as a subrange of the variable in a case where instruction is executed; a determination unit for determining if the execution result of the program changes if the instruction assigns any value in the subrange of the variable to the variable on the basis of the analyzed subrange of the variable; and a replacement unit for replacing the instruction to assign the value to the variable with an instruction to assign a constant value in the subrange of the variable to the variable. | 05-07-2009 |
20090144712 | PATH SPECIALIZATIONS FOR RUNTIME CODE WITH PHASE BEHAVIOR - Mechanism that employs code cloning and specialized code execution for barriers to minimize runtime overhead. This is facilitated by duplicating code and inserting specializations of the barriers in the code copies. The mechanism is effective for garbage collection when the garbage collection executes through different phases, and the barrier behavior and overheads depend on these phases. The duplicated and specialized code enables the program to run efficiently by reducing the dynamic count of a phase check when the phase is well-known and phase checks can be avoided. | 06-04-2009 |
20090158262 | EFFICIENT COMPILATION AND EXECUTION OF IMPERATIVE-QUERY LANGUAGES - A system which combines sequential and iterative source code is provided. The system decides which type of processing would be most suitable for all portions of the source code, regardless of type. The system can adjust that decision based on the specific nature of the constructs within the source code, and can also adjust that decision based on the platform upon which the resulting executable program will run. | 06-18-2009 |
20090158263 | DEVICE AND METHOD FOR AUTOMATICALLY OPTIMIZING COMPOSITE APPLICATIONS HAVING ORCHESTRATED ACTIVITIES - A device (D) is intended for optimizing composite applications comprising at least two orchestrated activities participating to at least one process. This device (D) comprises i) an analyzing means (AM) arranged for determining orchestrated activities contained into a composite application to be optimized and dependencies between these activities, and ii) an optimizing means (OM) arranged for determining a new orchestration between the determined activities which allows the composite application to execute requests of users in a minimal time, according to the determined dependencies and to predefined rules, and for outputting an optimized composite application based on the new orchestration. | 06-18-2009 |
20090164984 | ANALYSIS OF A LEGACY SOURCE CODE APPLICATION - A method of analyzing a legacy source code application is described. The method comprises traversing a generated set of entries of a module hash array, a summary count catalog, and an occurrence location catalog to determine duplicate lines of code of the legacy source code application. The method also comprises determining a duplicate sequence of one or more lines of code with respect to at least one other sequence of one or more lines of code of the legacy source code application based on traversal of the generated set of entries of the module hash array, the summary count catalog, and the occurrence location catalog. The method also comprises storing a match result identifying the determined duplicate sequence and the at least one other sequence. | 06-25-2009 |
20090187897 | COMPILING METHOD AND COMPILING PROGRAM - The compiling method and compiling program which can delete a redundantly generated function, regardless of whether or not a class object is generated and whether or not calling is performed is a compiling method for converting an input program written in an object-oriented language and having at least one class into an object program, and which includes: a virtual inheritance analyzing step of analyzing whether or not each class in the input program is defined by virtual inheritance; a special function consolidating step of generating a code which consolidates at least one of plural constructors and plural destructors of the class, in the case where, as a result of the analysis in the virtual inheritance analyzing step, the class is not defined by virtual inheritance; and a generating step of generating an object program including the code generated in the special function consolidating step. | 07-23-2009 |
20090228875 | Method and System for Reducing Disk Allocation by Profiling Symbol Usage - A system and method for executing an application, identifying a plurality of memory access operations performed by the application, logging a file and a memory address range within the file corresponding to the plurality of memory access operations and removing, from the file, a symbol that is not within the memory address range. | 09-10-2009 |
20090259998 | METHOD, SYSTEM AND COMPUTER PROGRAM FOR IDENTIFYING AND REUSING COMPONENT AGGREGATES - A method of automatically identifying entity aggregates for use in creating entity libraries is provided. The method includes: identifying one or more sub-entities of a first application; identifying one or more sub-entities of a second application; determining common usage patterns between the one or more sub-entities of the first application and the one or more sub-entities of the second application; and generating one or more entity aggregates based on the common usage patterns. | 10-15-2009 |
20090276765 | COMPILER DRIVEN MECHANISM FOR REGISTRATION AND DEREGISTRATION OF MEMORY PAGES - A method, system and article of manufacture are disclosed for registering and deregistering memory pages in a computer system. The method comprises the steps of hoisting register and deregister calls in a given routine where temporal locality is present to overlap computation and communication; using software pipelined registration and deregistration where spatial locality is observed; and using intra-procedural and inter-procedural analysis by a compiler of the computer system to deregister dynamically allocated buffers. The preferred embodiment of the invention is based on an optimizing compiler. The compiler is used to extract information such as addresses of buffers which are being reused repeatedly (temporal locality), preferably in a loop. The compiler may also find information about spatial locality, such as arrays whose indexes are used in a well-defined manner in a series of messages, for example, array pages being accessed in a pre-defined pattern in a loop. | 11-05-2009 |
20090300592 | AUTOMATED DIALOG COMPLIANCE MECHANISMS - Tools and techniques are described for automated dialog compliance mechanisms. Systems provided by this description may include toolkits for developing and debugging software code, with this code operative to create dialog boxes within a user interface. These systems may also include automated dialog compliance mechanisms for receiving requests from the toolkits to evaluate the code against guidelines specified across an enterprise and applicable to constructing the dialog boxes. | 12-03-2009 |
20090313615 | POLICY-BASED PROGRAM OPTIMIZATION TO MINIMIZE ENVIRONMENTAL IMPACT OF SOFTWARE EXECUTION - A method for policy-based program optimization of existing software code is performed where the code is segmented into code modules. The optimization is based on a performance policy that defines a target characteristic and a sacrificial characteristic relating to the existing software code and further defines an allowable degradation of the sacrificial characteristic resulting from optimization of the target characteristic. This method may include identifying code modules that contribute to suboptimal performance of the software code with respect to the target characteristic; identifying code transformations that increase performance of the suboptimal code modules with respect to the target characteristic; and optimizing the identified code modules by selectively applying the code transformations in accordance with the performance policy to increase performance of the software code with respect to the target characteristic. | 12-17-2009 |
20090320009 | DECOUPLING DYNAMIC PROGRAM ANALYSIS FROM EXECUTION IN VIRTUAL ENVIRONMENTS - Dynamic program analysis is decoupled from execution in virtual computer environments so that program analysis can be performed on a running computer program without affecting or perturbing the workload of the system on which the program is executing. Decoupled dynamic program analysis is enabled by separating execution and analysis into two tasks: (1) recording, where system execution is recorded with minimal interference, and (2) analysis, where the execution is replayed and analyzed. | 12-24-2009 |
20090320010 | SYNCHRONOUS DECOUPLED PROGRAM ANALYSIS IN VIRTUAL ENVIRONMENTS - Dynamic program analysis is decoupled from execution in virtual computer environments and is carried out synchronously with program execution. Decoupled dynamic program analysis is enabled by separating execution and analysis into two tasks: (1) recording, where system execution is recorded with minimal interference, and (2) analysis, where the execution is replayed and analyzed. Synchronous decoupled program analysis is enabled by suspending execution or data outputs of the program until a confirmation is received that the analysis is in sync with the program execution. | 12-24-2009 |
20090320011 | ACCELERATING REPLAYED PROGRAM EXECUTION TO SUPPORT DECOUPLED PROGRAM ANALYSIS - A virtual machine system decouples dynamic program analysis from program execution. Program analysis is decoupled from program execution through the use of a virtual machine to record program execution and an analysis platform to replay and analyze the program execution. Optimization techniques are applied to prevent the analysis platform from falling too far behind the program execution platform during replay. | 12-24-2009 |
20090328018 | OPTIMIZING PRIMITIVES IN SOFTWARE TRANSACTIONAL MEMORY - A compiler is provided that determines when the use of software transactional memory (STM) primitives may be optimized with respect to a set of collectively dominating STM primitives. The compiler analysis coordinates the use of variables containing possible shadow copy pointers to allow the analysis to be performed for both direct write and buffered write STM systems. The coordination of the variables containing the possible shadow copy pointers ensures that the results of STM primitives are properly reused. The compiler analysis identifies memory accesses where STM primitives may be eliminated, combined, or substituted for lower overhead STM primitives. | 12-31-2009 |
20100037214 | METHOD AND SYSTEM FOR MPI_WAIT SINKING FOR BETTER COMPUTATION-COMMUNICATION OVERLAP IN MPI APPLICATIONS - A computer implemented method is provided for optimizing at the time of compiling a program that employs a message-passing interface (MPI). The method includes: detecting an MPI application source file; identifying a non-blocking communication within the MPI application source file; and overlapping independent computation concurrently with the non-blocking communication. A system is also provided. | 02-11-2010 |
20100050163 | CACHING RUN-TIME VARIABLES IN OPTIMIZED CODE - In one embodiment, the present invention includes a method for emitting a live range statement into a program for a memory variable to be cached during run-time that has at least one simulation state variable if the memory variable is dynamically mapped, and defining the simulation state variable at a first execution path of the program. In such manner, the program may be optimized using the live range statement and the simulation state variable. Also, a debugger may use the simulation state variables in obtaining and displaying the memory variable from a cache. | 02-25-2010 |
20100095285 | Array Reference Safety Analysis in the Presence of Loops with Conditional Control Flow - Mechanisms are provided for analyzing and optimizing loops with conditional control flow in source code based on array reference safety. Mechanisms are provided for analyzing blocks of the source code to identify a conditional control flow loop having loop source code specifying a total access range for an array reference. A safe access range, of the total access range of the array reference in the loop source code, is identified over which a compiler-based optimization of the loop source code can be safely applied without introducing new exception conditions. The compiler-based optimization of the loop source code is performed based on the identified safe access range to generate optimized code. The optimized code is output for generation of executable code for execution on a processor. | 04-15-2010 |
20100138819 | TYPE MERGING TECHNIQUE TO REDUCE CLASS LOADING DURING JAVA VERFICATION - An apparatus, process, and computer program product to merge types in an object-oriented program is disclosed herein. In one embodiment, a process may include analyzing a method within an object-oriented program to identify merge candidates. These merge candidates may then be recorded in a merge candidate list. The process may further include identifying at least two code paths in the method that merge into a single code path and that operate on different types. The types in these code paths may then be merged to a nearest common superclass listed in the merge candidate list. In selected embodiments, the types may be merged to the java.lang.Object class in the event the merge candidate list is empty. | 06-03-2010 |
20100162219 | Diagnosing Aliasing Violations in a Partial Program View - A compiler generated static analysis of potential aliasing violations in a portion of code that is not in the current program view of the analysis. Source code in a current program view of the program code is processed to collect symbol definitions. The possible destinations of each symbol definition are computed. The set of symbol definitions in the current program view of the code that are accessible to the portion of the program code outside the current program view is evaluated. Each symbol definition is diagnosed based on the type of the symbol defined and the symbols which may be pointed-to by the symbol definitions. | 06-24-2010 |
20100169872 | Use of Name Mangling Techniques To Encode Cross Procedure Register Assignment - Optimizing a program having a plurality of functions. The program is optimized using an optimization technique that requires breaking a calling convention. The first function of the plurality of functions is modified as a result of optimizing. A name of the first function is mangled to form a unique first mangled name. Mangling comprises changing the name. The unique first mangled name includes, as a result of mangling, first information conveying at least in part how the first function was modified. A second function of the plurality of functions, being a caller of the first function, is also modified to correctly invoke first function using the unique first mangled name to apply the optimization technique. A compilation tool can, after optimizing, use the first information to take a first action with respect to the first procedure, wherein the compilation tool otherwise would require the calling convention to remain unbroken in order to take the first action. | 07-01-2010 |
20100299661 | Load-Time Code Optimization In a Computing Environment - A method for optimizing program code is provided. The method comprises receiving a request to execute a computer program on a computer system; loading executable code generated for the computer program into memory; optimizing the executable code during the loading; and executing the optimized executable code. The executable code is optimized according to information collected about the computer system, and the optimized executable code and the collected information are stored for use during future optimization of the executable code. | 11-25-2010 |
20100325620 | EMBEDDED ANNOTATION AND PROGRAM ANALYSIS - Program source code is annotated to support dataflow analysis or other program analysis, without requiring changes to compilers. Annotation statements are embedded inside comments or other non-code-generative portions of the source code. The annotations can be used to express contracts at routine boundaries, allowing an analyzer to check the global correctness of the source code through modular (local) analysis, with performance that is linear in the number of routines. In particular, annotated SQL source code may be analyzed to identify SQL injection vulnerabilities. | 12-23-2010 |
20110029961 | NATIVE CODE MODULE SECURITY FOR ARM INSTRUCTION SET ARCHITECTURES - Some embodiments provide a system that executes a native code module. During operation, the system obtains the native code module. Next, the system loads the native code module into a secure runtime environment. Finally, the system safely executes the native code module in the secure runtime environment by using a set of software fault isolation (SFI) mechanisms that constrain store instructions in the native code module. The SFI mechanisms also maintain control flow integrity for the native code module by dividing a code region associated with the native code module into equally sized code blocks and data blocks and starting each of the data blocks with an illegal instruction. | 02-03-2011 |
20110099542 | Controlling Compiler Optimizations - In an embodiment, a conditional branch is detected that selects between execution of a first alternative block and a second alternative block. A first count and a second count are saved, where the first count is a number of times the first alternative block was executed, and the second count is a number of times the second alternative block was executed. If the first count is greater than a threshold and the second count equals zero, the first alternative block is compiled into first alternative block object code and the second alternative block is not compiled. If the first count is not greater than the threshold, the first alternative block is compiled into the first alternative block object code and the second alternative block is compiled into second alternative block object code. | 04-28-2011 |
20110119661 | Automated Determination of Quasi-Identifiers Using Program Analysis - A system and method for automated determination of quasi-identifiers for sensitive data fields in a dataset are provided. In one aspect, the system and method identifies quasi-identifier fields in the dataset based upon a static analysis of program statements in a computer program having access to—sensitive data fields in the dataset. In another aspect, the system and method identifies quasi-identifier fields based upon a dynamic analysis of program statements in a computer program having access to—sensitive data fields in the dataset. Once such quasi-identifiers have been identified, the data stored in such fields may be anonymized using techniques such as k-anonymity. As a result, the data in the anonymized quasi-identifiers fields cannot be used to infer a value stored in a sensitive data field in the dataset. | 05-19-2011 |
20110138372 | REGISTER PRESPILL PHASE IN A COMPILER - The present disclosure provides a compiler prespill phase that reduces or eliminates excessive register pressure, or locations in the code of a program where live virtual registers exceeds physical registers of a target computing device, prior to register allocation. The prespill phase identifies points of excessive register pressure, selects candidate virtual registers, chooses virtual registers to prespill from the candidates, and inserts spill and reload instructions to prespill the chosen registers. The prespill phase may reduce the register pressure such that the live virtual registers only exceed the physical registers by a particular number, the live virtual registers equal the physical registers, or the physical registers exceed the live virtual registers by a particular number. The compiler may then perform one or more early and/or late instruction scheduling phases, including global and/or local instruction scheduling, to optimize the placement of the spill and reload instructions. | 06-09-2011 |
20110145803 | EXTENSION MECHANISM - A system and method for executing a user agent in an electronic device. Upon each startup of the user agent, the electronic device loads binary code of a base version of the user agent into memory, and determines whether a binary patch has previously been downloaded. If the patch has been downloaded, it is applied to the base version and the updated base version is executed. The binary patch may be downloaded from a server, which compiles the binary patch on the basis of stored source code of the base version and stored source code of one or more enhancements selected by the electronic device. | 06-16-2011 |
20110154310 | Performance Analysis Of Software Executing In Different Sessions - A technique includes providing first objects that are associated with an application session and in a processor-based system, identifying second objects in another application session corresponding to the first objects based at least in part on a comparison of the second objects to matching rules associated with the first objects. | 06-23-2011 |
20120311552 | RUNTIME OPTIMIZATION OF APPLICATION BYTECODE VIA CALL TRANSFORMATIONS - A method and system for optimizing application code via transformation of calls made by the application code during runtime. A computer system loads the application code that has been intermediately compiled into bytecode. The computer system then compiles and executes the application code. During runtime, the application code makes a call from a call site to an implementation of an operation that returns a value to the application code. The computer system runs an implementer of the implementation and an agent that operates independently of a compiler. The agent receives a notification of the call, performs an analysis on the application code during runtime to determine whether the value is used by the application code, and optimizes the application code by transforming the call site based on a result of the analysis. | 12-06-2012 |
20130031537 | Specialized Function Implementation Using Code Frequency Profiling - Systems, methods and products for code optimization are provided. In one embodiment, the method comprises dividing a target code into basic blocks; analyzing traversed execution paths between the basic blocks during multiple executions of the target code to determine a frequency with which the execution path between two or more basic blocks are traversed; and determining whether code optimization may be achieved by identifying execution paths that have been traversed subject to one or more threshold levels. | 01-31-2013 |
20130086568 | OPTIMIZATIONS USING A BPEL COMPILER - Various arrangements for reducing a size of a Business Process Execution Language (BPEL) data blob for storage may be presented. One or more dehydration points within compiled BPEL code may be identified. A liveness analysis for the one or more dehydration points may be performed. At each of the one or more dehydration points, one or more live variables from a set of variables may be identified. An optimization data structure may be created for each dehydration point identifies the one or more live variables. | 04-04-2013 |
20130205287 | Reducing Application Startup Time by Optimizing Spatial Locality of Instructions in Executables - Provided are techniques for parsing source code file into a plurality of functions; generating a ranking corresponding to each of the plurality of functions based upon an order of occurrence in the source code file; generating a weight score corresponding to each of the plurality of functions based upon a weighing factor and the occurrence of a condition corresponding to each of the plurality of functions; and generating an object code file such that the plurality of functions are ordered in the object code file based upon the corresponding rankings and weight scores such during a startup of execution of the object code file a startup time is minimized with respect to an object code file not generated in accordance with the claimed method. | 08-08-2013 |
20130227536 | Increasing Performance at Runtime from Trace Data - An analysis system may perform network analysis on data gathered from an executing application. The analysis system may identify relationships between code elements and use tracer data to quantify and classify various code elements. In some cases, the analysis system may operate with only data gathered while tracing an application, while other cases may combine static analysis data with tracing data. The network analysis may identify groups of related code elements through cluster analysis, as well as identify bottlenecks from one to many and many to one relationships. The analysis system may generate visualizations showing the interconnections or relationships within the executing code, along with highlighted elements that may be limiting performance. | 08-29-2013 |
20130275954 | INTER-PROCEDURAL UNREACHABLE CODE ELIMINATION WITH USE GRAPH - Methods, apparatuses, and computer readable media for unreachable code identification and removal. A method includes generating a Use Graph for a program. Generating the Use Graph includes identifying global identifiers within the program, creating a node in the Use Graph for each of the global identifiers, traversing the program to identify each use of a global identifier, and creating edges in the Use Graph corresponding to each identified use of a global identifier. The method includes storing usee global identifiers identified from the Use Graph, and determining unused global identifiers corresponding to identified global identifiers that are not usee global identifiers. The method includes removing unreachable software code associated with the unused global identifiers from the program to produce a revised program and storing the revised program. | 10-17-2013 |
20140059524 | Compile Time Execution - When compiling high level, graphical code (e.g. LabVIEW™ code) representative of a design, parts of the code that do not depend on external input data may be executed during the compilation process. Specific variables and/or value traces of specific variables in the program, e.g. constant values and/or repeating patterns may be recorded then analyzed, and certain transformations may be applied in the compilation process according to the results of the analysis, thereby optimizing the design. In one approach, the graph may be dynamically stepped through one node at a time, and it may be determined whether all inputs to the stepped-through node are known. If those inputs are known, type conversion and the operation corresponding to the stepped-through node may be dynamically performed. In another approach, a subset of the graphical code not depending on external data may be compiled and executed, thereby obtaining the same results as described above. | 02-27-2014 |
20140196018 | 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. | 07-10-2014 |
20140282453 | SYSTEMS AND METHODS FOR FACILITATING APPLICATION DEVELOPMENT UTILIZING PLUGINS - Systems, apparatus, methods, and articles of manufacture provide for determining at least one criterion for establishing an offer campaign based on a player's experience on gaming platform (e.g., via a gaming website) and/or determining whether a player qualifies for one or more offers based on the player's experience. | 09-18-2014 |
20140310697 | COMPILATION OF TRANSFORMATION IN RECALCULATION USER INTERFACE - The compilation a transformation chain of a recalculation user interface that displays an electronic canvas that contains one or more displayed result of a transformation chain. The transformation chain includes transforms between a respective data source and data sink. User editing of the recalculation user interface could cause one or more of the transforms to be re-executed, thereby causing recalculation. The compilation involves analyzing the transformation chain of the recalculation user interface for dependencies to create a dependency graph of dependencies between entities. For instance, some dependencies might be between entities so as to indicate that if one entity is evaluated, then the other should be also. The dependency graph is then used to create a lower level of execution steps. The dependency graph is further provided to a runtime for the program, so that the dependency graph may be available during operation of the recalculation user interface. | 10-16-2014 |
20140366009 | Reducing Application Startup Time by Optimizing Spatial Locality of Instructions in Executables - Provided are techniques for parsing source code file into a plurality of functions generating a ranking corresponding to each of the plurality of functions based upon an order of occurrence in the source code file; generating a weight score corresponding to each of the plurality of functions based upon a weighing factor and the occurrence of a condition corresponding to each of the plurality of functions; and generating an object code file such that the plurality of functions are ordered in the object code file based upon the corresponding rankings and weight scores such during a startup of execution of the object code file a startup time is minimized with respect to an object code file not generated in accordance with the claimed method. | 12-11-2014 |
20150067659 | Auto-Cloudifying Applications Via Runtime Modifications - An approach is provided in in which distributed runtime environment executes a software application that includes isolated runtime constructs corresponding to an isolated runtime environment. During the execution, the distributed runtime environment identifies isolated runtime constructs included in the software application and selects distributed runtime constructs corresponding to the isolated runtime constructs. In turn, the distributed runtime environment executes the distributed runtime constructs in lieu of executing the isolated runtime constructs. | 03-05-2015 |
20150074655 | ELIMINATING REDUNDANT REFERENCE COUNT OPERATIONS IN INTERMEDIATE REPRESENTATION OF SCRIPT CODE - The disclosure is related to optimizing generation of intermediate representation (IR) for a script code by eliminating redundant reference count code from the IR. The reference count code includes code that manages a reference count of an object, e.g., code that increments a reference count of the object (“incref code”) and an observer code which consumes or the execution of which depends on the reference count of the object. The IR is analyzed to identify redundant reference count code. Counters associated with the object are evaluated and upon satisfying the optimization criterion, the incref code is moved closer to the observer code. The incref code and the observer code that are adjacent to each other are identified as redundant code pair and the code pair is eliminated from the IR to generate an optimized IR. The optimized IR is further converted to an executable code. | 03-12-2015 |
20150121352 | IDENTIFICATION OF CODE SYNCHRONIZATION POINTS - An illustrative embodiment of a computer-implemented method for identification of code synchronization points collects locking data for a set of locks in a managed runtime environment associated with the processor to form a set of contended metrics and analyzes the set of contended metrics using a set of predetermined event triggers. The method further determines whether a threshold in a set of predetermined thresholds in the set of predetermined event triggers is met and identifies a particular form of call path capture for a lock associated with the predetermined event trigger identified as having met the predetermined threshold. Call path information for the lock is captured using the particular form of call path capture. | 04-30-2015 |
20150128116 | WEB-BASED SCAN-TASK ENABLED SYSTEM AND METHOD OF AND APPARATUS FOR DEVELOPING AND DEPLOYING THE SAME ON A CLIENT-SERVER NETWORK - An improved development and deployment environment and processes for developing and deploying object-oriented web-based scan-task enabled applications, wherein web-based scan-task enabled client computers use scan task specifications and task decoders to retrieve and decode a scan tasks encapsulated on each web page requested and received from a web server supported by an application server and database server, and then perform specified actions, including the display of web controls, required by the scan task script contained within the decoded scan task, corresponding to the served web page. | 05-07-2015 |
20150149987 | METHOD AND APPARATUS FOR COMPILER PROCESSING FOR A FUNCTION MARKED WITH MULTIPLE EXECUTION SPACES - A method for processing a function with a plurality of execution spaces is disclosed. The method comprises creating an internal compiler representation for the function. Creating the internal compiler representation comprises copying substantially all lexical tokens corresponding to a body of the function. Further, the creating comprises inserting the lexical tokens into a plurality of conditional if-statements, wherein a conditional if-statement is generated for each corresponding execution space of said plurality of execution spaces, and wherein each conditional if-statement determines which execution space the function is executing in. During compilation, the method finally comprises performing overload resolution at a call site of an overloaded function by checking for compatibility with a first execution space specified by one of the plurality of conditional if-statements, wherein the overloaded function is called within the body of the function. | 05-28-2015 |
20150309779 | SYSTEMS AND METHODS FOR POWER OPTIMIZATION OF PROCESSORS - A compilation system generates one or more energy windows in a program to be executed on a data processors such that power/energy consumption of the data processor can be adjusted in which window, so as to minimize the overall power/energy consumption of the data processor during the execution of the program. The size(s) of the energy window(s) and/or power option(s) in each window can be determined according to one or more parameters of the data processor and/or one or more characteristics of the energy window(s). | 10-29-2015 |
20150317137 | EXTENDING SUPERWORD LEVEL PARALLELISM - A computer identifies one or more pairs of scalar statements and performs a cost analysis of operations of each of the one or more pairs of scalar statements to determine both a benefit and a cost of operations. The computer determines, based, at least in part, on the cost analysis, a gain for each of the one or more pairs of scalar statements. The computer creates based, at least in part, on the gain, a sorted list of each of the one or more pairs of scalar statements and selects a first pair from the sorted list. The computer issues a query to a hash table using a statement of the first pair and selects from results received from the query, a second pair. The computer then extends, based, at least in part, on the second pair, the first pair to create a pack. | 11-05-2015 |
20150317141 | EXTENDING SUPERWORD LEVEL PARALLELISM - A computer identifies one or more pairs of scalar statements and performs a cost analysis of operations of each of the one or more pairs of scalar statements to determine both a benefit and a cost of operations. The computer determines, based, at least in part, on the cost analysis, a gain for each of the one or more pairs of scalar statements. The computer creates based, at least in part, on the gain, a sorted list of each of the one or more pairs of scalar statements and selects a first pair from the sorted list. The computer issues a query to a hash table using a statement of the first pair and selects from results received from the query, a second pair. The computer then extends, based, at least in part, on the second pair, the first pair to create a pack. | 11-05-2015 |
20150347105 | Combining Compute Tasks For A Graphics Processing Unit - Methods, systems and devices are disclosed to examine developer supplied graphics code and attributes at run-time. The graphics code designed for execution on a graphics processing unit (GPU) utilizing a coding language such as OpenCL or OpenGL which provides for run-time analysis by a driver, code generator, and compiler. Developer supplied code and attributes can be analyzed and altered based on the execution capabilities and performance criteria of a GPU on which the code is about to be executed. In general, reducing the number of developer defined work items or work groups can reduce the initialization cost of the GPU with respect to the work to be performed and result in an overall optimization of the machine code. Manipulation code can be added to adjust the supplied code in a manner similar to unrolling a loop to improve execution performance. | 12-03-2015 |
20160019038 | APPARATUS, METHOD, AND SYSTEM FOR PROVIDING A DECISION MECHANISM FOR CONDITIONAL COMMITS IN AN ATOMIC REGION - An apparatus and method is described herein for conditionally committing and/or speculative checkpointing transactions, which potentially results in dynamic resizing of transactions. During dynamic optimization of binary code, transactions are inserted to provide memory ordering safeguards, which enables a dynamic optimizer to more aggressively optimize code. And the conditional commit enables efficient execution of the dynamic optimization code, while attempting to prevent transactions from running out of hardware resources. While the speculative checkpoints enable quick and efficient recovery upon abort of a transaction. Processor hardware is adapted to support dynamic resizing of the transactions, such as including decoders that recognize a conditional commit instruction, a speculative checkpoint instruction, or both. And processor hardware is further adapted to perform operations to support conditional commit or speculative checkpointing in response to decoding such instructions. | 01-21-2016 |
20160026483 | SYSTEM FOR AN INSTRUCTION SET AGNOSTIC RUNTIME ARCHITECTURE - A system for an agnostic runtime architecture. The system includes a close to bare metal JIT conversion layer, a runtime native instruction assembly component included within the conversion layer for receiving instructions from a guest virtual machine, and a runtime native instruction sequence formation component included within the conversion layer for receiving instructions from native code. The system further includes a dynamic sequence block-based instruction mapping component included within the conversion layer for code cache allocation and metadata creation, and is coupled to receive inputs from the runtime native instruction assembly component and the runtime native instruction sequence formation component, and wherein the dynamic sequence block-based instruction mapping component receives resulting processed instructions from the runtime native instruction assembly component and the runtime native instruction sequence formation component and allocates the resulting processed instructions to a processor for execution. | 01-28-2016 |
20160110191 | STAGED POINTS-TO ANALYSIS FOR LARGE CODE BASES - A method, system, and computer-readable medium (CRM) for performing a staged points-to analysis of an object-oriented codebase, including obtaining the codebase and a points-to query, slicing the codebase to obtain a program slice, and performing a type analysis of the program slice to compute a type set. The method, system, and CRM include refining the program slice, after performing the type analysis, by resolving virtual dispatch sites based on the type set, and performing, after refining the program slice, a context-insensitive points-to analysis of the program slice to compute a first points-to set. The method, system, and CRM include re-refining the program slice, after performing the context-insensitive points-to analysis, by resolving the virtual dispatch sites based on the first points-to set, and performing, after re-refining the program slice, a context-sensitive points-to analysis of the program slice to compute a second points-to set, which is provided to a developer. | 04-21-2016 |
20160188305 | TECHNOLOGIES FOR LOW-LEVEL COMPOSABLE HIGH PERFORMANCE COMPUTING LIBRARIES - Technologies for generating composable library functions include a first computing device that includes a library compiler configured to compile a composable library and second computing device that includes an application compiler configured to compose library functions of the composable library based on a plurality of abstractions written at different levels of abstractions. For example, the abstractions may include an algorithm abstraction at a high level, a blocked-algorithm abstraction at medium level, and a region-based code abstraction at a low level. Other embodiments are described and claimed herein. | 06-30-2016 |