Class / Patent application number | Description | Number of patent applications / Date published |
717156000 | Using flow graph | 79 |
20080229297 | METHOD AND SYSTEM FOR REDUCING MEMORY REFERENCE OVERHEAD ASSOCIATED WITH TREADPRIVATE VARIABLES IN PARALLEL PROGRAMS - A computer implemented method, system and computer program product for accessing threadprivate memory for threadprivate variables in a parallel program during program compilation. A computer implemented method for accessing threadprivate variables in a parallel program during program compilation includes aggregating threadprivate variables in the program, replacing references of the threadprivate variables by indirect references, moving address load operations of the threadprivate variables, and replacing the address load operations of the threadprivate variables by calls to runtime routines to access the threadprivate memory. The invention enables a compiler to minimize the runtime routines call times to access the threadprivate variables, thus improving program performance. | 09-18-2008 |
20080282237 | Method and Apparatus For Generating Execution Equivalence Information - A method of compiling code includes identifying blocks of code that are execution equivalence pairs. Other embodiments are described and claimed. | 11-13-2008 |
20080301655 | PROGRAM ABSTRACTION BASED ON PROGRAM CONTROL - Embodiments described herein relate to determining an abstraction of a computer program and to the refinement of an abstraction of a computer program. The computer program may be a sequential program or may be a concurrent (parallel) program. A directed graph represents a computer program and may be the cross product of threads within a concurrent program. Nodes within a representation of a program are reduced to a single node to produce an abstraction. An abstraction may be refined by determining constraints that produce a refined abstraction that does not comprise infeasible paths. | 12-04-2008 |
20090007087 | PROGRAM ANALYZING METHOD, PROGRAM ANALYZING APPARATUS AND PROGRAM ANALYZING PROGRAM - A dependent element group which is invertibly contractible is found by using program analysis information including a plurality of dependent elements representing dependent relationships of statement and control, the statement and the control being included in a program. Next, a program dependence graph in which dependent elements are made to be contracted is generated by contracting the found dependent element group. The number of vertices and the number of edges of the program dependence graph are reduced by the contraction of the dependent elements, so that a program dependence graph with a rough granularity can be generated. As a result, a calculation amount (calculation time) necessary for optimization processing such as parallel processing of the program can be reduced. That is, by generating the contracted program dependence graph having invertibility, it is possible to realize the analysis and optimization of large-scale software in a realistic time. | 01-01-2009 |
20090019433 | METHOD AND SYSTEM FOR DESCRIBING WHOLE-PROGRAM TYPE BASED ALIASING - A compilation system for whole-program type based aliasing, the system includes: a set of hardware and networking resources; a front-end, a whole-program optimization component; a backend; an algorithm implemented on the set of hardware and networking resources; wherein the algorithm configures the front-end to a specific programming language being compiled and processes one source file at a time; wherein the whole-program optimization component merges the aliasing information from multiple invocations of the front-end into a single aliasing representation of a whole program; and wherein the backend uses that information to optimize and generate executable code that is the output of the compilation system. | 01-15-2009 |
20090044181 | Graphics Tools for Interactive Analysis of Three-Dimensional Machine Data - Methods for displaying machine data are described including a method for displaying machine data as a virtual three-dimensional image showing a three-dimensional graph having three axes such that the data in the graph may be rotated about one or more of the axes to give a data analyst a better perspective of the behavior of an item being monitored. In a related embodiment, a method for displaying machine data in a virtual three-dimensional image such that the data may be rotated one or more of the axes is described which further includes one or more cursor images representing substantially planar cursors on the display for analyzing data. | 02-12-2009 |
20090094590 | DETECTING CHANGE IN PROGRAM BEHAVIOR FOR ADAPTIVE CODE OPTIMIZATION - A computer implemented method, apparatus, and computer program product for generating an optimization insensitive behavior profile. In one embodiment, a source identifier is assigned to each instruction in an original control flow graph representing a program code prior to optimization. The identifiers identify a basic block associated with the instruction or a group of basic blocks. A source identifier in the set of source identifiers is assigned to instructions in an optimized control flow graph representing the program code after optimizing the program code. The instructions in the optimized control flow graph are mapped to the original control flow graph using the set of source identifiers to form a mapping transformation. Behavior profile data associated with the optimized program code is moved to basic blocks in the original control flow graph using the mapping transformation to form the optimization insensitive behavior profile. | 04-09-2009 |
20090125894 | Highly scalable parallel static single assignment for dynamic optimization on many core architectures - A method, system, and computer readable medium for converting a series of computer executable instructions in control flow graph form into an intermediate representation, of a type similar to Static Single Assignment (SSA), used in the compiler arts. The indeterminate representation may facilitate compilation optimizations such as constant propagation, sparse conditional constant propagation, dead code elimination, global value numbering, partial redundancy elimination, strength reduction, and register allocation. The method, system, and computer readable medium are capable of operating on the control flow graph to construct an SSA representation in parallel, thus exploiting recent advances in multi-core processing and massively parallel computing systems. Other embodiments may be employed, and other embodiments are described and claimed. | 05-14-2009 |
20090265696 | JUST-AHEAD-OF-TIME COMPILATION - Pre-compiling postdominating functions. Some embodiments may be practiced in a computing environment including a runtime compilation. For example one method includes acts for compiling functions. The method includes determining that a function of an application has been called. A control flow graph is used to determine one or more postdominance relationships between the function and one or more other functions. The one or more other functions are assigned to be pre-compiled based on the postdominance relationship. | 10-22-2009 |
20100023931 | Method and System for Intermediate Representation of Source Code - A method to provide effective control and data flow information in an Intermediate Representation (IR) form. A Path Sensitive single Assignment (PSA) IR form with effective and explicit control and data path information supports control flow sensitive optimizations such as path sensitive symbolic substitution, array privatization and speculative multi threading. In the definition of PSA form, besides defining new versioned variables, the gamma functions keep control path information. The gamma function in PSA form keeps the basic attribute of SSA IR form and only one definition exists for each use. Therefore, all existing Single Static Assignment (SSA) IR form based analysis can be applied in PSA form. The gamma function in PSA form keeps all essential control flow information and eliminates unnecessary predicates at the same time. | 01-28-2010 |
20100095286 | REGISTER REDUCTION AND LIVENESS ANALYSIS TECHNIQUES FOR PROGRAM CODE - A system and method for efficient architectural register liveness analysis and register usage reduction. A compiler within a computing system maintains a master liveness vector for each instruction in a program code and a path liveness vector for each path within a predetermined control flow graph (CFG). Predetermined required paths from an earlier compiler stage are used to find force paths, which are used to reduce the number of times a control block (CB) is processed. Upon completion of the liveness analysis, the compiler finds an instruction within the program code where a chosen register previously dead is now live. The compiler identifies allocation code paths from this instruction, wherein each path terminates at an instruction wherein the chosen register is dead for the first time in the allocation code path. The compiler subsequently replaces the chosen register with a determined dead register. | 04-15-2010 |
20100229162 | COMPILING APPARATUS, COMPILING METHOD, AND PROGRAM PRODUCT - A compiling apparatus includes an instruction-sequence-hierarchy-graph generating unit that generates an instruction sequence hierarchy graph by arraying unit graphs, to each of which a data path realized by a plurality of microinstructions included in one instruction sequence is to be allocated and in each of which function units included in a target processor are a node and a data line between the function units is an edge, to correspond to an execution order of a plurality of instruction sequences and by connecting arrayed unit graphs with an edge corresponding to a hardware path capable of establishing a data path across the instruction sequences; a data path allocating unit that allocates a data path to each of the unit graphs constituting the instruction sequence hierarchy graph; and an object program output unit that generates an instruction sequence group based on the data path allocated to the instruction sequence hierarchy graph. | 09-09-2010 |
20100293535 | Profile-Driven Data Stream Processing - Techniques for compiling a data stream processing application are provided. The techniques include receiving, by a compiler executing on a computer system, source code for a data stream processing application, wherein the source code comprises source code for a plurality of operators, each of which performs a data processing function, determining, by the compiler, one or more characteristics of operators within the data stream processing application, grouping, by the compiler, the operators into one or more execution containers based on the one or more characteristics, and compiling, by the compiler, the source code for the data stream processing application into executable code, wherein the executable code comprises a plurality of execution units, wherein each execution unit contains one or more of the operators, wherein each operator is assigned to an execution unit based on the grouping, and wherein each execution unit is to be executed in a partition. | 11-18-2010 |
20100325621 | PARTITIONING OPERATOR FLOW GRAPHS - Techniques for partitioning an operator flow graph are provided. The techniques include receiving source code for a steam processing application, wherein the source code comprises an operator flow graph, wherein the operator flow graph comprises a plurality of operators, receiving profiling data associated with the plurality of operators and one or more processing requirements of the operators, defining a candidate partition as a coalescing of one or more of the operators into one or more sets of processing elements (PEs), using the profiling data to create one or more candidate partitions of the processing elements, using the one or more candidate partitions to choose a desired partitioning of the operator flow graph, and compiling the source code into an executable code based on the desired partitioning. | 12-23-2010 |
20110055819 | System and Method for Optimizing Compiler Performance by Object Collocation - A computer-implemented method, system, and computer program product for performing object collocation on a computer system are provided. The method includes analyzing a sequence of computer instructions for object allocations and uses of the allocated objects. The method further includes creating an allocation interference graph of object allocation nodes with edges indicating pairs of allocations to be omitted from collocation. The method also includes coloring the allocation interference graph such that adjacent nodes are assigned different colors, and creating an object allocation at a program point prior to allocations of a selected color from the allocation interference graph. The method additionally includes storing an address associated with the created object allocation in a collocation pointer, and replacing a use of each allocation of the selected color with a use of the collocation pointer to collocate multiple objects. | 03-03-2011 |
20110067018 | COMPILER PROGRAM, COMPILATION METHOD, AND COMPUTER SYSTEM - A method, computer program product and system for improving performance of a program during runtime. The method includes reading source code; generating a dependence graph with a dependency for (1) data or (2) side effects; generating a postdominator tree based on the dependence graph; identifying a portion of the program able to be delayed using the postdominator tree; generating delay closure code; profiling a location where the location is where the delay closure code is forced; inlining the delay closure code into a frequent location in which the delay closure code has been forced with high frequency; partially evaluating the program; and generating fast code which eliminates an intermediate data structure within the program, where at least one of the steps is carried out using a computer device so that performance of the program during runtime is improved. | 03-17-2011 |
20110107315 | ABSTRACTING BENEFIT RULES FROM COMPUTER CODE - A method that includes: obtaining a computer code usable to process insurance claims; building a computer readable directed graph representing a control flow of the code, by identifying decisions and actions in the code, the graph comprising nodes connected by edges, some of the nodes being decision nodes associated with the decisions and some of the nodes being action nodes associated with the actions; determining, on the graph, benefit action nodes that are each associated with at least one monetary outcome of a specified insurance claim; identifying all logic paths that lead to each benefit action node by traversing the graph from each benefit action node backwards, each logic path comprising a sequence of preceding decision nodes and action nodes connected by edges, each set of paths being associated with a specified benefit action node representing a benefit rule; and outputting all benefit rules by presenting each specified benefit action vis à vis grouped logic paths associated with the specified benefit action. | 05-05-2011 |
20110191761 | Control Flow Analysis Using Deductive Reaching Definitions - A computer-implemented process for deductive reaching definition analysis receives a control flow graph to form a set of received blocks and edges, performs traditional reaching definitions to produce bit-vectors OUT(b), GEN(b) and KILL(b) for each block in the set of received blocks and receives impossibility indicators for a set of definitions that are impossible on specific edges. The computer-implemented process further performs deduction operations using a combination of the bit-vectors and impossibility indicators to deduce that additional definitions cannot reach certain blocks to create resulting reachability information and provides the resulting reachability information as a result to a requestor. A related system and program product is also provided. | 08-04-2011 |
20110225572 | COMPILER OPTIMISATION LIKE IDIOM RECOGNITION THROUGH PATTERN MATCHING USING VALUE NUMBERING - A compiler and method for compiling source code comprising: a library of code patterns and control flow information for each code pattern, wherein each code pattern comprises one or more variable; and a processor arranged to: evaluate the control flow of an expression in the source code, wherein the expression comprises one or more variable, match the expression to one of the code patterns in the library based on the evaluated control flow information, assign value numbers to the one or more variable within the expression, determine if the expression and the matched code pattern are equivalent based on the assigned value numbers, and replace the expression in the source code with a replacement expression if the expression and the matched code pattern are equivalent. | 09-15-2011 |
20120151461 | ANALYZING A POINTER IN AN ANALYSIS TARGET PROGRAM OR A PARTIAL PROGRAM - The present invention provides a technique for analyzing a pointer. The technique is characterized in detecting whether or not an object for which it is desired to detect an access position escapes to at least one method which is a caller of a method which generates the identified object (a first caller method) or at least one method which is called by the method which generates the identified object (a first callee method), and preparing a load node in a point-to graph and updating the point-to graph on condition that a field of at least one object in the point-to graph is reachable from the first caller method or the first callee method and the field is in a state of not pointing to an object in the point-to graph. | 06-14-2012 |
20120159465 | BUSINESS INTELLIGENCE DOCUMENT - A business intelligence (BI) document preserves references to identities and formats of remote data sources and allows a local computing device to offload analytical operations to remote data sources. The BI document specifies a graph of entities connected by directed edges from the output of one entity to an input of another entity. An entity, for example, can represent without limitation a data structure, an external data source, a control element, an external event source, a visualization, or an update service. The entities of a BI document at a local computing device can reference data at an original data source—rather than extracting data from the original data source to a preferred local datastore. An entity of the BI document can direct a remote data source to execute transformations on the remote data before returning a solution to the local computing device. | 06-21-2012 |
20120180032 | Implementing Portable Content Protection to Secure Secrets - A source-level compiler may randomly select compilation conventions to implement portable content protection, securing, the secrets embedded in a program by shuffling associated data. The program may be developed using a source language that is applicative on the associated data. To obscure the embedded secrets, in one embodiment, pre-compiler software may be deployed for compiling the program in a random-execution-order based on a random seed indication that randomly selects compilation conventions and a shuffling algorithm that moves the associated data across the program during execution. | 07-12-2012 |
20120254847 | REGISTER LIVENESS ANALYSIS FOR SIMD ARCHITECTURES - Systems and methods of allocating physical registers to variables may involve identifying a partial definition of a variable in an inter-procedural control flow graph. A determination can be made as to whether to terminate a live range of the variable based at least in part on the partial definition. Additionally, a physical register may be allocated to the variable based at least in part on the live range. | 10-04-2012 |
20120304161 | DETERMINING SUITABLE INSERTION POINTS FOR STRING SANITIZERS IN A COMPUTER CODE - A method of determining suitable insertion points for inserting string sanitizers in a computer code is provided herein. The method includes the following stages: obtaining: (i) a computer code associated with a data flow of externally supplied data, from one or more sources to one or more sinks, (ii) locations of the sources, and (iii) locations of the sinks; building a graph representing control paths, data paths and semantic relationships between the control paths and the data paths of the computer code; associating all tainted data paths on the graph, being data paths that go from sources to sinks and do not include a sanitizer; and determining, on the tainted data paths, potential control paths suitable for sanitizer insertion. | 11-29-2012 |
20130097592 | USER SELECTED FLOW GRAPH MODIFICATION - A computer implemented method and apparatus display an information integration flow graph, receive user input selecting a modification to apply to the displayed information integration flow graph and modify the information integration flow graph based on the selected modification to form a modified information integration flow graph, wherein the modified information integration flow graph is displayed. | 04-18-2013 |
20130139135 | OPTIMIZATION METHOD FOR COMPILER, OPTIMIZER FOR A COMPILER AND STORAGE MEDIUM STORING OPTIMIZING CODE - The invention pertains to an optimization method for a compiler, comprising providing a model of inter-operand constraints of physical registers of a target-platform of a compilation; and a) providing an intermediate representation of a source code using virtual registers; b) grouping the virtual registers of the intermediate representation based on the model of inter-operand constraints into two or more groups, each group comprising at least one virtual register; c) if for at least one group at least one interference of virtual registers within the group occurs, amending the intermediate representation to resolve at least one interference and jumping to step b); otherwise d) providing a representation of a group interference graph of interferences between the groups; and e) allocating virtual registers to physical registers using a coloring scheme on the representation of the group interference graph. The invention also refers to a corresponding optimizer for a compiler and a computer-readable storage medium storing optimizing code. | 05-30-2013 |
20130191818 | PROBABILISTIC POINTER ANALYSIS METHOD USING SSA FORM - A computer-implemented probabilistic pointer analysis method using SSA form comprises the steps of: evaluating a program in an SSA form comprising a target pointer to determine pointer relations between the target pointer, a plurality of aliased pointers related to the target pointer and at least a probable location of the target pointer; and generating a direct probabilistic relation between the target pointer and the at least a probable location of the target pointer according to the pointer relation. | 07-25-2013 |
20130239100 | Partitioning Operator Flow Graphs - Techniques for partitioning an operator flow graph are provided. The techniques include receiving source code for a stream processing application, wherein the source code comprises an operator flow graph, wherein the operator flow graph comprises a plurality of operators, receiving profiling data associated with the plurality of operators and one or more processing requirements of the operators, defining a candidate partition as a coalescing of one or more of the operators into one or more sets of processing elements (PEs), using the profiling data to create one or more candidate partitions of the processing elements, using the one or more candidate partitions to choose a desired partitioning of the operator flow graph, and compiling the source code into an executable code based on the desired partitioning. | 09-12-2013 |
20130305231 | Profile-Based Global Live-Range Splitting - A system is provided for splitting a live-range of a variable in frequently executed regions of program instructions. The live-range of a variable is split into multiple sub-ranges, each of which can be assigned to a different register or spilled into memory. The amount of spill code is reduced in frequently used regions of code by coalescing the live ranges based on profile information obtained after splitting the live ranges at every join and fork point in a control flow graph. | 11-14-2013 |
20130305232 | Profile-Based Global Live-Range Splitting - A computer program product is provided for splitting a live-range of a variable in frequently executed regions of program instructions. The live-range of a variable is split into multiple sub-ranges, each of which can be assigned to a different register or spilled into memory. The amount of spill code is reduced in frequently used regions of code by coalescing the live ranges based on profile information obtained after splitting the live ranges at every join and fork point in a control flow graph. | 11-14-2013 |
20140007062 | STRENGTH REDUCTION COMPILER OPTIMIZATIONS FOR OPERATIONS WITH UNKNOWN STRIDES | 01-02-2014 |
20140007063 | STRENGTH REDUCTION COMPILER OPTIMIZATIONS FOR CONDITIONAL OPERATIONS | 01-02-2014 |
20140007064 | STRENGTH REDUCTION COMPILER OPTIMIZATIONS FOR OPERATIONS WITH UNKNOWN STRIDES | 01-02-2014 |
20140007065 | STRENGTH REDUCTION COMPILER OPTIMIZATIONS FOR CONDITIONAL OPERATIONS | 01-02-2014 |
20140033186 | USING BUILD HISTORY INFORMATION TO OPTIMIZE A SOFTWARE BUILD PROCESS - Methods and systems for optimizing a build order of component source modules comprises creating a dependency graph based on dependency information. Historical build information associated with previous build failures is then used to calculate relative failure factors for paths of the dependency graph; and the relative failure factors are used to determine an order of traversal of the dependency graph during a build process in which component binary modules are built from the component source modules. | 01-30-2014 |
20140101643 | TRACE GENERATION METHOD, TRACE GENERATION DEVICE, TRACE GENERATION PROGRAM PRODUCT, AND MULTI-LEVEL COMPILATION USING TRACE GENERATION METHOD - A trace generation device including a directed graph generator configured to generate a directed graph in accordance with execution of compiled traces whose maximum length is limited to a certain length or shorter and that have been generated at a low optimization level, the directed graph representing transitions of execution between the compiled traces; a directed graph updater configured to traverse edges in the directed graph backward from a start point in timer-based sampling, the start point being a node corresponding to a trace in which a timer tick has occurred, and configured to increment a recompilation counter of a trace that the backward traversal has reached when stopping in front of a cyclic trace or at a trace not having any further edge; and a generator configured to determine the head of a corresponding trace as a head of a new trace. | 04-10-2014 |
20140165049 | COMPILER-CONTROLLED REGION SCHEDULING FOR SIMD EXECUTION OF THREADS - A compiler-controlled technique for scheduling threads to execute different regions of a program. A compiler analyzes program code to determine a control flow graph for the program code. The control flow graph contains regions and directed edges between regions. The regions have associated execution priorities. The directed edges indicate the direction of program control flow. Each region has a thread frontier which contains one or more regions. The compiler inserts one or more update predicate mask variable instructions at the end of a region. The compiler also inserts one or more conditional branch instructions at the end of the region. The conditional branch instructions are arranged in order of execution priority of the regions in the thread frontier of the region, to enforce execution priority of the regions at runtime. | 06-12-2014 |
20140223420 | CONVERGENCE ANALYSIS IN MULTITHREADED PROGRAMS - A basic block within a thread program is characterized for convergence based on mapping the basic block to an indicator subnet within a corresponding Petri net generated to model the thread program. Each block within the thread program may be similarly characterized. Each corresponding Petri net is enumerated to generate a corresponding state space graph. If the state space graph includes an exit node with an odd execution count attribute, such as by Petri net coloring, then the corresponding basic block is divergent. The corresponding basic block is convergent otherwise. Using this characterization technique, a thread program compiler may advantageously identify all convergent blocks within a thread program and apply appropriate optimizations to the convergent blocks. | 08-07-2014 |
20140344794 | Optimizing Compiler Performance by Object Collocation - A computer-implemented method, system, and computer program product for performing object collocation on a computer system are provided. The method includes analyzing a sequence of computer instructions for object allocations and uses of the allocated objects. The method further includes creating an allocation interference graph of object allocation nodes with edges indicating pairs of allocations to be omitted from collocation. The method also includes coloring the allocation interference graph such that adjacent nodes are assigned different colors, and creating an object allocation at a program point prior to allocations of a selected color from the allocation interference graph. The method additionally includes storing an address associated with the created object allocation in a collocation pointer, and replacing a use of each allocation of the selected color with a use of the collocation pointer to collocate multiple objects. | 11-20-2014 |
20140380290 | EXTRACTING STREAM GRAPH STRUCTURE IN A COMPUTER LANGUAGE BY PRE-EXECUTING A DETERMINISTIC SUBSET - Compile-time recognition of graph structure where graph has arbitrary connectivity and is constructed using recursive computations is provided. In one aspect, the graph structure recognized at compile time may be duplicated at runtime and can then operate on runtime values not known at compile time. | 12-25-2014 |
20140380291 | EXTRACTING STREAM GRAPH STRUCTURE IN A COMPUTER LANGUAGE BY PRE-EXECUTING A DETERMINISTIC SUBSET - Compile-time recognition of graph structure where graph has arbitrary connectivity and is constructed using recursive computations is provided. In one aspect, the graph structure recognized at compile time may be duplicated at runtime and can then operate on runtime values not known at compile time. | 12-25-2014 |
20150143349 | METHOD FOR DIVERGENCE ANALYSIS OF POINTER-BASED PROGRAM - A method comprises generating an intermediate representation of a pointer-based program; providing a control flow graph of the intermediate representation; selecting an analysis candidate from the intermediate representation as a traced variable and a root node; determining a definition site of the trace variable according to a use-define chain and the control flow graph; defining a node for each definition site variable; defining an edge by using each definition site variable and the traced variable; using each definition site variable of the definition site as a traced variable; repeating the steps of determining a definition site, defining a node, defining an edge and using each definition site to obtain a divergence relation graph; transforming the divergence relation graph into a directed acyclic graph; and determining whether the analysis candidate is divergent or not according to a divergent node and the directed acyclic graph. | 05-21-2015 |
20150149988 | METHOD FOR OBTAINING EXECUTION FREQUENCY INFORMATION ON EXECUTION PATHS IN CONTROL FLOW GRAPH, AND COMPUTER AND COMPUTER PROGRAM FOR OBTAINING THE INFORMATION - The present invention is a technique for obtaining execution frequency information on execution paths in a CFG, including preparing a CFG from a source code read into a memory, preparation of the CGF including modifying the CFG by assigning path value zero to an edge v→w between a precedent basic block v and a successor basic block w following the predecessor basic block v in a case where the successor basic block w has a predecessor basic block x other than the predecessor basic block v, and where the successor basic block w exists on a fall-through path from the predecessor basic block x. The technique also includes obtaining execution frequency information by using the modified CFG. | 05-28-2015 |
20150293751 | Adaptable and Extensible Runtime and System for Heterogeneous Computer Systems - A method for accelerating processing of program code in a heterogeneous system may be provided. It may include identifying at runtime a code region having an acceleration potential, creating a dependency graph of the program code, expanding the dependency graph based on a first set of predefined rules to generate variants of the code region, and determining segments within the variants based on a second set of predefined rules. The segments may be dedicated and assigned and compiled for use to/by a specific execution unit such that a cost function is minimized. | 10-15-2015 |
20160070550 | EMBEDDED SYSTEM DEVELOPMENT - A computer-implemented method of automatically generating an embedded system on the basis of an original computer program, comprising analyzing the original computer program, comprising a step of compiling the original computer program into an executable to obtain data flow graphs with static data dependencies and a step of executing the executable using test data to provide dynamic data dependencies as communication patterns between load and store operations of the original computer program, and a step of transforming the original computer program into an intermediary computer program that exhibits multi-threaded parallelism with inter-thread communication, which comprises identifying at least one static and/or dynamic data dependency that crosses a thread boundary and converting said data dependency into a buffered communication channel with read/write access. | 03-10-2016 |
20160117155 | CONTROL FLOW GRAPH FLATTENING DEVICE AND METHOD - Control Flow Graph flattening of a function comprising a plurality of basic blocks having an address and at least one instruction. A processor creates a jump table associating a label of each basic block with its address, creates a coefficient array comprising constant coefficients, creates a dispatcher basic block comprising instructions to look up an address in the jump table and to jump to the address, replaces a Jump terminal instruction by a jump to the dispatcher basic block in each basic block, creates and inserts at least one lookup functions in each of the plurality of basic blocks, each lookup function returning a derived value based on a constant coefficient depending on at least an index of the basic block; creates and inserts a first branch function calculating the label of a subsequent basic block based on at least the derived value and a second branch function calculating the index of the subsequent basic block; and creates and inserts into the dispatcher basic block a transition function obtaining the address in the jump table based on at least the label of a subsequent basic block. | 04-28-2016 |
20160154634 | MODIFYING AN ANALYTIC FLOW | 06-02-2016 |
717157000 | Using procedure or function call graph | 32 |
20080288931 | Using Dynamic Call Graphs For Creating State Machines - A method and system capable of creating UML protocol state machine for classes and interfaces of a software, by instrumenting the software to obtain a call graph comprising classes and interfaces and respective values associated with class variables and interface variables; identifying particular classes and interfaces in the call graph; identifying call patterns from the call graph to generate a protocol state machine. | 11-20-2008 |
20080301656 | METHOD OF PROCEDURE CONTROL DESCRIPTOR-BASED CODE SPECIALIZATION FOR CONTEXT SENSITIVE MEMORY DISAMBIGUATION - A computer implemented method, apparatus, and computer program product for compiling source code. The source code is scanned to identify a candidate region. A procedure control descriptor is corresponding to the candidate region is generated. The procedure control descriptor identifies, for the candidate region, a condition which, if true at runtime means that the candidate region can be specialized. Responsive to a determination during compile time that satisfaction of at least one condition will be known only at runtime, the procedure control descriptor is used to specialize the candidate region at compile time to create a first version of the candidate region for execution in a case where the condition is true and a second version of the candidate region for execution in a case where the condition is false. Also responsive to the determination, code is further generated to correctly select one of the first region and the second region at runtime. | 12-04-2008 |
20090089770 | Method and Apparatus for Performing Non Service Affecting Software Upgrades in Place - The invention includes a method and apparatus for dynamically defining and instantiating an undefined portion of a graph, where the graph has a plurality of states and a plurality of state transitions. A method includes executing the graph where the graph comprises a defined portion and an undefined portion and a plurality of tokens traverse the graph executing functions, suspending the one of the tokens in response to the one of the tokens detecting the undefined portion of the graph, generating a new portion of the graph for the undefined portion of the graph, replacing the undefined portion of the graph with the new portion of the graph, and releasing the suspended token. The new portion of the graph is generated by generating at least one definition file for the undefined portion of the graph and executing the at least one definition file to form thereby the new portion of the graph. The at least one definition file is generated by obtaining information adapted for defining the undefined portion of the graph and generating the at least one definition file using the obtained information. | 04-02-2009 |
20090293049 | METHOD FOR CONSTRUCTING DYNAMIC CALL GRAPH OF APPLICATION - A method of generating a dynamic call graph of an application is disclosed. The method includes collecting information on what program code pages are accessed during each sampling period, defining parts of an executable program code which are accessible during each sampling period according to the collected information, defining a set of functions within the defined parts of the executable program code, generating dynamic call graphs using the defined set of functions for each sampling period, and generating dynamic call graphs for an observation period by combining accurate dynamic call graphs of each sampling period. | 11-26-2009 |
20100031242 | METHOD AND APPARATUS FOR PROVISIONING A NODE WITH EXECUTABLE CODE - A method and apparatus for provisioning a node with executable code is provided herein. Prior to sending out a code request, a node ( | 02-04-2010 |
20100095287 | METHOD AND SYSTEM FOR PROGRAM TRANSFORMATION USING FLOW-SENSITIVE TYPE CONSTRAINT ANALYSIS - A method for analyzing a program is provided. The method includes, determining an object type that may exist at an execution point of the program, wherein this enables determination of possible virtual functions that may be called; creating a call graph at a main entry point of the program; and recording an outgoing function call within a main function. The method also includes analyzing possible object types that may occur at any given instruction from any call path for virtual calls, wherein possible object types are determined by tracking object types as they pass through plural constructs; and calling into functions generically for handling specialized native runtime type information. | 04-15-2010 |
20100125837 | REDUNDANT EXCEPTION HANDLING CODE REMOVAL - A system performs operations comprising creating a call graph for a program translated from source code, identifying redundant exception handling code in the program utilizing the call graph, and removing the redundant exception handling code. The operation of identifying redundant exception handling code may comprise identifying at least one function or callsite by determining that a first function in the at least one function's or callsite's callee chain throws an exception and that the exception is handled by a second function in the function's or callsite's callee chain or by determining that an exception is not thrown in the at least one function's or callsite's callee chain. The operation of removing the redundant exception handling code may comprise removing redundant exception handling code included in at least one function or callsite and/or removing at least one entry for the at least one function or callsite from an exception lookup table. | 05-20-2010 |
20100199270 | SYSTEM, METHOD, AND COMPUTER-PROGRAM PRODUCT FOR SCALABLE REGION-BASED REGISTER ALLOCATION IN COMPILERS - A region-based register allocation system, method, and computer-program product not only provides a scalable framework across multiple applications, but also improves application runtime. They include a register pressure based model, to determine when using multiple regions may be profitable, the use of different regions for each register class, and a new region formation algorithm. | 08-05-2010 |
20110107316 | ALGORITHM COMPLEXITY IDENTIFICATION - An illustrative embodiment provides a computer-implemented process for algorithm complexity identification through inter-procedural data flow analysis receives a call graph to form a set of received nodes in a static analysis framework, identifies a parent node in the set of received nodes to form an identified parent, traverses the call graph from the identified parent node to a node to identify a function within the node to form an identified function. Each identified function is analyzed to form a complexity value in a set of complexity values. Responsive to a determination that node analysis is complete, and responsive to a determination that path analysis is complete, determines whether path analysis for the identified parent is complete. Responsive to a determination that path analysis for the identified parent is complete, sum the complexity values in the set of complexity values for the identified parent and return the complexity value for the identified parent to a requester. | 05-05-2011 |
20110138373 | METHOD AND APPARATUS FOR GLOBALLY OPTIMIZING INSTRUCTION CODE - The disclosed embodiments provide a system that globally optimizes instruction code. During operation, the system obtains the instruction code, wherein the instruction code was previously generated from the source code, and wherein the instruction code is stored along with symbol table information. Next, the system constructs a symbol table from the symbol table information stored along with the instruction code. The system then creates a data structure for the instruction code, wherein the data structure contains a call graph for the instruction code, and wherein creating the data structure involves accessing the symbol table. Finally, the system performs optimizations on the instruction code to produce optimized instruction code, wherein performing the optimizations involves accessing the data structure. | 06-09-2011 |
20110239203 | METHOD AND APPARATUS FOR ANALYZING SOFTWARE INCLUDING A CALIBRATED VALUE - A computer-implemented method for evaluating a machine-executable software code specification includes using the computer to generate a system dependence graph corresponding to the software code specification. The system dependence graph includes elements including nodes and edges. The computer evaluates the system dependence graph including selecting a variable modified in the software code specification, providing a control operation node of the system dependence graph corresponding to a control statement in the software code specification with a preferred calibration state, traversing to selected elements of the system dependence graph wherein the selected elements are associated with the selected variable and the preferred calibration state of the control operation node, evaluating only the selected elements of the system dependence graph, and identifying ones of the selected elements whereat a state of the selected variable is modified. | 09-29-2011 |
20110239204 | METHOD AND APPARATUS FOR ANALYZING SOFTWARE - A computer-implemented method for evaluating a machine-executable software code specification includes using the computer to generate a system dependence graph corresponding to the software code specification. The system dependence graph includes elements including nodes and edges, wherein the computer evaluates the system dependence graph. The evaluation of the system dependence graph includes selecting a variable modified in the software code specification, traversing to selected elements of the system dependence graph, the selected elements associated with the selected variable, evaluating only the selected elements of the system dependence graph, and identifying ones of the selected elements whereat a state of the selected variable is modified. | 09-29-2011 |
20110258617 | CALL GRAPH SIMPLIFICATION/COMPARISON AND AUTOMATIC INITIAL SUSPECTS FINDING OF PERFORMANCE DEGRADATONS - In one embodiment, a method for call graph analysis is provided. The method includes determining a plurality of nodes in a call graph. The plurality of nodes represent resource consumption of functions of a software program executed in a software system. A simplification factor is determined. A first set of nodes in the plurality of nodes is then eliminated based on exclusive values for the plurality of nodes, inclusive values for the plurality of nodes, and the simplification factor. An inclusive value for a node is a first amount of resources consumed by the node and any descendent nodes of that node. An exclusive value for the node is a second amount of resources consumed by the node. A simplified call graph is output including a second set of nodes in the plurality of nodes. The second set of nodes does not include the eliminated first set of nodes. | 10-20-2011 |
20110321021 | Arranging Binary Code Based on Call Graph Partitioning - Mechanisms are provided for arranging binary code to reduce instruction cache conflict misses. These mechanisms generate a call graph of a portion of code. Nodes and edges in the call graph are weighted to generate a weighted call graph. The weighted call graph is then partitioned according to the weights, affinities between nodes of the call graph, and the size of cache lines in an instruction cache of the data processing system, so that binary code associated with one or more subsets of nodes in the call graph are combined into individual cache lines based on the partitioning. The binary code corresponding to the partitioned call graph is then output for execution in a computing device. | 12-29-2011 |
20120102474 | STATIC ANALYSIS OF CLIENT-SERVER APPLICATIONS USING FRAMEWORK INDEPENDENT SPECIFICATIONS - Systems and methods are provided for statically analyzing a software application that is based on at least one framework. According to the method, source code of the software application and a specification associated with the software application are analyzed. The specification includes a list of synthetic methods that model framework-related behavior of the software application, and a list of entry points indicating the synthetic methods and/or application methods of the software application that can be invoked by the framework. Based on the source code and the specification, intermediate representations for the source code and the synthetic methods are generated. Based on the intermediate representations and the specification, call graphs are generated to model which application methods of the software application invoke synthetic methods or other application methods of the software application. The software application is statically analyzed based on the call graphs and the intermediate representations so as to generate analysis results for the software application. | 04-26-2012 |
20120151462 | Sequential-Code Optimization of Parallel Code Based on Identifying Siloed Program References - A parallel-code optimization system includes a siloed program reference-identifier and an intermediate representation (IR) updater. The siloed program reference identifier determines siloed program references in parallel code, wherein siloed program references are free of cross-thread interference. The IR updater modifies data-flow abstractions based on the identified siloed program references. | 06-14-2012 |
20120198429 | Arranging Binary Code Based on Call Graph Partitioning - Mechanisms are provided for arranging binary code to reduce instruction cache conflict misses. These mechanisms generate a call graph of a portion of code. Nodes and edges in the call graph are weighted to generate a weighted call graph. The weighted call graph is then partitioned according to the weights, affinities between nodes of the call graph, and the size of cache lines in an instruction cache of the data processing system, so that binary code associated with one or more subsets of nodes in the call graph are combined into individual cache lines based on the partitioning. The binary code corresponding to the partitioned call graph is then output for execution in a computing device. | 08-02-2012 |
20130061215 | INTER-PROCEDURAL DEAD CATCH HANDLER OPTIMIZATIONS - Whole program analysis during a link time code generation part of compilation can be used to detect and eliminate dead catch handlers. If all catch handlers of a try clause in a computer program are found to be dead then the try clause can also be eliminated. Detection of dead catches can be automatic, using iterative propagation of the types of thrown exceptions from callee function to caller function from bottom to top in the call-graph and iterative propagation of the types of in-flight exceptions from caller function to callee function from top to bottom in the call-graph. | 03-07-2013 |
20130139136 | ELIMINATING REDUNDANT FUNCTION CALLS - A computer-implemented method for removing redundant function calls in a computer program includes identifying a first set of equivalent function calls appearing in the computer program. For each of the equivalent function calls, the method identifies whether the function call is partially available or partially anticipable. When a function call is identified as being partially anticipable, a result of the function call is stored in a temporary variable. When a function call is identified as being partially available, the function call is removed and replaced with use of the temporary variable. | 05-30-2013 |
20130247018 | EFFICIENT INTERPRETER PROFILING TO OBTAIN ACCURATE CALL-PATH INFORMATION - A method for obtaining accurate call path information in a mixed-mode environment where interpreted methods and non-interpreted methods can call one another is disclosed. In one embodiment, such a method includes generating an event and recording it in a buffer when an interpreted method calls an interpreted method. The method also generates an event and records it in the buffer when an interpreted method calls a non-interpreted method. The method further generates an event and records it in the buffer when a non-interpreted method calls an interpreted method. The method refrains from generating an event when a non- interpreted method calls a non-interpreted method. A corresponding apparatus and computer program product are also disclosed. | 09-19-2013 |
20130263101 | IDENTIFICATION OF LOCALIZABLE FUNCTION CALLS - Detecting localizable native methods may include statically analyzing a native binary file of a native method. For each function call invoked in the native binary, it is checked whether resources accessed through the function call is locally available or not. If all resources accessed though the native method is locally available, the method is annotated as localizable. | 10-03-2013 |
20130318511 | VECTORIZATION OF SCALAR FUNCTIONS INCLUDING VECTORIZATION ANNOTATIONS AND VECTORIZED FUNCTION SIGNATURES MATCHING - Methods and apparatuses associated with vectorization of scalar callee functions are disclosed herein. In various embodiments, compiling a first program may include generating one or more vectorized versions of a scalar callee function of the first program, based at least in part on vectorization annotations of the first program. Additionally, compiling may include generating one or more vectorized function signatures respectively associated with the one or more vectorized versions of the scalar callee function. The one or more vectorized function signatures may enable an appropriate vectorized version of the scalar callee function to be matched and invoked for a generic call from a caller function of a second program to a vectorized version of the scalar callee function. | 11-28-2013 |
20140109070 | SYSTEM AND METHOD FOR CONFIGURABLE ENTRY POINTS GENERATION AND AIDING VALIDATION IN A SOFTWARE APPLICATION - A system, method, and computer-readable storage medium is disclosed for identifying and verifying entry points in a software application. The method may include processing, using a processor, input data for a software application. The processing may include generating one or more call graphs for said software application, identifying one or more root parameters for each of said one or more call graphs, and setting the one or more root parameters as a first set of entry points, and filtering the first set of entry points using a first call length value provided by a user to generate a second set of entry points. The method may further include displaying, using the processor, the second set of entry points along with their respective call graphs. | 04-17-2014 |
20140282454 | Stack Data Management for Software Managed Multi-Core Processors - Methods and apparatus for managing stack data in multi-core processors having scratchpad memory or limited local memory. In one embodiment, stack data management calls are inserted into software in accordance with an integer linear programming formulation and a smart stack data management heuristic. In another embodiment, stack management and pointer management functions are inserted before and after function calls and pointer references, respectively. The calls may be inserted in an automated fashion by a compiler utilizing an optimized stack data management runtime library. | 09-18-2014 |
20150121354 | CODE STACK MANAGEMENT - Embodiments relate to code stack management. An aspect includes a processor configured to execute a software application. Another aspect includes a code stack memory area and a data stack memory area, the code stack memory area being separate from the data stack memory area. Another aspect includes maintaining a data stack in the data stack memory area, the data stack comprising a plurality of stack frames comprising one or more data variables corresponding to the execution of the software application. Another aspect includes maintaining a code stack in the code stack memory area, the code stack comprising a plurality of code stack entries comprising executable computer code corresponding to the execution of the software application. | 04-30-2015 |
20150309777 | METHOD OF CALL CONTEXT ENCODING - The present invention provides methods, systems and computer-program products in support of dynamic calling context encoding, in which call graph evolution is recorded in parallel with call events. In part, this can enable a calling context to be encoded on the fly at a low processing overhead without advance knowledge of the complete call graph. | 10-29-2015 |
20160004518 | PROFILE GUIDED OPTIMIZATION IN THE PRESENCE OF STALE PROFILE DATA - Profile guided optimization (PGO) in the presence of stale profile data as described herein can be based on path profiling, whereby different paths through a program's call graph are uniquely identified. Stale profile data is data collected in a training run of a previous version of the program. Profile data can be collected along these paths and optimization decisions can be made using the collected data. The paths can be numbered using an algorithm that assigns path increments to all the callees of a function. The path increment assignments (which can be stored in the profile database) can be used to locate the profile data for that path and to make corresponding optimization decisions. PGO optimizations along call graph paths involving edited functions can be performed. | 01-07-2016 |
20160085527 | CODE PLACEMENT USING A DYNAMIC CALL GRAPH - When a program function is called, if the instructions for that function are not in active memory, a page fault occurs. Resolving a page fault includes a costly process of loading a page of object code instructions, into active memory, including the instructions for the called function. Technology is disclosed to reduce page faults by placing interrelated functions near each other within executable code based on a log of previous function calls. A log of function calls may be from observing the execution of applications over time. Computing devices can compute where to place functions within executable code by: obtaining the function call log; building a call graph based on the function call log; defining multiple node clusters within the call graph; and generating an ordered list of functions by sorting the node clusters. The ordered list of functions can then be provided during linking to determine function placements. | 03-24-2016 |
20160170725 | GLOBAL CALL CONTROL FLOW GRAPH FOR OPTIMIZING SOFTWARE MANAGED MANYCORE ARCHITECTURES | 06-16-2016 |
20160188304 | EXECUTION OPTIMIZATION OF MOBILE APPLICATIONS - According to an aspect of some embodiments of the present invention there is provided a method for changing a program code to decrease execution time. The method comprises an action of receiving a program code, comprising function calls, with an entry and a target function. The method comprises analyzing the function calls between the entry function and the target function. A first program code is generated, comprising some of the function calls executed before the target function. A second program code is generated, comprising some of the function calls executed after the target function. The function calls executed before the target function are replaced with the first program code. The function calls executed after the target function are removed. The second program code is added to the program code to execute after the target function as a background process. | 06-30-2016 |
20160196121 | SYSTEMS AND METHODS FOR ENERGY PROPORTIONAL SCHEDULING | 07-07-2016 |
20190146766 | DEVICE PROFILING IN GPU ACCELERATORS BY USING HOST-DEVICE | 05-16-2019 |