Abstract: Testing a computer software application by identifying a sink in the computer software application, identifying a source associated with the sink in the application, identifying an entry point associated with the source in the application, where the source is configured to receive input provided externally to the application via the entry point, determining a sink type represented by the sink, and providing to a testing application information identifying the entry point and in association with the sink type.

Abstract: A method for instrumenting a computer-based software application, the method including instrumenting instructions of a computer-based software application, the instructions being in a first computer instruction language, with a native handler referencing instructions in a second language, and creating the instructions referenced by the native handler in the second computer instruction language to carry out at least one task during the execution of the computer-based software application.

Abstract: Embodiments of the invention provide the ability to determine whether a particular application may be safely added to a client computing device. Further, embodiments of the invention also allow for performing a rollback operation on clients experiencing a decrease of performance due to an addition of new software. For example, after a client updates to a new piece of software, a server may monitor the performance of the first client by analyzing a plurality of updates received from the first client. Each update may include a performance indicator. Using the updates, the server may detect a decrease in the performance of the first client. Upon detecting the decrease in the performance, the server may initiate a rollback to a previous state on the first client.

Abstract: Methods and apparatuses that collect code coverage information for selected code locations when executing executable code are described. Source code in one or more files may be annotated at the selected code locations. The executable code may be compiled from the annotated source code using standard compilers. The code coverage information may be collected into a run time data store accessible by other applications. In response to receiving a code coverage request, the code coverage information can be retrieved from the data store to compare with annotations identified from the source code. A code coverage report can be generated to indicate whether one or more of the selected code locations are not covered when executing the executable code.

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

Abstract: Some embodiments of the present invention provide a system that tests a software program. During operation, the system traces a flow of tainted data through the software program during execution of the software program. Next, the system alters the flow by modifying an instruction within the software program. The system then monitors the behavior of the software program after modifying the instruction. Finally, the system analyzes a correctness of the software program based on the monitored behavior.

Abstract: A method, system, and computer-readable medium for identifying root causes of problems in a software factory. Each work packet being executed within the software factory is assigned meta-data, which describes a relationship between that work packet and other work packets, as well as a relationship between that work packet and resources within the software factory. These metrics provides means for identifying any problems within the software factory.

Abstract: In tracking a deadlock caused by at least one application, a computing system is communicatively coupled to a computing device, wherein the computing device has the at least one application. A source code line in the at least one application is identified, wherein the at least one application includes a plurality of source code lines. A deadlock identifier is generated by the computing system and the computing system transmits a first response to the application, wherein first response includes the deadlock identifier. The deadlock identifier is extracted from the first response, the source code line is captured, and a second response is transmitted to the computer system by the application. The second response includes the source code line and the deadlock identifier.

Abstract: A digital rights management system permits an application owner to cause code to be injected into the application's run-time instruction stream so as to restrict execution of that application to specific hardware platforms. In a first phase, an authorizing entity (e.g., an application owner or platform manufacturer) authorizes one or more applications to execute on a given hardware platform. Later, during application run-time, code is injected that performs periodic checks to determine if the application continues to run on the previously authorized hardware platform. If a periodic check fails, at least part of the application's execution string is terminated—effectively rendering the application non-usable. The periodic check is transparent to the user and difficult to circumvent.

Abstract: A runtime system implemented in accordance with the present invention provides an application platform for parallel-processing computer systems. Such a runtime system enables users to leverage the computational power of the parallel-processing computer systems to accelerate/optimize numeric and array-intensive computations in their application programs. A profiling tool is used to collect, analyze, and visualize the performance data of an application in connection with its execution on a parallel-processing computer system through the runtime system. This profiling tool greatly enhances an application developer's ability to understand how an application is executed on the parallel-processing computer system and fine-tune the application to achieve high performance.

Abstract: A data processing apparatus includes a host processing apparatus that can cooperatively verify, using generated Timed software, hardware and software of a semiconductor device mounted with a target processing device and an operating system (OS), wherein the host processing apparatus analyzes an assembler of the target processing device and recognizes a Basic Block, which is a basic unit for calculating information concerning time, and generates Timed software for the cooperative verification with reference to the Basic Block.

Abstract: A method for evaluating a debugger script, the method includes: (i) receiving a debugger script that includes a first debugger breakpoint that is associated with a certain program line number; and determining a validity of the first debugger breakpoint in response to a comparison between expected content associated with the first debugger breakpoint and between an actual content of at least a portion of a certain program line group that comprises a certain program line identified by the certain program line number.

Abstract: In embodiments of the present invention improved capabilities are described for the steps of identifying a functional code block that performs a particular function within executable code; transforming the functional code block into a generic code representation of its functionality by tokenizing, refactoring, or the like, the functional code block; comparing the generic code representation with a previously characterized malicious code representation; and in response to a positive correlation from the comparison, identifying the executable code as containing malicious code.

Abstract: A method and system to automatically insert a test script into a web application is provided. A web browser is monitored to detect the navigation in the web application. The test script is automatically inserted into the web application rendered on a web browser after a navigation is detected in the web application.

Abstract: Code coverage may be provided. First, coverage data and static data may be received. Next, results may be created based on the received coverage data and the received static data. The results may then be displayed.

Abstract: Method, computer readable medium, and system for specifying before-compiled code, compiling the before-compiled code into a compiled code snippet, specifying an insertion point in a compiled code block of a computer program, and inserting the compiled code snippet into the compiled code block at the specified insertion point while the computer program is running.

Abstract: Integrated application of specific CASE tools that allow a user to accomplish instrument programming and control when generating, capturing and/or analyzing electronic signals, and in doing so automatically generate automation code to replicate a desired instrument setup, acquisition, analysis and sequence control. The CASE tools include, but are not limited to, GUI instrument programming tools, an electronic signal redisplay tool, a waveform analyzer tool, automated code generation tools, macro generation tools, macro and sequence playback tools, a test creation tool, a test sequencer tool, a decision engine that may be part of the test sequencer tool, and test result data logger. A method for analyzing electronic signals that enables multiple tests to be performed after a single signal acquisition, and enables results from the multiple tests to be analyzed is also disclosed.

Abstract: Device, system, and method of debugging computer programs. For example, a method for debugging computer programs includes: locating a bug in a computer program based on a first score corresponding to a first instrumentation location of the computer program and a second score corresponding to a second instrumentation location of the computer program.

Abstract: There is provided an autonomic software system and method for normalizing a profile collected for an executing application to account for one or more actions applied to the executing application after the profile was collected, comprising: predicting an impact of applying the one or more actions to the executing application by utilizing the profile and the one or more actions; and adjusting the profile to form a normalized profile according to the predicted impact. A plurality of different a profile consumers, such as, a phase shift detector, an action evaluator as well as a normalizing controller, may utilize the normalized profile to improve the behavior of the executing application. In addition, online visualization tools may be implemented to graphically depict the normalized profiles, as well as differences between the collected profiles and the normalized profiles.

Abstract: Disclosed is a software testing system operative to test a software application, for example during runtime. There may be provided an apparatus for at least partially isolating, from within the software application, at least one highly coupled software component which performs a given function. Isolation may be performed by introducing, prior to execution, code elements for runtime access of application points associated with the at least one highly coupled software component. There may also be provided apparatus for removing or replacing a behavior of at least said at least partially isolated highly coupled software component during runtime.

Abstract: An application builder system and methodology enables a user to create an application using a builder (“builder application”); interactively edit the builder application by adding and removing application objects; interactively edit the properties of the application objects, including a new property called “debug level”; interactively set values of parameters for a code generator, including the value of a new parameter called “debug level”; invoking the code generator to automatically generate application code; and running the resulting generated application.

Abstract: A component name manager operates within an integrated development environment to assist developers in creating dynamic websites and Internet applications. The component name manager identifies an input field displayed on a graphical user interface of an object-oriented software development environment. The input field uses a fully-qualified name of a software component for accessing to access instructions and data associated with the software component and located at an application server. In response to receiving an input associated with the input field, the component name manager displays a list of qualified names of software components available for use in the object-oriented software development environment. Each of the qualified names identifies a path for accessing a corresponding software component. The component name manager can resolve fully qualified names by accessing one or more of an application file, an administrator interface, project level mappings, and global level preference mappings.

Abstract: A software application recreation in a computing environment is provided. One embodiment involves analyzing program execution trace data of a software application, and using the analysis results in recreating an executable version of the software application from data traced at significant points during the software application execution. Recreating an executable version of the software application involves creating white space code to simulate the software application execution timing by replacing business logic code of the software application with white space code in the recreated executable version. The recreated executable version of the software application programmatically behaves essentially similarly to the software application.

Abstract: The disclosure relates to program debugging. More particularly, the disclosure relates to technology for debugging a program without restarting a virtual machine. Embodiments may provide a program debug method in a virtual machine environment, the program running on the virtual machine, the method comprising receiving a request for debugging a program, instrumenting debug logic code into code to be debugged of the program, and running the program code with the debug logic code instrumented, to debug the program.

Abstract: A computer-implemented software self-assembled system and method for providing an external override and monitoring capability to dynamically self-assembling software containing machines that self-assemble execution sequences and data structures. The method provides an external override machine that can be introduced into a system of self-assembling machines while the machines are executing such that the functionality of the executing software can be changed or paused without stopping the code execution and modifying the existing code. Additionally, a monitoring machine can be introduced without stopping code execution that can monitor specified code execution functions by designated machines and communicate the status to an output device.

Abstract: Data relating to execution flows at a computer system is aggregated across multiple execution flows by categorizing each execution flow into an execution flow shape. The execution flows may represent sequences of software components that are invoked or other computer system resources that are consumed. The execution flow shapes are developed by observing and recording the execution flows at the computer system and applying lossy compression rules. Execution flows are categorized into an execution flow shape which is a closest match. The execution flow data may be aggregated by an agent at the computer system, and communicated to a manager for subsequent use. The aggregation combines the information from all execution flows into a small enough data set that can be reported without consuming unduly large processing overhead while still preserving as many of the interesting aspects of the execution flows as possible.

Abstract: Program execution profile data is collected by direct measurement of some code paths, and by inferring data for unmeasured paths. The data collection process may cause errors, which are propagated by the inferencing process. The profile data thus constructed is further enhanced by detecting certain data mismatches, and adjusting inferred data to reduce the scope of errors propagated during the inferencing process. Preferably, a control flow graph of the program being measured is constructed. Mismatches in the total weights of input arcs versus output arcs are detected. For certain specific types of mismatches, it can be known or guessed which count is incorrect, and this count is accordingly corrected. Correction of arc counts proceeds recursively until it is no longer possible to correct mismatches. Additionally, certain other conditions are adjusted as presumed inaccuracies.

Abstract: A dynamic verification system is described that enables application developers to safely include significant custom business logic in their applications. The dynamic verification system receives application behavior criteria that specify behavior of an application of interest to an application host. The system executes an application and instruments an application execution environment to detect application behavior that meets the application behavior criteria. The system determines when the application has performed an action that satisfies the application behavior criteria and provides a notification about the application behavior that occurred that a system administrator can use to take action against the application.

Abstract: A profiler of a multithreaded process that determines whether a process is runnable but not running by determining whether a process is both waiting for the processor and also not waiting for other events such as I/O. Counters are maintained for each such process that is runnable but not running. Reports are generated summarizing data relating to any process that may be starved due to lack of processor time. Information obtained by the method and apparatus assists developers in optimizing resources in multithreaded environments.

Abstract: System aware performance counters including a processor for performing a method that includes executing a predefined code segment of an application, the executing on a processor. The executing includes executing an instrumented thread included in the predefined code segment. The method includes performing a first action associated with executing the instrumented thread in the predefined code segment, and registering the instrumented thread. A performance counter associated with the predefined code segment is started. Also, the execution of the predefined code segment is paused and the performance counter is paused. The method further includes performing a second action associated with pausing the executing of the predefined code segment. The executing of the predefined code segment is resumed and the performance counter is resumed responsive to resuming the executing of the predefined code segment. Also, a third action associated with resuming executing the predefined code segment is performed.

Abstract: In an embodiment, a computer system initiates an application debugging process for an application that is to be debugged and maps runtime object elements of the application to both code elements and graphical elements. The computer system appends portions of software code to each runtime object element so that a runtime event is outputted indicating which corresponding graphical or code element is currently being processed. The computer system accesses the outputted runtime events to determine which graphical or code element is currently being processed and, based on the accessed outputted runtime events and based on the mappings, displays the elements currently being debugged in a first view. The computer system, based on the accessed outputted runtime events and based on the mappings, switches views from the first view to a second view without restarting the application debugging process for the application being debugged.

Abstract: A method for replay of program executions using cross-entropy is provided. The method comprises identifying a first sequence of decision points, wherein the first sequence represents a first execution of a logic code; identifying a second sequence of decision points, wherein the second sequence represents a second execution of the logic code; computing a distance between the first and second executions; and minimizing the distance between the first and second executions using cross-entropy, in response to determining that the second execution is not within a predetermined threshold distance of the first execution.

Abstract: Methods, systems and machine readable media are disclosed for performing dynamic information flow tracking. One method includes executing operations of a program with a main thread, and tracking the main thread's execution of the operations of the program with a tracking thread. The method further includes updating, with the tracking thread, a taint value associated with the value of the main thread to reflect whether the value is tainted, and determining, with the tracking thread based upon the taint value, whether use of the value by the main thread violates a specific security policy.

Abstract: An embodiment of the present invention comprises a method of configuring one or more target network devices for operation, that further comprises the steps of creating an object for deployment to a predetermined target network device, the object having configuration data for configuring the target network device, and at least one of identification data identifying the object, an autonomous encapsulated agent for executing necessary steps for installing the configuration data, identification data identifying the predetermined target network device, and authentication data for authenticating at least one of the predetermined target network device identification data and object identification data, transporting the object to the predetermined target network device, and the autonomous encapsulated agent begins an on-site process of installing the configuration data in the predetermined target network device.

Abstract: A method and system for automatic analysis of an application's runtime configuration settings is provided. The configuration processing system includes a monitoring component and an analysis component. The monitoring component observes requests for configuration information stored in configuration data stores of a monitored device. For example, the monitoring component may observe requests directed to the configuration data stores when an application starts, during runtime, and when the application exits. The monitoring component may record the observed requests in a file or data structure that may be accessed by or sent to the analysis component. Based on the observed requests of an application, the analysis component automatically identifies a reduced set of configuration settings which likely correspond to user-specific configuration settings used by the application.

Abstract: Preventing a resource leak is disclosed. An indication that an implementation object is no longer referenced by a user of the implementation object is received. The implementation object is prevented from becoming unavailable until after it is determined whether a resource associated with the implementation object is released.

Abstract: A software system is disclosed which facilitates the process of tracing the execution paths of a program, called the client. The tracing is performed without requiring modifications to the executable or source code files of the client. Trace data collected during the tracing operation is collected according to instructions in a trace options file. At run time, the tracing library attaches to the memory image of the client. The tracing library is configured to monitor execution of the client and to collect trace data, based on selections in the trace options file. Conditional tracing, through the use of triggers and actions taken in response to the triggers, allows the developer to control the tracing operation. The triggers can be conditional triggers in which the corresponding action is taken only if a conditional expression is satisfied. The system can trace multiple threads and multiple processes. The tracing system provides a remote mode and an online mode.

Abstract: Instrumentation is dynamically added to application components during runtime. An interestingness engine receives inputs from various sources which identify software components such as classes for which it is desired to provide instrumentation. The sources can include a heuristics engine which receives performance data from already-instrumented components, a user interface from which a user identifies component to be instrumented or de-instrumented, and a static list of components to be instrumented. During the runtime, instrumentation can be added to components which become interesting, or removed from components which become not interesting. When loading or redefining a component, if a component type matches rules, it is eligible for instrumentation, and the interestingness engine is consulted to determine whether the component is of interest, in which case instrumentation is added.

Abstract: Embodiments of parallelization and/or instrumentation in a producer graph oriented programming framework have been presented. In one embodiment, a request to run an application program is received, wherein object-oriented source code of the application program includes methods and producer dependency declarations, wherein the producer dependency declaration for a given method identifies a set of zero or more producers with outputs that are an input to the given method, wherein a producer is at least an instance and a method associated with that instance. Further, execution of the application program may be parallelized based on dependency between producers of the application program using the runtime. In some embodiments, the application program is instrumented using the runtime.

Abstract: The execution of a software application is diverted to detect software object corruption in the software application. Software objects used by the software application are identified and their pointers are inspected. One or more tests are applied to pointers pointing to the virtual method tables of the software objects, addresses (or pointers) in the virtual method tables, and memory attributes or content of the memory buffer identified by the addresses for inconsistencies that indicate corruption. A determination of whether the software objects are corrupted is made based on the outcome of the tests. If software object corruption is detected, proper corrective actions are applied to prevent malicious exploitation of the corruption.

Abstract: In a distributed system that includes a debug server and debug clients coupled for data communications through a data communications network, where the debug server includes a debug administrator, a message router, a back-end debugger, and a debuggee, collaborative software debugging includes: receiving, by the debug server from the debug clients asynchronously during a debug session of the debuggee, a plurality of application-level messages, receiving, from a requesting debug client, a request to notify other debug clients that the requesting debug client is presently modifying a value of a particular variable; routing, by the message router, the application-level messages among the debug clients, the debug administrator, and the back-end debugger, including distributing to the other debug clients a notification of the modification the value of the particular variable; and returning, to the debug clients, client-specific debug results.

Abstract: Where a process in a computing system comprises mixed code, having different sections of code managed by different runtimes, the call stack used to coordinate function invocations may comprise call stack frames created according to multiple calling conventions. In order to analyze this call stack in a stack walk or unwinding, a debugger may be configured to request the runtimes managing the process to claim a particular call stack frame, and to request the runtime that claims it to parse the contents of the frame, or to utilize call stack analysis techniques if the call stack frame was created by unmanaged code.

Abstract: A technique is disclosed for determining off-line the number and location of instrumentation probes to be inserted into a program under testing, and subsequently instrumenting the program at run-time based on the off-line analysis. In accordance with the illustrative embodiment, an off-line analyzer first determines instrumentation locations for a program under test in accordance with a method called the Super Nested Block Method. After the instrumentation locations have been determined, a testing/monitoring tool executes the program and a run-time instrumenter in parallel. The run-time instrumenter accordingly inserts probes into the program, removes probes after they have been executed once, and generates and reports information about code coverage based on the probes.

Abstract: A code profiler can be digitally encoded in a storage medium that is configured to automatically detect an existence of non-modifying transforms within monitored programmatic code using hash codes of arguments of the monitored programmatic code.

Abstract: A computer implemented method, apparatus, and computer usable program code for sampling call stack information. An accumulated latency time is monitored for a set of threads executing in a data processing system. The call stack information is obtained for the thread in response to a thread in the set of threads having an associated accumulated latency exceeding a threshold.

Abstract: An instruction trace of a first instruction string is generated from a second instruction string obtained by sampling, at predetermined intervals, the first instruction string. The second instruction string is divided into partial instruction strings. A combination of the partial instruction strings is selected based on the similarity of stored partial instruction strings. A plurality of combination patterns are generated by combining instructions included in the selected partial instruction strings. A likelihood is calculated for each of the combination patterns, and the combination patterns are stored in the storage unit based on the likelihood.

Abstract: Generally, this disclosure describes systems and methods for transparently instrumenting a computer process. The systems and methods are configured to allow instrumenting executable code while permitting legacy memory scanning tools to monitor corresponding uninstrumented executable code stored in memory.

Abstract: A computer-implemented method of performing runtime analysis on and control of a multithreaded computer program. One embodiment of the present invention can include identifying threads of a computer program to be analyzed. With a supervisor thread, execution of the identified threads can be controlled and execution of the identified threads can be monitored to determine a status of the identified threads. An indicator corresponding to the determined status of the threads can be output.

Abstract: A method and system for creating uniquely representative execution path identifiers of software program. The method comprises the steps of running the software program, continuously accessing execution information of the software program, identifying execution sequences of the execution information, and creating a unique execution path identifier of each of the execution sequences by summing the execution information when the execution information is within a functional boundary thereof so as to create an execution path identifier representing a unique execution sequence of the execution information. The system comprises an execution path identification creator continuously receiving and accessing execution information of the software program, identifying execution sequences of the execution information and creating the unique execution path identifier of each of the execution sequences.

Abstract: Various technologies and techniques are disclosed for using Petri Nets for diagnostics of concurrent programs. One or more initial traces are obtained from a concurrent program that executed properly. The initial trace is used to create a Petri Net. To generate the Petri Net, unique task identifiers and places of interest are generated, and transitions are added. The resulting Petri Net is stored for later use in differential debugging. A trace is obtained from a later execution of the concurrent program that did not execute properly. The later trace is run against the Petri Net to identify at least one difference. A Petri Net can also be used for model checking of concurrent programs. A model checking process is performed to analyze possible executions in the Petri Net to look for one or more problems. A result of the model checking process is output.