Abstract: A partition-based method for diagnosing memory leaks in Java systems, comprising dividing heap memory of a Java virtual machine into a plurality of partitions based on a partition plan, wherein each partition has at least one partition owner; monitoring the status of the respective partitions to determine whether there is a partition in which the memory space is exhausted; and if there is a partition in which the memory space is exhausted, determining that the memory leak may occur in the partition and analyzing the partition to obtain leaked objects and objects related to the leaked objects. The present invention also provides a partition-based apparatus for diagnosing memory leak in Java systems.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: Various technologies and techniques are disclosed for using a command interpreter at design time of a software application. A command interpreter can be used to design and test the functionality of an application at design time. The command interpreter allows a user to identify a command to execute for a selected object at design time of an application being developed within a software application design environment. The command interpreter causes the identified command to be executed. A selected object can be sent from a visual tree to the command interpreter. The command interpreter receives the object sent from the visual tree and assigns a designated object name for referencing the object in the command interpreter. The designated object name is displayed within the command interpreter to allow a user to have an abbreviated way of issuing one or more commands for the object from the command interpreter.

Abstract: A method of detecting deadlock in a multithreading program is provided. An invocation graph is constructed having a single root and a plurality of nodes corresponding to one or more functions written in code of the multithreading program. A resource graph is computed in accordance with one or more resource sets in effect at each node of the invocation graph. It is determined whether cycles exist between two or more nodes of the resource graph. A cycle is an indication of deadlock in the multithreading program.

Abstract: A method for grouping algorithms included in a program into groups and thus for assisting in analyzing the program. The method includes the steps of: converting each of the algorithms into a directed graph; judging, as to each representative directed graph stored in a storage unit of a computer system, whether or not the directed graph obtained by the conversion is similar to the representative directed graph; and determining a group to which the directed graph obtained by the conversion belongs from among groups stored in the storage unit in accordance with the similarity judgment. A computer system for performing the above method and a computer program for causing a computer system to perform the above method are also described.

Abstract: Coverage analysis may be performed using reverse time. The coverage analysis may be based on last hit data. The last hit data may comprise a timestamp indicating a last time in which a coverage event was covered. Utilizing last hit data instead of first hit data as is known in the art enables distinction between coverage goals that were never covered and coverage goals that were not covered lately.

Abstract: 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.

Abstract: 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 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.

Abstract: A quality assurance system has a test generator for applying tests to an application program and a correlator for logging events that occur during testing in correlation with test steps so as to generate a test log. The quality assurance program has a user interface for providing an interactive presentation displaying a list of events and a list of test steps such that: 1) selecting a test step will cause a correlated event to be highlighted, and 2) selecting an event will cause a correlated test step to be highlighted.

Abstract: A method for detecting defects in a computer program.

Abstract: A method for software debugging in a multi-tenant database network system is provided. When an exception occurs the stack frames in temporary working memory are dumped into long term memory for later analysis. A stack trace is performed from which performance information may be derived, which may aid in discovering the cause of the exception.

Abstract: Apparatus, systems, and methods for a compiler are disclosed. One such compiler parses a human readable expression into a syntax tree and converts the syntax tree into an automaton having in-transitions and out-transitions. Converting can include unrolling the quantification as a function of in-degree limitations wherein in-degree limitations includes a limit on the number of transitions into a state of the automaton. The compiler can also convert the automaton into an image for programming a parallel machine, and publishes the image. Additional apparatus, systems, and methods are disclosed.

Abstract: 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.

Abstract: Determining the association between data objects may be accomplished using any of a variety of systems and techniques. In particular implementations, a system and technique may have the ability to receive a group of data objects and execute a matching algorithm to determine duplicate data object propositions between the data objects. The system and technique also may have the ability determine whether a data object is a potential duplicate data object and, if a data object is a potential duplicate data object, determine whether the data object is a duplicate data object by examining duplicate data object propositions of a plurality of data objects that are associated with the data object through duplicate data object propositions.

Abstract: A high level programming language provides a co-map communication operator that maps an input indexable type to an output indexable type according to a function. The function maps an index space corresponding to the output indexable type to an index space corresponding to the input indexable type. By doing so, the co-map communication operator lifts a function on an index space to a function on an indexable type to allow composability with other communication operators.

Abstract: An aspect of the present invention facilitates identification of test cases to be run after changes to modules of a software application. In one embodiment, a reference data is generated by inspecting the instructions (static analysis) forming the modules of the software application, with the reference data specifying a corresponding set of modules in the application that are referenced by each of the modules in the application. The reference data is then examined to find a referencing set of modules which reference any of the changed modules either as immediate reference or multi-level reference through other modules. Test cases invoking any of the modules in the referencing set are identified as suitable test cases to be run.

Abstract: 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.

Abstract: A working set profiler can monitor an execution of a program or can monitor a user-specified portion of a program to identify methods executed within the monitored execution and associate memory page accesses with each of the identified methods. Memory page accesses are categorized as shared or exclusive, where a shared page is a page that is accessed by more than one method and where an exclusive page is a page that is accessed by only one method in the monitored portion of the program. A call tree can be constructed and augmented with the collected information regarding memory page accesses. Further, for shared pages, the name of the method with which a particular method shares the page access can be collected. The augmented call tree information can be analyzed and prioritized to identify methods whose elimination would reduce program latency.

Abstract: A technique includes providing first objects that are associated with an application session and in a processor-based system, identifying second objects in another application session corresponding to the first objects based at least in part on a comparison of the second objects to matching rules associated with the first objects.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: Methods and apparatus for testing user interfaces are disclosed herein. An example method includes extracting object data from a file associated with a user interface; storing a plurality of object definitions corresponding to the extracted object data in a computer readable storage medium; and generating, at a computer having a tangible memory, a test script for the user interface using the object definitions, wherein the test script is to be generated based on one or more test definitions defining one or more attributes of the object definitions to be tested in the test script, and wherein the test script is to be generated based on one or more automation rules defining how the object definitions are to be tested.

Abstract: This invention enables a target variable name to be confirmed without inputting all the character string even when a method of giving a name such as allocating a number to the end of the name is performed from the necessity to allocate a variable name having the same meaning to a plurality of different addresses. If narrowed down variable name exists in plurals and one or two or more continuous next character strings match each other among the variable names, the series of character strings without any choice are automatically adopted and confirmed as the character string of the target variable name without waiting for the input of an operator.

Abstract: 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.

Abstract: A technique for debugging code during runtime includes providing, from an outside process, a trigger to a daemon. In this case, the trigger is associated with a registered callback function. The trigger is then provided, from the daemon, to one or more designated tasks of a job. The registered callback function (that is associated with the trigger) is then executed by the one or more designated tasks. Execution results of the executed registered callback function are then returned (from the one or more designated tasks) to the daemon.

Abstract: A system is described for processing predicates in the course of analyzing a program, based on a general-purpose theory of pointers. The system converts location expressions in the predicates into logical formulae that are interpretable by a theorem prover module, producing converted predicates. This conversion associates the location expressions with location objects. More specifically, the conversion represents variables as explicitly-specified location objects, and location terms (such as a field-type access terms and dereference-type terms) as constructor-specified location objects. The theory of pointers is also expressed by a set of axioms which constrain the operation of the theorem prover module.

Abstract: 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.

Abstract: Visual representations of multiple call stacks in a parallel programming system include a stack segments graph constructed by coalescing data from multiple stacks. The graph has nodes that represent stack segments and has arcs between adjacent segments. Similar stack frames are represented by the same node. In a stack prefix view of the graph, arcs are directed from a node representing stack frames to a node representing subsequently executed stack frames. In a method-centered view, an arc is shown between a node representing stack frames of a selected method and a node representing adjacent stack frames. The graph can be based on call stacks of all tasks or all threads, or based on call stacks of tasks or threads flagged by a user. Stack frame, thread, and/or task details are also displayed.

Abstract: 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.

Abstract: A computer-implemented method for monitoring an object-oriented application is disclosed. A transaction-representative-digraph is built based upon a real-time running of the application, and the digraph contains nodes of a plurality of replaceable classes. A key node is selected based upon invocation relationships between the nodes. A monitor program is instrumented at the selected key node.

Abstract: 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.

Abstract: Apparatuses and methods for producing run-time architectures of computer program modules. One embodiment includes creating an abstract graph from the computer program module and from containment information corresponding to the computer program module, wherein the abstract graph has nodes including types and objects, and wherein the abstract graph relates an object to a type, and wherein for a specific object the abstract graph relates the specific object to a type containing the specific object; and creating a runtime graph from the abstract graph, wherein the runtime graph is a representation of the true runtime object graph, wherein the runtime graph represents containment information such that, for a specific object, the runtime graph relates the specific object to another object that contains the specific object.

Abstract: Provided is an apparatus and method for automatically analyzing a program in order to detect window malicious codes that are programmed to perform malicious behaviors when a specific event occurs, when the specific event does not occur, when a specific program execution condition is satisfied, and when the specific program execution condition is not satisfied.

Abstract: In one embodiment, a method of determining stack usage of at least a portion of a model for deployment on a target system is provided. The method may include obtaining information describing a first target system, and using the information to estimate a stack usage related to executing a representation of a component of the model on the first target system.

Abstract: 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.

Abstract: A computer can be configured to execute event-driven applications by programming the computer with software that provides an event-driven execution environment including an event dispatcher. The event dispatcher can be used to relay events by receiving and dispatching the events from software components of an event-driven application during execution thereof. While the event-driven application is executing, the event dispatcher can be monitored in order to generate and store a log or other record(s) identifying one or more events that occur during execution. The log can be stored in a computer-readable medium accessible by the computing apparatus and used to provide information about at least some of the one or more events. As an example, the log data may be used to generate a timeline showing the relative order of events and the components that generated and listened to the events.

Abstract: A computer method involving receiving by an integrated development environment component an output file from a thread tracking component, generating a Gantt chart of a thread from the output file to visualize a life of the thread, and displaying the Gantt chart to a requesting user.

Abstract: 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.

Abstract: A data structure of a run-time object having a hash value field. The data structure allows an object allocation site to be traced from the run-time object, the object allocation site being a site in a program allocating the run-time object. A method for allowing an object allocation site to be traced from a run-time object includes embedding a value corresponding to the object allocation site in the program. A hash-value field includes the embedded value and the object identifier, and the tracing is performed by identifying the object allocation site that corresponds to the embedded value. A computer system for tracing an object allocation site includes a memory that stores the run-time object; an acquirer that acquires the value from a hash value field; and an identification unit that identifies the object allocation site that corresponds to the acquired value.

Abstract: 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.

Abstract: 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.

Abstract: To achieve end-to-end security, traditional machine-to-machine security measures are insufficient if the integrity of the graphical user interface (GUI) is compromised. GUI logic flaws are a category of software vulnerabilities that result from logic flaws in GUI implementation. The invention described here is a technology for uncovering these flaws using a systematic reasoning approach. Major steps in the technology include: (1) mapping a visual invariant to a program invariant; (2) formally modeling the program logic, the user actions and the execution context, and systematically exploring the possibilities of violations of the program invariant; (3) finding real spoofing attacks based on the exploration.

Abstract: A test coverage analysis method and corresponding apparatus are disclosed, wherein, by executing the program under test using one or more test cases, generating one or more heapdump files containing the call stack information of the program under test, and analyzing the call stack information in the one or more heapdump files, the coverage information of the one or more test cases in terms of functions in the program under test is obtained.

Abstract: Enhanced software architecture diagrams are derived by correlating runtime and static information, thereby allowing the diagrams to span runtime determination boundaries. Runtime determination boundaries are defined by decisions made at runtime, e.g., client-server boundaries, machine-machine boundaries, database-querying program boundaries, web service provider-consumer boundaries, factory caller-instance boundaries, interface call-implementing class boundaries, and reflection boundaries. Correlation may involve identifying instances of types, tracing an identifier injected into a communication channel, using a causality hook, and/or comparing messages leaving a caller with messages entering a callee, for example.

Abstract: Mechanisms are provided for rewriting branch instructions in a portion of code. The mechanisms receive a portion of source code having an original branch instruction. The mechanisms generate a branch stub for the original branch instruction. The branch stub stores information about the original branch instruction including an original target address of the original branch instruction. Moreover, the mechanisms rewrite the original branch instruction so that a target of the rewritten branch instruction references the branch stub. In addition, the mechanisms output compiled code including the rewritten branch instruction and the branch stub for execution by a computing device. The branch stub is utilized by the computing device at runtime to determine if execution of the rewritten branch instruction can be redirected directly to a target instruction corresponding to the original target address in an instruction cache of the computing device without intervention by an instruction cache runtime system.

Abstract: 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.

Abstract: In general, in one aspect, the invention relates to a method for identifying program properties in source code. The method includes: identifying a set of program objects corresponding to a potential program property within the source code; identifying a function associated with the set of program objects in the source code; identifying an input and an output of the function in the source code; creating a value flow graph by: creating a function input node representing the input; creating a function output node representing the output; identifying value flow functions, where each value flow function defines a conditional dependency between a pair of graph nodes, and creating, based on the value flow functions, directed graph edges modeling a potential flow of data through the value flow graph; and identifying a feasible path in the value flow graph depicting an occurrence of the potential program property in the source code.