| Class / Patent application number | Description | Number of patent applications / Date published |
|---|
| 717133000 | Using procedure or function call graph | 30 |
| 20080256521 | Apparatus and Method for Partitioning Programs Between a General Purpose Core and One or More Accelerators - An apparatus and method for partitioning programs between a general purpose core and one or more accelerators are provided. With the apparatus and method, a compiler front end is provided for converting a program source code in a corresponding high level programming language into an intermediate code representation. This intermediate code representation is provided to an interprocedural optimizer which determines which core processor or accelerator each portion of the program should execute on and partitions the program into sub-programs based on this set of decisions. The interprocedural optimizer may further add instructions to the partitions to coordinate and synchronize the sub-programs as required. Each sub-program is compiled on an appropriate compiler backend for the instruction set architecture of the particular core processor or accelerator selected to execute the sub-program. The compiled sub-programs and then linked to thereby generate an executable program. | 10-16-2008 |
| 20090119650 | GENERATING SEQUENCE DIAGRAMS USING CALL TREES - A software tool is provided to analyze static source code. Source Code files are selected to define the project work space. A class and a method in the class are selected from said selected source code files. The tool generates a Call Tree as an ordered recursive sequence of all method calls in different classes or their instances that are invoked by said selected method in said selected class. A Sequence Diagram is generated from said Call Tree. The tool remembers all updates to the Call Tree used to generate the Sequence Diagram. This information is used when a generated Sequence Diagram is impacted due to changes made to any source code file included in the project. | 05-07-2009 |
| 20090158260 | APPARATUS AND METHOD FOR AUTOMATICALLY ANALYZING PROGRAM FOR DETECTING MALICIOUS CODES TRIGGERED UNDER SPECIFIC EVENT/CONTEXT - Provided is an apparatus for automatically analyzing a program in order to detect window malicious codes that are programmed to perform malicious behaviors only when a specific event occurs or when a specific program execution condition is satisfied. | 06-18-2009 |
| 20090271769 | DETECTING IRREGULAR PERFORMING CODE WITHIN COMPUTER PROGRAMS - A computer-implemented method of finding portions of a computer program exhibiting irregular performance can include detecting an entry into a function of a computer program under test indicating a current execution of the function and, responsive to detecting an exit from the function, determining a count of a computing resource utilized by the function during the current execution of the function. The count of the computing resource can be compared with a count range determined according to at least one prior execution of the function. The function can be selectively represented within a call graph as a plurality of nodes according to the comparing. | 10-29-2009 |
| 20100175053 | DEVICE AND A METHOD OF MANAGING A PLURALITY OF SOFTWARE ITEMS | 07-08-2010 |
| 20100199266 | Code Execution Visualization Using Software Fingerprinting - A system, method, and computer program for analyzing code execution and software performance characteristics are disclosed. Samples of executing code may be taken based on any of a number of various triggers. For example, samples may be triggered based on function calls, such as malloc calls. Alternatively, samples may be triggered based on occurrence of a specified event. Code execution is graphically displayed such that certain patterns may be easily identified. Multiple redundant function calls and areas of code having excessively deep function calls can be readily spotted. Such areas represent opportunities for performance optimization. | 08-05-2010 |
| 20100205584 | METHOD AND APPARATUS FOR DETERMINING AUTHORITATIVENESS OF FIRST SOFTWARE COMPONENT WITH REGARD TO SECOND SOFTWARE COMPONENT - For identification of the quality of trustworthiness and reliability of software components, an eigenvector based approach is used in which a procedure invocation graph of a set of software components is provided. Subsequently, the authoritativeness of a first software component is calculated as a function of an eigenvector of the provided procedure invocation graph. For calculating the authoritativeness, a flexible algorithm, which considers background knowledge is used. Applying the method, software code can be analyzed more efficiently. The method can be applied in software code analysis and/or in software architecture analysis. | 08-12-2010 |
| 20110010693 | SYSTEM AND METHOD FOR VERIFICATION OF PROGRAMS USING THREADS HAVING BOUNDED LOCK CHAINS - A system and method for model checking of concurrent multi-threaded programs with bounded lock chains includes analyzing individual program threads in a concurrent multi-threaded program to determine sets of reachable states and lock access patterns for bounded lock chains by tracking sets of states reachable from a given set of states and tracking lock acquisitions and releases by maintaining a bi-directional lock causality graph. Analysis results from multiple threads are combined using an acceptance condition of the lock causality graph to determine whether there is a violation of a correctness property in the concurrent multi-threaded program. | 01-13-2011 |
| 20110078667 | STATIC CODE ANALYSIS FOR PACKAGED APPLICATION CUSTOMIZATION - A method for static code analyzing customizations to a pre-packaged computing solution can include establishing a communicative connection from a recommendation generation module to a pre-packaged computing solution and authenticating into the pre-packaged computing solution. Customized program code can be extracted from the pre-packaged computing solution and a call graph of the customized program code can be constructed such that the call graph indicates method calls to different interfaces for program code of the pre-packaged computing solution. Finally, a report can be generated identifying customized program code to be adapted to a new version of the pre-packaged computing solution based upon changes in the different interfaces shown by the call graph to be used in the new version of the pre-packaged computing solution and modifications required for the customized program code to call the different interfaces in the new version of the pre-packaged computing solution. | 03-31-2011 |
| 20110138368 | Verifying function performance based on predefined count ranges - A computer-implemented method of finding portions of a computer program exhibiting irregular performance can include detecting an entry into a function of a computer program under test indicating a current execution of the function and, responsive to detecting an exit from the function, determining a count of a computing resource utilized by the function during the current execution of the function. The count of the computing resource can be compared with a predetermined count range to determine whether the function is nonconforming to the predetermined count range. Usage information for the computer program under test can be output to a display of an electronic device resource, the resource usage information indicating that the function does not conform to the predetermined count range. | 06-09-2011 |
| 20110138369 | Feedback-Directed Call Graph Expansion - A technique for feedback-directed call graph expansion includes performing symbolic analysis on an interprocedural control flow graph representation of software code, skipping over a virtual method call in the control flow graph, using information obtained from the symbolic analysis as feedback to identify a target of the virtual method call, and iterating the symbolic analysis on a modified version of the control flow graph that associates the target with the virtual method. | 06-09-2011 |
| 20110145800 | Building An Application Call Graph From Multiple Sources - A system and method for generating a computer program call graph. A profiler may insert probes into a debuggee computer program, the probes generating call trace events. Checkpoints may be performed during execution of the debuggee program, so that a snapshot of the call stack is performed. Call trace events and checkpoint snapshots are logged and serialized. Logged call trace events and checkpoints may be retrieved and used in combination to generate a call graph and a shadow stack. Mechanisms facilitate combining the different sources of debuggee program information and determining whether the call graph and shadow stack are determinate or indeterminate at any time. The mechanisms may provide for improved accuracy of generated call graphs. | 06-16-2011 |
| 20110154300 | Debugging From A Call Graph - A system and method for debugging a computer program by using a call graph. A call graph that represents trace events during execution of a debuggee program may be used as input to a system that enables a user to debug the debuggee program. Mechanisms facilitate conditionally forming clusters of event nodes, a cluster indicative of multiple event nodes corresponding to an execution of a source language statement. During a debugging session, in response to a command to perform a step operation, the nodes of a cluster are processed together so that a step corresponds to multiple events if the multiple events correspond to a single source language statement. A mechanism for inspecting variables is provided. Variable values may be selectively propagated and provided based on the call graph and a static control flow analysis of the debuggee program. | 06-23-2011 |
| 20120089966 | TWO PASS AUTOMATED APPLICATION INSTRUMENTATION - A two-pass technique for instrumenting an application is disclosed. One pass may be performed statically by analyzing the application and inserting probes while the application is not running. Another pass may be performed dynamically by analyzing data collected by the probes while the application runs to derive metrics for the probes. One or more metrics for each probe may be analyzed to determine whether to dynamically modify the probe. By dynamically modifying the probe, the application does not need to be shut down. Dynamically modifying the probe could include removing the probe from the application or moving the probe to another component (e.g., method) in the application, as examples. For example, the probe might be moved to a component that is either up or down the call graph from the component that the probe is presently in. | 04-12-2012 |
| 20120102471 | GENERATING SPECIFICATIONS OF CLIENT-SERVER APPLICATIONS FOR STATIC ANALYSIS - Systems and methods are provided for creating a data structure associated with a software application that is based on at least one framework. According to the method, source code and at least one configuration file of the software application is analyzed by at least one framework-specific processor so as to determine entry point information indicating entry points in the source code, request attribute access information indicating where attributes attached to a request data structure are read and written, and forward information indicating forwards performed by the software application. A data structure for a static analysis engine is created based on this information. The data structure 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. | 04-26-2012 |
| 20120110557 | AUTOMATED PARALLEL SOFTWARE CODE IMPACT ANALYSIS - A server device is configured to receive a request to identify a manner in which changed code propagates within an application; generate a group of blocks that correspond to code associated with a parent function corresponding to the application and which includes the changed code; perform an intra-procedural analysis on the group of blocks to identify a block that is affected by the changed code included within an epicenter block; perform an inter-procedural analysis on functions associated with the block, where, when performing the inter-procedural analysis, the server device is to generate another group of blocks associated with the functions, and identify another block that is affected by the changed code included within the epicenter block; and present, for display, information associated with the block or the other block that enables the application to be tested based on the block or the other block. | 05-03-2012 |
| 20120254841 | DETECTING IRREGULAR PERFORMING CODE WITHIN COMPUTER PROGRAMS - A computer-implemented method of finding portions of a computer program exhibiting irregular performance can include detecting an entry into a function of a computer program under test indicating a current execution of the function and, responsive to detecting an exit from the function, determining a count of a computing resource utilized by the function during the current execution of the function. The count of the computing resource can be compared with a count range determined according to at least one prior execution of the function. The function can be selectively represented within a call graph as a plurality of nodes according to the comparing. | 10-04-2012 |
| 20130174127 | CONTROL FLOW ANALYSIS - A method for control flow analysis according to an embodiment of the present invention includes: acquiring an original function call tree of a program, wherein nodes of the original function call tree represent functions and a parent/child relation between the nodes represents a calling relation; generating a corresponding function dominator tree from the calling relation, wherein nodes of the function dominator tree represent the functions and a parent/child relation between the nodes represents a dominator relation, wherein a first function dominates a second function if all the invocations to the second function are originated by the first function; and simplifying the original function call tree according to the function dominator tree so as to obtain a simplified function call tree. According to an embodiment of the present invention, the function call tree for control flow analysis can be simplified. | 07-04-2013 |
| 20130263097 | 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 |
| 20140040869 | Call Graph Simplification/Comparison and Automatic Initial Suspects Finding of Performance Degradations - 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. | 02-06-2014 |
| 20140189656 | Flow Analysis in Program Execution - Machines, systems and methods for distinguishing feasible paths in a program by statically tracking one or more execution paths are provided. The method comprises reading one or more program statements in an execution path; adding a location identification for the program statement read to an abstract representation of the execution stack at the time the program statement is executed, in response to determining that the program statement is a procedure call; updating the abstract representations of the execution stack to exclude infeasible execution paths for a possible point in program where the procedure could return or continue, in response to determining that the program statement is a return from a procedure. | 07-03-2014 |
| 20140189657 | Enhanced String Analysis That Improves Accuracy Of Static Analysis - A method includes determining, as part of a static analysis of a program, links between functions in the program and performing, as part of the static analysis, string analysis on strings used in the program to determine additional links between the functions in the program. The method further includes outputting, as part of the static analysis, indications of at least the links between the functions and the additional links between the functions. Apparatus, computer programs, and program products are also disclosed. | 07-03-2014 |
| 20140189658 | Enhanced String Analysis That Improves Accuracy Of Static Analysis - An apparatus and computer program product which are configured for determining, as part of a static analysis of a program, links between functions in the program and performing, as part of the static analysis, string analysis on strings used in the program to determine additional links between the functions in the program. The apparatus and computer program product are further configured for outputting, as part of the static analysis, indications of at least the links between the functions and the additional links between the functions. | 07-03-2014 |
| 20140250429 | CODE ANALYSIS FOR SIMULATION EFFICIENCY IMPROVEMENT - A computer program product and computer system for analyzing code to improve efficiency of simulating a hardware system. A computer identifies one or more functions calling an application programming interface of a hardware simulator simulating the hardware system. In response to determining that left hand sides of respective one or more Boolean expressions are associated with the one or more functions calling the application programming interface and right hand sides are not associated with the one or more functions calling the application programming interface, the computer identifies the respective one or more Boolean expressions as one or more improvement points in source code for verifying a hardware model of the hardware system. | 09-04-2014 |
| 20140372990 | METHOD AND SYSTEM FOR IMPLEMENTING A MULTI-THREADED API STREAM REPLAY - A method for debugging and includes receiving a request for capturing a frame generated by a graphics application implementing application threads executing function calls. The function calls are associated with one or more thread specific resources used at the beginning of the capturing process. For each application thread, a corresponding state is determined for each thread specific resource utilized, and a corresponding capture stream is established. For each application thread, executed function calls are captured into the corresponding capture stream. A plurality of captured function calls is arranged in the order they were executed by the graphics application. For each capture stream, a corresponding replay thread is established. Application threads, capture streams, and replay threads exist in a one-to-one-to-one relationship. Captured function calls are replayed in order, wherein each captured function call is executed in a corresponding replay thread based on which application thread executed the captured function call. | 12-18-2014 |
| 20150106794 | TRANSPARENT PERFORMANCE INFERENCE OF WHOLE SOFTWARE LAYERS AND CONTEXT-SENSITIVE PERFORMANCE DEBUGGING - Methods and systems for performance inference include inferring an internal application status based on a unified call stack trace that includes both user and kernel information by inferring user function instances. A calling context encoding is generated that includes information regarding function calling paths. Application performance is analyzed based on the encoded calling contexts. The analysis includes performing a top-down latency breakdown and ranking calling contexts according to how costly each function calling path is. | 04-16-2015 |
| 20160011956 | SYSTEM AND/OR METHOD FOR COMPUTING INTERPROCEDURAL DOMINATORS | 01-14-2016 |
| 20160092336 | CODE ANALYSIS FOR CLOUD-BASED INTEGRATED DEVELOPMENT ENVIRONMENTS - The disclosure generally describes computer-implemented methods, software, and systems, including methods for generating visualizations. On a client side, a user request is received for an inter-entity call visualization. Code analysis data is accessed. A visualization model is built. The visualization is shown. User inputs are received for interacting with the visualization. The visualization is updated based on the received user inputs. On a server side, a request is received for code analysis data. The requested data collected, including running analyzers for any available data. The requested data is sent. The code analysis data can be used for other purposes than visualizations. | 03-31-2016 |
| 20160092350 | CALLPATH FINDER - Techniques and systems for creating a function call graph for a codebase are disclosed. Graph creation includes identifying functions in the codebase by a function signature and representing a function as a first node in the call graph. For that function, identifying call-to functions, call-from functions, and inheritance parents and children, and a base class from the function signature of that function; adding child nodes to the first node based on the identified call-to and call-from functions; for an interface call to a base class method in the function, adding child nodes to the first node based on implementations of an override of the base class method; for an added child node, removing that child node from the first node if a source file that includes an implementation of an override and a source code file that includes the function don't share at least one common binary file. | 03-31-2016 |
| 20170235667 | SYSTEM AND/OR METHOD FOR COMPUTING INTERPROCEDURAL DOMINATORS | 08-17-2017 |
