| Class / Patent application number | Description | Number of patent applications / Date published |
|---|
| 717132000 | Using program flow graph | 58 |
| 20130086562 | STATIC ANALYSIS OF COMPUTER SOFTWARE APPLICATIONS - Static analysis of a computer software application can be performed by applying a first level of abstraction to model a plurality of run-time objects, thereby producing a set of object abstractions. Static data-flow analysis of the computer software application can be performed using the set of object abstractions, thereby producing a first data-flow propagation graph. A data-flow bottleneck can be identified within the data-flow propagation graph. A second level of abstraction can be applied to model any of the run-time objects having in the set of object abstractions a corresponding object abstraction that is traceable to the data-flow bottleneck. The applying the second level of abstraction can decompose the corresponding object abstraction into a set of object abstractions, thereby modifying the set of object abstractions. Static data-flow analysis of the computer software application can be performed using the modified set of object abstractions. | 04-04-2013 |
| 20130081002 | SELECTIVE DATA FLOW ANALYSIS OF BOUNDED REGIONS OF COMPUTER SOFTWARE APPLICATIONS - Performing data flow analysis of a computer software application, including, for a data flow analysis type, identifying within a computer software application code base a plurality of seeds relating to the data flow analysis type, for each of the plurality of seeds, defining a portion of the computer software application code base to a predefined depth of calls backward from the seed and to a predefined depth of calls forward from the seed, thereby resulting in a plurality of bounded portions of the computer software application code base, detecting a change in the computer software application code base, and performing, on any of the bounded portions affected by the change, a data flow analysis relating to the data flow analysis type. | 03-28-2013 |
| 20130081003 | SELECTIVE DATA FLOW ANALYSIS OF BOUNDED REGIONS OF COMPUTER SOFTWARE APPLICATIONS - Performing data flow analysis of a computer software application, including, for a data flow analysis type, identifying within a computer software application code base a plurality of seeds relating to the data flow analysis type, for each of the plurality of seeds, defining a portion of the computer software application code base to a predefined depth of calls backward from the seed and to a predefined depth of calls forward from the seed, thereby resulting in a plurality of bounded portions of the computer software application code base, detecting a change in the computer software application code base, and performing, on any of the bounded portions affected by the change, a data flow analysis relating to the data flow analysis type. | 03-28-2013 |
| 20130086561 | STATIC ANALYSIS OF COMPUTER SOFTWARE APPLICATIONS - Static analysis of a computer software application can be performed by applying a first level of abstraction to model a plurality of run-time objects, thereby producing a set of object abstractions. Static data-flow analysis of the computer software application can be performed using the set of object abstractions, thereby producing a first data-flow propagation graph. A data-flow bottleneck can be identified within the data-flow propagation graph. A second level of abstraction can be applied to model any of the run-time objects having in the set of object abstractions a corresponding object abstraction that is traceable to the data-flow bottleneck. The applying the second level of abstraction can decompose the corresponding object abstraction into a set of object abstractions, thereby modifying the set of object abstractions. Static data-flow analysis of the computer software application can be performed using the modified set of object abstractions. | 04-04-2013 |
| 20090077542 | METHODS FOR SELECTIVELY PRUNING FALSE PATHS IN GRAPHS THAT USE HIGH-PRECISION STATE INFORMATION - Methods are provided that allow a false path pruner to traverse a directed acyclic graph in conjunction with one or more checker programs that are analyzing a program for defects or other artifacts of interest. While the checkers may have ways of avoiding re-traversal of portions of the graph that have already been traversed, the false path pruner may override such decisions made by the checkers as a result of a false path in order to allow re-traversal during a future different traversal when that same defect or artifact may not lie along a false path, and therefore avoid missing a valid defect or artifact. Computer programs stored on tangible media are provided that implement the methods of the invention. | 03-19-2009 |
| 20120167061 | IDENTIFYING FACTORABLE CODE - Various embodiments are disclosed that relate to the automated identification of one or more computer program functions for potentially placing on a remote computing device in a split-computational computing environment. For example, one disclosed embodiment provides, on a computing device, a method of determining a factorable portion of code to locate remotely from other portions of the code of a program to hinder unauthorized use and/or distribution of the program. The method includes, on a computing device, receiving an input of a representation of the code of the program, performing analysis on the representation of the code, the analysis comprising one or more of static analysis and dynamic analysis, and based upon the analysis of the code, outputting a list of one or more functions determined from the analysis to be candidates for locating remotely. | 06-28-2012 |
| 20090007079 | CALLING AN ENTITY OF A GRAPHICAL MODEL WITH A NON-GRAPHICAL ENTITY AND CALLING A NON-GRAPHICAL ENTITY OF A GRAPHICAL MODEL WITH A GRAPHICAL ENTITY - The present invention provides a graphical model in a computing environment, where the graphical model includes at least a caller entity. A call command associated with the caller entity is executed, where the call command includes at least a partial name of the callee entity. The at least one callee entity may be identified based on the partial name of the at least one callee entity provided in the call command. The at least one callee entity may then be called. | 01-01-2009 |
| 20110191753 | Incremental deployment and execution of a program on an embedded device - System and method for deploying and executing a program, e.g., a graphical program, on an embedded device. The program and a plurality of execution system components are stored on a host computer. The program is analyzed programmatically to determine a subset of the plurality of components required for execution of the program. The subset of components and the program are combined into a file while preserving execution order of the program. The file is transmitted to the device. The file is used to construct a combined program which includes executable code for the program and the subset of components. The device includes a minimal execution engine which executes the subset of components to execute the program. The file may be streamed to the device for streaming execution, where received portions of the subset of components needed for execution of received portions of the program are stored until no longer needed. | 08-04-2011 |
| 20090282393 | Securing Software By Enforcing Data Flow Integrity - The majority of such software attacks exploit software vulnerabilities or flaws to write data to unintended locations. For example, control-data attacks exploit buffer overflows or other vulnerabilities to overwrite a return address in the stack, a function pointer, or some other piece of control data. Non-control-data attacks exploit similar vulnerabilities to overwrite security critical data without subverting the intended control flow in the program. We describe a method for securing software against both control-data and non-control-data attacks. A static analysis is carried out to determine data flow information for a software program. Data-flow tracking instructions are formed in order to track data flow during execution or emulation of that software. Also, checking instructions are formed to check the tracked data flow against the static analysis results and thereby identify potential attacks or errors. Optional optimisations are described to reduce the resulting additional overheads. | 11-12-2009 |
| 20080307398 | Method and System for Finding Problems Caused by Access to Partially Uninitialized Data Storage Which is Accessed Using Index Expressions - The present invention provides a system and method for detecting problems caused by access to incompletely initialized data storage in assembler and high-level language programs. An internal representation of the control flow of the source code of the assembler program is generated and a data-flow analysis method is applied to the internal representation. | 12-11-2008 |
| 20110225570 | PROGRAM FLOW ROUTE CONSTRUCTOR - A method and corresponding tool, the method comprising: receiving as an input (a) a higher-level structure representing control flow through an executable program, the higher-level structure comprising one or more levels of parent nodes, each parent node representing internal structure comprising a group of one or more child nodes and one or more associated edges between nodes; and (b) an indication of at least one start and end instruction. The method further comprises probing the levels of the higher-level structure to extract a substructure representing a route through the program from the start to the end instruction, by selectively extracting nodes of different levels of parent to represent different regions along the route in dependence on a location of the start and end instructions relative to the levels of parent nodes; and based on the extracted substructure, estimating an execution time for the route through the program. | 09-15-2011 |
| 20090249308 | Efficient Encoding of Instrumented Data in Real-Time Concurrent Systems - A mechanism for encoding and reporting instrumented data is disclosed that requires less storage space and incurs less processor overhead than other methods of the prior art. In accordance with the illustrative embodiment, a bit vector in shared memory corresponds to nodes of a program's control-flow graph that have been instrumented, and the contents of the vector indicate which of these nodes have executed; in addition, character strings in shared memory indicate what file, class, and method each node belongs to. A process that executes concurrently with those of the program under test transmits instrumented data from the shared memory to a database. The illustrative embodiment enables efficient, rapid reporting and storage of instrumented data, and is therefore especially well-suited for run-time analysis of real-time concurrent systems. | 10-01-2009 |
| 20100153928 | Developing and Maintaining High Performance Network Services - A network service runtime module executing on a processor is configured to accept a directed acyclic service graph representing elements of a network service application. During execution of the service graph, runtime events are stored. The service graph may by optimized by generating alternate service graphs, and simulating performance of the alternate service graphs in a simulator using the stored runtime events. A hill climber algorithm may be used in conjunction with the simulator to vary alternate service graphs and determine which alternate service graphs provide the greatest utility. Once determined, an alternate service graph with the greatest utility may be loaded into the network service runtime module for execution. | 06-17-2010 |
| 20110145799 | PATH-SENSITIVE DATAFLOW ANALYSIS INCLUDING PATH REFINEMENT - Methods, systems, and computer-readable media are disclosed to perform path-sensitive dataflow analysis including path refinement. A path-insensitive dataflow analysis may be performed on a control flow graph (CFG) of a computer program to detect a set of potential defects in the computer program. A path-sensitive dataflow analysis may be performed to identify one or more infeasible paths of the CFG without modifying the CFG. Potential defects associated with the one or more infeasible paths may be removed from the set of potential defects to produce a resulting reduced set of potential defects. The resulting reduced set of potential defects may be output. | 06-16-2011 |
| 20090328009 | METHOD AND SYSTEM FOR FAST STATIC TAINT ANALYSIS - A method for detecting user input dependence in software code. The method including representing the software code with a reachability graph having: a plurality of nodes, where a root node of the plurality of nodes represents an input controlled by a user; a first directed edge connecting a first node of the plurality of nodes and a second node of the plurality of nodes, where the first directed edge represents a data dependency; and a second directed edge connecting a third node of the plurality of nodes and a fourth node of the plurality of nodes, wherein the second directed edge represents a data dependency. The method also includes identifying a fifth node of the plurality of nodes as a reachable node from the root node by traversing the reachability graph from the root node to the reachable node; and marking a portion of the software code represented by the reachable node as user input dependant. | 12-31-2009 |
| 20110067010 | Method for Characterization of a Computer Program Part - The invention relates to a method for characterizing a computer program section held in a computer memory system, comprising the steps of breaking down the computer program section into segments, wherein program commands contained in the computer program section are used to define a program flow relationship between the segments, and determining characteristic data which can be associated with the program flow relationship of the segments, wherein the characteristic data are compressed to form a signature which identifies the computer program section. | 03-17-2011 |
| 20110067009 | SOURCE CODE INSPECTION METHOD AND SYSTEM - A source code inspection method and system. The method includes receiving by a computing system, source code files associated with a specified project. The computing system retrieves metrics data comprising software metrics associated with the source code files. The computing system generates first evaluation scores associated with the source code files. The computing system generates and presents to a user, a graph displaying the first evaluation scores. The computing system calculates parameter values associated with an evaluation function used to calculate second evaluation scores associated with the source code files. The computing system calculates the second evaluation scores by enabling the evaluation function using the parameter values. The computing system generates and presents to the user, a second graph displaying the second evaluation scores. | 03-17-2011 |
| 20120246626 | DONUT DOMAINS - EFFICIENT NON-CONVEX DOMAINS FOR ABSTRACT INTERPRETATION - A computer implemented program analysis method employing a set of new abstract domains applicable to non-convex invarients. The method analyzes programs statically using abstract interpretation while advantageously considering non-convex structures and in particular those situations in which an internal region of an unreachable state exists within a larger region of reachable states. The method employs a new set of non-convex domains (donut domains) based upon the notion of an outer convex region of reachable states (Domain D1) and an inner region of unreachable states (Domain D2) which advantageously permits capture of non-convex properties by using convex regions and operations. | 09-27-2012 |
| 20110010692 | APPLICATION DEVELOPMENT SUPPORT DEVICE, PROGRAM AND STORAGE MEDIUM - The development of an application program that includes a user interface (UI), which can provide a processing parameter to be handed to a web service when a UI screen is called via a link, is realized without coding operations. When the UI screen is called via the link, in which link information is embedded with the processing parameter, a platform program obtains the processing parameter and stores the processing parameter in a corresponding storage region. A call program that has been attached to an unconditional starting button, which is located in the UI screen by a developer, in advance activates the web service by using the processing parameter in the storage region as an argument. After the processing for storing the output variables of the web service in the corresponding storage region is carried out, the processing, in which the called UI screen is generated and distributed, is carried out. | 01-13-2011 |
| 20110246970 | INTERVAL ANALYSIS OF CONCURRENT TRACE PROGRAMS USING TRANSACTION SEQUENCE GRAPHS - A method for the verification of multi-threaded computer programs through the use of concurrent trace programs (CTPs) and transaction sequence graphs (TSGs). | 10-06-2011 |
| 20090217248 | SYSTEMS AND METHODS FOR INFORMATION FLOW ANALYSIS - Computer-implemented methods for analyzing computer programs written in semi-structured languages are disclosed. The method is based on unification of the two classic forms of program flow analysis, control flow and data flow analysis. As such, it is capable of substantially increased precision, which increases the effectiveness of applications such as automated parallelization and software testing. Certain implementations of the method are based on a process of converting source code to a decision graph and transforming that into one or more alpha graphs which support various applications in software development. The method is designed for a wide variety of digital processing platforms, including highly parallel machines. The method may also be adapted to the analysis of (semi-structured) flows in other contexts including water systems and electrical grids. | 08-27-2009 |
| 20120304158 | POINTS-TO ANALYSIS AS VALUE FLOW - In general, in one aspect, the invention relates to a method for performing points-to analysis by generating a value flow graph for source code. The method steps include: initializing the value flow graph including a set of memory objects and a set of edges based on Base and Assignment instructions, where the set of edges represents inclusion constraints between the set of memory objects and a set of pointer variables; determining a pointed-to-by set including at least one pointer variable of the set of pointer variables; updating the value flow graph by introducing a flow edge based on an indirect reference, where the flow edge is related to a memory object of the set of memory objects that is added to a working list; updating the pointed-to-by set based on the memory object in the working list; and analyzing the source code using the pointed-to-by set. | 11-29-2012 |
| 20130014090 | Weighted Code Coverage Tool - Evaluating software test comprehensiveness of an application. A subset of the software-under-test basic blocks is identified for emphasized and/or deemphasized testing. During test, execution of the basic blocks is monitored, and then aggregated into a weighted code coverage result which factors in the prioritization assignments of the subset of basic blocks. | 01-10-2013 |
| 20090249309 | Efficient Program Instrumentation - A method for determining the number and location of instrumentation probes to be inserted into a program is disclosed. The method advantageously inserts the minimum number of probes that are required to obtain execution coverage for every node in the program's control-flow graph. In addition, the method requires only type of node marking and one bit to store each probe, and does not require the assignment of weights to arcs or nodes of the control-flow graph. In the illustrative embodiment, the nodes of a control-flow graph are partitioned into non-empty sets, where each non-empty set corresponds to a super nested block of the program. | 10-01-2009 |
| 20080320451 | Procedure Summaries for Pointer Analysis - Pointer analysis is used for different applications, e.g., compilers, debugging tools and programs understanding tools, each having different requirements. A framework for pointer analysis is provided that defines a multidimensional space, for example a three-dimensional space, containing an order sensitivity dimension, a predicate sensitivity dimension and a value persistence dimension. A point in the three-dimensional space is identified. This point yields values for order sensitivity, predicate sensitivity and value persistence. Pointer analysis is then conducted on a computer program in accordance with the identified values for order sensitivity, predicate sensitivity and value persistence. | 12-25-2008 |
| 20110179400 | System and method for overflow detection USING PARTIAL EVALUATIONS - A method for overflow detection using partial evaluations. The method includes obtaining a section of code from a source code file stored on a storage device, analyzing the section of code to identify a buffer with an index, determining a plurality of statements that are statically-computable and dependent on the index of the buffer, and generating a code segment including the plurality of statements. The method further includes replacing an access statement of the plurality of statements with a conditional statement returning true when bounds of the buffer are exceeded, where the access statement uses the index to access the buffer, adding an unconditional statement returning false to the code segment, and executing the code segment on a computer processor to obtain a determination of whether the bounds of the buffer are exceeded. | 07-21-2011 |
| 20120311545 | Lossless Path Reduction for Efficient Symbolic Execution and Automatic Test Generation - In one embodiment, symbolically executing a software module having a number of execution paths; and losslessly reducing the number of execution paths during the symbolic execution of the software module. | 12-06-2012 |
| 20110307873 | SYSTEM AND METHOD FOR ENTROPY POOL VERIFICATION - Disclosed are systems, methods, and non-transitory computer-readable storage media for detecting changes in a source of entropy. A system configured to practice the method generates a cyclic graph based at least in part on the values in the entropy pool. Using the cyclic graph and one or more starting points, the system establishes one or more baseline properties for the cyclic graph. These properties can include the number of steps required to identify a cycle in the graph or the number of steps required to traverse the graph from one or more starting points to a selected end point. The computed properties are then stored for later use. As execution progresses, the system monitors the entropy pool to detect a change by regenerating the cyclic graph and using the stored properties. | 12-15-2011 |
| 20120011492 | SYSTEMS AND METHODS FOR CONCURRENCY ANALYSIS - Systems and methods are disclosed to check properties of bounded concurrent programs by encoding concurrent control flow graph (CFG) and property for programming threads as a first-order formula F | 01-12-2012 |
| 20120017201 | System and Method for Comparing Software Frameworks - In one embodiment, a method may include symbolically executing application code on a first framework. The method may also include creating a first model based on the symbolic execution of the first framework. The method may additionally include symbolically executing the application code on a second framework. The method may further include creating a second model based on the symbolic execution of the first framework. The method may also include determining one or more parameters associated with the first framework based on the first model. The method may additionally include determining one or more parameters associated with the second framework based on the second model. The method may also include selecting one of the first framework and the second framework as a desired framework for execution of the application code based on a comparison of the one or more parameters associated with the first framework and the one or more parameters associated with the second framework. | 01-19-2012 |
| 20110107314 | STATIC CODE RECOGNITION FOR BINARY TRANSLATION - In one embodiment, the present invention includes a method for creating a control flow graph (CFG) node for a starting address, parsing code beginning at the starting address until a control transfer is encountered and statically determining a destination address for the control transfer, and creating a CFG node for the destination address, and parsing code beginning at the destination address. In this way, virtually all executed code of an application can be recognized. Other embodiments are described and claimed. | 05-05-2011 |
| 20120167060 | System and Method for Software Immunization Based on Static and Dynamic Analysis - Disclosed herein are systems, methods, and non-transitory computer-readable storage media for analyzing source code and identifying potential defects. The methods employ both static analysis and dynamic testing to detect program defects early in the development stage for better quality with less cost. The analysis also ranks identified potential defects and reports only the most likely defects to a human developer. Once defects are detected, they can be removed right away and similar defects can be prevented automatically. | 06-28-2012 |
| 20120131559 | Automatic Program Partition For Targeted Replay - Program partitioning of an application can include creating execution flow graphs and static flow graphs of targeted functions or operations of the application. Based on the execution flow graphs or static flow graphs, replay interfaces are created. The replay interfaces provide data flows that are usable in re-execution of the application during program development. | 05-24-2012 |
| 20120260236 | Visualization Of JVM And Cross-JVM Call Stacks - A method for diagnosing problems in a computer system by visualizing flows through applications and other subsystems in a directed graph on a user interface. The user interface represents multiple instances of each application or other subsystem by a respective node, and edges indicate which nodes depend on one another. Aggregate metrics which are based on the multiple instances, and associated alerts, can be provided for the nodes and edges. An aging process can indicate which nodes have not been recently invoked. The user interface can also indicate which nodes and edges are associated with a given business transaction. In a summary view, a node hides the identity of invoked components such as servlets of the application, while in a detailed view these details are provided. | 10-11-2012 |
| 20100299656 | Concurrent Static Single Assignment for General Barrier Synchronized Parallel Programs - Techniques for generating concurrent static single assignment (CSSA) are provided. The techniques include generating a clocked control flow graph of a program, for each thread of the program created through async instruction, determining each part of the program that can execute concurrently with each thread to create a pair comprising a thread and a parallel program part, for each pair that can execute concurrently, using one or more flow equations to perform node-by-node matching, and using the node-by-node matching to generate CSSA form for the program. | 11-25-2010 |
| 20100275186 | SEGMENTATION FOR STATIC ANALYSIS - Various embodiments provide techniques to segment program code that may be the subject of static analysis. In one or more embodiments, an algorithm is applied to an abstract representation of the program code to derive segments for the program code. In at least some embodiments, multiple segments can be derived based at least in part upon of one or more “boxed” portions of the program code that are designated to remain intact within the segments. Each segment can then be subjected individually to static analysis to verify compliance with one or more prescribed behaviors. Verification results can be output for each individual segment and the individual results can be combined to obtain results for the program code overall. | 10-28-2010 |
| 20120180028 | SETTING PROGRAM, WORKFLOW CREATING METHOD, AND WORK FLOW CREATING APPARATUS - A computer-readable, non-transitory medium storing a program that causes a computer to execute a procedure, the procedure includes acquiring a state from each of a plurality of components of a first server device group before and after execution of an execution control process in which the first server device group is caused to execute processes, the components being hardware or software and whose dependencies are previously defined, and storing, in a storage unit, information in which a component whose state is different before and after the execution of the execution control process is associated with the execution control process. | 07-12-2012 |
| 20120084761 | Interprocedural Exception Method - An interprocedural exception analysis and transformation framework for computer programming languages such as C++ that (1) captures the control-flow induced by exceptions precisely, and (2) transforms the given computer program into an exception-free program that is amenable for precise static analysis, verification, and optimizations. | 04-05-2012 |
| 20120096443 | METHOD OF ANALYZING SINGLE THREAD ACCESS OF VARIABLE IN MULTI-THREADED PROGRAM - A method of analyzing single thread access by a variable of a multi-threaded program is provided. The method includes computing a thread identifier of a thread to be executed in a node of the multi-thread program; computing multiple threads configured to concurrently execute the node; and computing thread accessibility by deducing one or more variables that are executed in a single thread of the program from one or more pairs of the computed threads that concurrently execute the node. | 04-19-2012 |
| 20120151455 | Enhanced Unit Test Framework - Implementations of the present disclosure provide methods including analyzing a plurality of units of a software application to determine a dependency graph defining that at least a first unit depends on a second unit. Each unit includes executable instructions. An execution order is determined for the units based on the dependency graph, wherein the execution order specifies execution of the second unit before the first unit. Unit tests are executed for the units according to the execution order, including executing a unit test of the second unit before the first unit. Executing a unit test for a unit comprises executing the executable instructions of the unit and comparing a resulting value to an expected value. | 06-14-2012 |
| 20110161939 | APPARATUS FOR DISPLAYING THE RESULT OF PARALLEL PROGRAM ANALYSIS AND METHOD OF DISPLAYING THE RESULT OF PARALLEL PROGRAM ANALYSIS - According to one embodiment, an apparatus includes a delay data calculator configured to calculate data delay data and task delay data based on a target ability parameter describing an ability of an environment of executing a parallel program, profile data of the parallel program, and a task-dependency graph representing dependence of tasks described in the parallel program, the data delay data representing time elapsing from a start of obtaining variables needed for executing a task comprised in the tasks to acquisition of all of the needed variables, the task delay data representing the time elapsing from the acquisition of the variable to execution of the task, and a display module configured to display, on a display screen, an image showing the task, a task on which the task depends, the task delay data, and the data delay data, based on the task delay data and the data delay data. | 06-30-2011 |
| 717133000 | Using procedure or function call graph | 17 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 20100175053 | DEVICE AND A METHOD OF MANAGING A PLURALITY OF SOFTWARE ITEMS | 07-08-2010 |
| 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 |
| 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 |
