Inventors list

Assignees list

Classification tree browser

Top 100 Inventors

Top 100 Assignees


Tracing

Subclass of:

717 - Data processing: software development, installation, and management

717100000 - SOFTWARE PROGRAM DEVELOPMENT TOOL (E.G., INTEGRATED CASE TOOL OR STAND-ALONE DEVELOPMENT TOOL)

717124000 - Testing or debugging

717127000 - Monitoring program execution

Patent class list (only not empty are listed)

Deeper subclasses:

Entries
DocumentTitleDate
20130086558Testing Program Code in Multiple Process Modes - The subject disclosure is directed towards testing program code in multiple process modes without developing separate test case source code for each process mode. Source code for one or more test cases is developed once in accordance with a standard template. Two or more process mode implementations associated with the one or more test cases are built using common source code. Based on a test command, one or more of the process mode implementations is selected for executing a test plan.04-04-2013
20110202903APPARATUS AND METHOD FOR DEBUGGING A SHARED LIBRARY - An apparatus and method for debugging a shared library are provided. By performing the shared library-based debugging as described herein, instead of application process-based debugging, the limit of physical memory may be reduced and debugging efficiency may be improved by un-mapping a virtual map page in application processes that are mapped with the physical and logical memory addresses of the shared library.08-18-2011
20120246623APPLICATION INTEGRATED ISSUE MANAGEMENT - The disclosed embodiments relate to an application integrated issue management system wherein a given computer software program includes, in addition to the particular functionality for which the program was designed, integrated issue reporting and tracking functions which allow a user to both report issues, e.g. bugs, defects, enhancements, new function requests, user inquiries, user comments, or combinations thereof, to the software developer's project management system, as well as track previously submitted issue reports in the developer's project management system, without having to leave or otherwise terminate the computer software program. Thereby, a convenient mechanism for reporting and tracking issues is provided which encourages participation by the user of the computer software program. Additional functionality may also be provided, also within the context of the computer software program, such as allowing the user to view issue reports submitted by other users or to assist the developer in selecting which issues to address first, such as by voting on, or ranking, those issues which the user thinks are significant. Further, automated monitors may monitor operation of the computer software program to look for operational patterns, such as inter-operational latencies, which may be indicative of a problem. Upon detection of a suspect pattern of operation, an issue report may be automatically generated and submitted. Suspect patterns may be defined by the developer and/or by the user, such as based on provisions of a service level agreement between the user and the developer defining, for example, tolerances for inter-operational latencies or other operational parameters.09-27-2012
20130081001IMMEDIATE DELAY TRACKER TOOL - An immediate delay tracker tool listens for the occurrence of user-specified events that exceed a delay threshold. In an embodiment, the events are associated with immediate user actions processed by a user interface (UI) thread where the response time of the immediate user action requires an instantaneous response. When the event exceeds the delay threshold, the control flow of all the processes and/or threads in the system is recorded, filtered and then analyzed for the source of the delay.03-28-2013
20100042978TEMPLATE MODEL FOR METADATA CAPTURE - The illustrative embodiments provide a method, system and computer program product for automatically capturing metadata using a template model. The template model is assembled for automatically capturing metadata during one or more stages of the life cycle of an application. Included in the template model are a description and a source of the metadata during a particular stage of the application lifecycle. The template model further includes multiple fields for dynamically capturing metadata. The template model fields may include: a stage field, an item field, a type field, specific source field, indicative field, a source list field, an analyzer reference field, default value field, and default reason field. A unique label associated with the stage field, of the template model, is read to identify the current stage of the lifecycle. The metadata associated with the current stage is automatically captured, then communicated to the application.02-18-2010
20100042977Selective Execution of Trace Mechanisms for Applications Having Different Bit Structures - A computer implemented method, a computer program product, and a data processing system trace information about current context and system state for either 32-bit or 64-bit applications. A 32-bit trace executable code and a 64-bit trace executable code are compiled for a trace script. A determination is then made as to whether an application process is a 32-bit process or a 64-bit process. Responsive to determining that the application process is the 32-bit process or the 64-bit process, an internal indicator is set to indicate the application process as either a 32-bit process or a 64-bit process. Subsequently, the internal indicator is identified as either indicating the 32-bit process or the 64-bit process. If the internal identifier indicates the application process is a 32-bit process, an instruction pointer is set to indicate the 32-bit trace executable code, and the 32-bit trace executable code is executed. If the internal identifier indicates the application process is a 64-bit process, an instruction pointer is set to indicate the 64-bit trace executable code, and the 64-bit trace executable code is executed.02-18-2010
20100333072INTEGRATED PERFORMANCE AND LOAD TESTING TOOL FOR APPLICATION SERVERS - Implementations of the present disclosure provide for testing an application, and include loading a testing tool by a client that is in communication with an application server that executes the application, introducing probe code into a routine by a first component of the testing tool, the routine being called during execution of the application, and transmitting a request to the application using a second component of the testing tool. An elapsed time of an execution of the routine is determined based on the probe code, and a response is generated from the application server based on the request. A response time is determined based on the request and the response, and performance statistics are calculated based on the elapsed time and the response time.12-30-2010
20100333071Time Based Context Sampling of Trace Data with Support for Multiple Virtual Machines - Mechanisms for time based context sampling of trace data with support for multiple virtual machines are provided. In response to the occurrence of an event, a plurality of sampling threads associated with a plurality of executing threads executing on processors of a data processing system are awakened. For each sampling thread, an execution state of a corresponding executing thread is determined with regard to one or more virtual machines of interest. For each sampling thread, based on the execution state of the corresponding executing thread, a determination is made whether to retrieve trace information from a virtual machine of interest associated with the corresponding executing thread. For each sampling thread, in response to a determination that trace information is to be retrieved from a virtual machine of interest associated with the corresponding executing thread, the trace information is retrieved from the virtual machine.12-30-2010
20100107144AUTOMATED IDENTIFICATION OF REDUNDANT METHOD CALLS - Embodiments of the invention use an automated procedure to detect the occurrence of redundant or duplicate method calls in a running program. Software developers may then be notified of the redundant calls, and correct the redundancies if necessary. One embodiment, directed to a process or inventive method, is associated with a program disposed to run on a data processing system, wherein the program is provided with one or more methods that can be selectively called when the program is running. The process includes the step of collecting specified data each time that a call to a given one of the methods occurs, wherein a given call to the given method is associated with a set of arguments comprising one or more particular argument values for the given method, and the collected data includes an element uniquely identifying each of the particular argument values. The process further includes storing the collected data at a selected location, and selecting a call threshold for the given method, wherein the call threshold comprises a specified number of occurrences of the given call to the given method, when the program is running. The collected data is selectively analyzed at the storage location, to determine whether an occurrence of the given call to the given method has exceeded the call threshold.04-29-2010
20100107143Method and System for Thread Monitoring - An apparatus and methods for hardware-based performance monitoring of a computer system are presented. The apparatus includes: processing units; a memory; a connector device connecting the processing units and the memory; probes inserted the processing units, and the probes generating probe signals when selected processing events are detected; and a thread trace device connected to the connector device. The thread trace device includes an event interface to receive probe signals, and an event memory controller to send probe event messages to the memory, where probe event messages are based on probe signals. Also presented is a method that includes: inserting event probes in hardware-based processing units, where the event probes generate probe events when predetermined processing events are detected; configuring a hardware-based device to generate probe event messages based on said probe events; and transferring the probe event messages to a memory. The probe event messages transferred to memory can be subsequently analyzed using a software program to determine, for example, thread-to-thread interactions.04-29-2010
20100107142SCALABILITY ANALYSIS FOR SERVER SYSTEMS - Described is predicting cache locality in a multicore/multithreaded processing environment including when threads share cache data in a non-uniform interleaving manner. Thread execution traces are analyzed to compute a set of per-thread parameters that can then be used to predict cache miss rates for other cache sizes. In one aspect, a model is based upon a probability that the cache reuse distance will increase because of accesses by other threads, and another probability that the reuse distance will decrease because of intercept accesses by other threads to shared data blocks. Estimates of the number of shared data blocks, possibly shared data blocks and private data blocks are used in the computations.04-29-2010
20130042223METHODS AND/OR SYSTEMS FOR DETERMINING A SERIES OF RETURN CALLSTACKS - To reconstruct a call stack, a range of call addresses is determined. Based on the range of addresses, raw stack data is extracted based on the execution of a computer program. The raw stack data is parsed to reconstruct a call stack (or a series of call stacks). In obtaining the call stack, a depth between a function and a return address is calculated.02-14-2013
20090119645SYSTEM FOR BOUNDARY TRACE WITH REPRODUCTION FACILITY - Disclosed herein is a data processing system-implemented method, a data processing system, and an article of manufacture for investigating computer software. The data processing system-implemented method includes capturing tracing information at one or more boundary points of the computer software, and reproducing a behavior of the computer software at the boundary points based on the captured tracing information.05-07-2009
20100095280METHOD AND SYSTEM FOR PROVIDING LOITERING TRACE IN VIRTUAL MACHINES - A system and method are provided for performing loitering trace in virtual machines. In one embodiment, status of objects in a garbage collection heap at a first virtual machine at a server is identified, in response to a memory leak. First objects that are used are identified. Second objects that are alive and not being used are identified. Information regarding the first objects and the second objects is communicated to a second virtual machine at a client.04-15-2010
20130047141TRACKING OF CODE BASE AND DEFECT DIAGNOSTIC COUPLING WITH AUTOMATED TRIAGE - In response to a test case error generated by execution of a test case against a code build, a source code segment that caused the test case error is identified by a defect monitor. The identified source code segment is linked to the test case that generated the test case error. The linked source code segment is monitored for code changes. A determination is made as to whether a test case re-execution criterion associated with the test case has been satisfied based upon a detected code change of the linked source code segment. An indication to re-execute the test case is generated in response to determining that the test case re-execution criterion associated with the test case has been satisfied.02-21-2013
20130047140TRACKING OF CODE BASE AND DEFECT DIAGNOSTIC COUPLING WITH AUTOMATED TRIAGE - In response to a test case error generated by execution of a test case against a code build, a source code segment that caused the test case error is identified by a defect monitor. The identified source code segment is linked to the test case that generated the test case error. The linked source code segment is monitored for code changes. A determination is made as to whether a test case re-execution criterion associated with the test case has been satisfied based upon a detected code change of the linked source code segment. An indication to re-execute the test case is generated in response to determining that the test case re-execution criterion associated with the test case has been satisfied.02-21-2013
20120233600INFORMATION PROCESSING APPARATUS AND METHOD OF ACQUIRING TRACE LOG - In an information processing apparatus, a program execution section executes a program, and in the stage of execution of a log acquisition command, acquires the value of a variable set in the log acquisition command. A trace log generation section generates a trace log including identification information on a file set in the log acquisition command, version number on a source code, and the acquired value of the variable, and stores the trace log in a storage device. A source code acquisition section acquires a source code corresponding to a combination of the identification information and the version number, based on the trace log. A character string addition section extracts a character string related to the value of the variable included in the trace code, from the acquired source code, adds the extracted character string to the trace log, and stores the trace log in a storage device.09-13-2012
20090319998SOFTWARE REPUTATION ESTABLISHMENT AND MONITORING SYSTEM AND METHOD - Knowledge of a module's behavior when the module's reputation is formed is obtained. If the module's behavior changes, this change is detected. In one embodiment, upon a determination that the module's behavior has changed, the module's original reputation is lost. In this manner, malicious trusted modules are detected and defeated.12-24-2009
20090307668SOFTWARE PROBLEM IDENTIFICATION TOOL - A method for identifying a problem in a software application is presented. The method may include enabling a user to define at least one usage scenario for a software application. The software application may be executed on a reference computer system according to the usage scenario and data reflecting a status of the reference computer system and the software application during execution may be acquired. The software application may be further executed in a subject computer system according to the usage scenario. Data reflecting a status of the subject computer system and the software application during execution may likewise be acquired. Finally, the data from the reference computer system may be compared with the data from the subject computer system to identify at least one difference therebetween.12-10-2009
20090307667ASSISTING DEBUG MEMORY TRACING USING AN INSTRUCTION ARRAY THAT TRACKS THE ADDRESSES OF INSTRUCTIONS MODIFYING USER SPECIFIED OBJECTS - The present invention discloses a solution for increasing the immediacy in determining a point of failure after an unexpected program termination. In the solution, a user determined object is identified by a user at compile time, where the identified object is one to be tracked. The compiler introduces executable code into the source code which is able to track modifications made to the object members during run-time. During execution, the address of each instruction modifying to the object is stored in an instruction pointer (IP) array associated with the tracked object. The IP array is continuously updated during program execution when an instruction modifies a member of the tracked object. When an unexpected program termination occurs, the instruction pointer array can be presented to a debugging agent to assist in determining the instruction causing the termination. The debugging agent can be a human agent, debugging software, report generation software, and the like.12-10-2009
20130074050SELECTIVE TRACE FACILITY - An approach to selectively recording trace data. The approach sifts through process control and state data to store data that is most relevant to aiding debugging while reducing the overall amount of data that is stored in a trace data set by a trace facility. The approach may involve initiating a trace operation for the software component and, for each resource of the software component, determining whether the resource is currently in use. For those resources in use, the current state of the resource is compared with the previous state of the resource. If the current state has changed, the current state is written to the trace data set. If the resource is not in use, or the current state has not changed, no entry is made to the trace data set. The approach may also analyze users to determine which resources the users are holding and/or waiting for.03-21-2013
20100299654APPROACH FOR ROOT CAUSING REGRESSION BUGS - A stable program, a new program version and a test case which passes (or fails) in the first program may be analyzed. Another new input may be found that either exhibits the similar (different) behavior as that of the test case in the first program (or second program) or follows different (similar) behavior as that of the test case in the new program version. In the first case, the trace of the test case and the new input in the second code version while in the second case, the trace of the test case and the new input in the original program are compared to produce a bug report. By reviewing the bug reports, divergences may be found and error causing code lines may be isolated.11-25-2010
20130061212Modern Application Tracing - Modern application tracing techniques are described herein that enable dynamic logging of events declared in a static manifest. Various events for logging can be declared in a static manifest. The static manifest may then be compiled to translate the declared events into a library of corresponding functions that can be called by “modern” applications written using dynamic code. Calls made to these functions from dynamic code are converted to corresponding static events and forwarded to existing tracing application programming interfaces (APIs) designed to handle logging of static events for “legacy” applications that use compiled code. In this manner, static functions that are compatible with tracing APIs can be created and called dynamically from dynamic code. This can occur without requiring administrative rights to install the code and while preserving existing features for legacy applications, such that a tracing log can include events from both modern applications and legacy applications.03-07-2013
20110067008TECHNIQUES FOR ADAPTIVE TRACE LOGGING - Techniques for adaptive trace logging include, in one embodiment, obtaining input data on trace logging behavior and computing resources used by trace logging. Based on the obtained input data, an adaptive trace logging module automatically takes action at runtime to reduce the amount of computing resources consumed by tracing logging. For example, the action taken may include decreasing a trace logging level of an executing software program to reduce the number of trace logging messages added to a trace log. In another embodiment, the techniques include detecting a condition of an executing software program that warrants a change to a trace logging level of the executing program. The adaptive trace logging module automatically changes the trace logging level of the executing program as-needed for the detected condition. For example, the adaptive trace logging module may increase the trace logging level of an executing program upon detecting a deadlock or other abnormal condition of the executing program. By automatically increasing the trace logging level upon detecting an abnormal condition, additional trace logging messages may be written to a trace log aiding diagnosis and troubleshooting of the condition.03-17-2011
20120117546Run-time Module Interdependency Verification - A method for determining intermodule dependency in software having a plurality of modules, at least a portion of the modules, executing calls to other modules, comprising loading the software modules into a memory, preferably in a contiguous extent, with the modules being logically separated; executing instructions of the software step-by-step with threading disabled; determining whether when an instruction is executed, a module other than the current modules is being called; and if a module other than the current module is being called, storing data sufficient to identify the calling instruction, the calling module, the called instruction and the called module. A computer readable medium, to which a processor of a system is operatively coupled, having executable instructions stored thereon for executing the method on a computer. A computer programmed to execute the method.05-10-2012
20090249303RANDOM ACCESS TO HISTORICAL PROGRAM STATE FOR ENHANCED DEBUGGING - A method in one embodiment includes: executing a program; performing testing on the program; logging every input to the program during the testing; logging every result during testing of the program; storing the logged results; and allowing a user to search the logged results. If a failure occurs during the testing: performing a comparison between a successful testing of the program and the failed testing of the program; rerunning the successful testing and the failed testing in parallel; analyzing the logged results for determining occurrence of events during testing of the program; generating a timeline of the events; and outputting the timeline of the events.10-01-2009
20090007076Synchronizing Triggering of Multiple Hardware Trace Facilities Using an Existing System Bus - A method, apparatus, and computer program product are disclosed in a data processing system for synchronizing the triggering of multiple hardware trace facilities using an existing bus. The multiple hardware trace facilities include a first hardware trace facility and a second hardware trace facility. The data processing system includes a first processor that includes the first hardware trace facility and first processing units that are coupled together utilizing the system bus, and a second processor that includes the second hardware trace facility and second processing units that are coupled together utilizing the system bus. Information is transmitted among the first and second processing units utilizing the system bus when the processors are in a normal, non-tracing mode, where the information is formatted according to a standard system bus protocol. Trigger events are transmitted to the hardware trace facilities utilizing the same standard system bus, where the trigger events are also formatted according to the standard system bus protocol.01-01-2009
20080295081FRAMEWORK FOR CONDITIONALLY EXECUTING CODE IN AN APPLICATION USING CONDITIONS IN THE FRAMEWORK AND IN THE APPLICATION - A computer implemented method, apparatus, and computer usable program code for returning a return code to an error hook in an application using a framework. An identifier and a pass-through are received from the error hook. The error hook is software code in the application. The pass-through is a set of parameters. If the identifier has an active status, a set of framework conditions is retrieved using the identifier. If the set of framework conditions is met, an inject callback is retrieved using the error identifier. The inject callback is called with the error identifier and the pass-through. An inject callback return code is received. If the inject callback return code is an execute return code, the execute return code is returned to the error hook.11-27-2008
20090070746METHOD FOR TEST SUITE REDUCTION THROUGH SYSTEM CALL COVERAGE CRITERION - A method and apparatus is disclosed herein for determining whether a test case is to be included in a test suite. In one embodiment, the method comprises executing an application with test inputs of a test case during performance of software application testing and using a Finite State Machine (FSM) model of observable events generated from execution of other test cases in the test suite to determine whether to include the test case in the test suite for use in future testing of the application.03-12-2009
20080288926Computer Implemented Method and System for Accurate, Efficient and Adaptive Calling Context Profiling - Computer implemented method, system and computer usable program code for profiling the execution of an application that is both space-and time-efficient and highly accurate. A computer implemented method for profiling the execution of an application includes sampling execution characteristics of the application at a plurality of sampling points to provide samples, and deriving a calling context of the samples. The application is continuously executed between sampling points while additional profiling data is gathered.11-20-2008
20110041122AUTOMATIC IDENTIFICATION OF EXECUTION PHASES IN LOAD TESTS - A method for automatic identification of execution phases in load test data includes receiving load test data indicating processor utilization for threads over a period of time divided into a plurality of intervals. For each pair of proximate intervals, it is determined whether thread-wise processor utilization for a first interval is statistically indistinguishable from that of a second interval. The pair of proximate intervals is combined when it is determined that the processor utilization for the first interval is statistically indistinguishable from that of the second interval. Each of the pair of proximate intervals is divided into subintervals when it is determined that the first interval is not statistically indistinguishable the second interval. One or more execution phases are automatically identified as occurring between proximate intervals that are not substantially equivalent.02-17-2011
20110283262ENHANCED RELIABILITY USING DETERMINISTIC MULTIPROCESSING-BASED SYNCHRONIZED REPLICATION - A hardware and/or software facility for executing a multithreaded program is described. The facility causes each of a plurality of machines to execute the multithreaded program deterministically, such that the deterministic execution of the multithreaded program is replaced across the plurality of machines. The facility detects a problem in the execution of the multithreaded Program by one of the plurality of machines. In response, the facility adjusts the execution of the multithreaded program by at least one of the machines of the plurality.11-17-2011
20110302560REAL-TIME PROFILING IN A MULTI-CORE ARCHITECTURE - An apparatus comprising a first core of a multi-core processor, a second core of a multi-core processor and a bus matrix. The first core may be configured to communicate through a first input/output port. The first core may also be configured to initiate a testing application. The second core may be configured to communicate through a second input/output port. The second core may also be configured to respond to the testing application. The bus matrix may be connected to the first input/output port and the second input/output port. The bus matrix may transfer data between the first core and the second core. The testing application may generate real-time statistics related to the execution of instructions by the second core.12-08-2011
20110302561ARCHITECTURE-AWARE FIELD AFFINITY ESTIMATION - A data layout optimization may utilize affinity estimation between paris of fields of a record in a computer program. The affinity estimation may be determined based on a trace of an execution and in view of actual processing entities performing each access to the fields. The disclosed subject matter may be configured to be aware of a specific architecture of a target computer having a plurality of processing entities, executing the program so as to provide an improved affinity estimation which may take into account both false sharing issues, spatial locality improvement and the like.12-08-2011
20110289485Software Trace Collection and Analysis Utilizing Direct Interthread Communication On A Network On Chip - Collecting and analyzing trace data while in a software debug mode through direct interthread communication (‘DITC’) on a network on chip (‘NOC’), the NOC including integrated processor (‘IP’) blocks, routers, memory communications controllers, and network interface controllers, with each IP block adapted to a router through a memory communications controller and a network interface controller, where each memory communications controller controlling communications between an IP block and memory, and each network interface controller controlling inter-IP block communications through routers, including enabling the collection of software debug information in a selected set of IP blocks distributed through the NOC, each IP block within the selected set of IP blocks having a set of trace data; collecting software debugging information via the set of trace data; communicating the set of trace data to a destination repository; and analyzing the set of trace data at the destination repository.11-24-2011
20090150869SYSTEM AND METHOD OF MONITORING DYNAMIC SCOPES IN SYNCHRONOUS AND ASYNCHRONOUS CALLS - A system and method for monitoring dynamic scopes in a runtime environment is disclosed. The system and method utilizes an algorithm which may be applied to both synchronous and asynchronous invocations. The method comprises determining an initial scope of a source component, the initial scope being a scope of the source component upon providing a synchronous call to invoke a target component. The scope declaration specified by the target component is determined. A resultant scope present upon invocation of the target component is then determined. The resultant scope is determined based on the initial scope of the source component and the scope declaration specified by the target component. A record is stored in a centralized location identifying the resultant scope, and the target component as a participant in the resultant scope.06-11-2009
20100005455MANAGING SOFTWARE DEPENDENCIES DURING SOFTWARE TESTING AND DEBUGGING - A solution for managing software dependencies during software testing and debugging includes a capture module configured to capture a software call stack of a software execution environment, each software call of the software call stack including a call signature and a call result. The solution defines a set of proxied software calls within the software call stack suitable for simulating conversation responses to runtime software calls by a target application. Once a set of proxied software calls is defined, a playback module recognizes runtime software calls by the target application that are within the set of proxied software calls and responds to the recognized runtime software call with a captured call result corresponding to the recognized software call.01-07-2010
20090049429Method and System for Tracing Individual Transactions at the Granularity Level of Method Calls Throughout Distributed Heterogeneous Applications Without Source Code Modifications - The present invention provides a method and system for tracing and monitoring of distributed transactions spanning multiple threads or processes, running on multiple host systems, connected by a computer network. The correlation of distributed transactions is based on information that uniquely may identify execution paths within a virtual machine, additional to information which uniquely may identify the virtual machine that processes the execution path. The correlation information is transferred from a monitored thread to threads that are activated by the monitored thread and allows to reconstruct parent-child relations between different threads. Participating threads may run in different processes, in different virtual machines or on different host systems.02-19-2009
20120110551SIMULATING BLACK BOX TEST RESULTS USING INFORMATION FROM WHITE BOX TESTING - Systems, methods are program products for simulating black box test results using information obtained from white box testing, including analyzing computer software (e.g., an application) to identify a potential vulnerability within the computer software application and a plurality of milestones associated with the potential vulnerability, where each of the milestones indicates a location within the computer software application, tracing a path from a first one of the milestones to an entry point into the computer software application, identifying an input to the entry point that would result in a control flow from the entry point and through each of the milestones, describing the potential vulnerability in a description indicating the entry point and the input, and presenting the description via a computer-controlled output medium.05-03-2012
20130219372Runtime Settings Derived from Relationships Identified in Tracer Data - An analysis system may perform network analysis on data gathered from an executing application. The analysis system may identify relationships between code elements and use tracer data to quantify and classify various code elements. In some cases, the analysis system may operate with only data gathered while tracing an application, while other cases may combine static analysis data with tracing data. The network analysis may identify groups of related code elements through cluster analysis, as well as identify bottlenecks from one to many and many to one relationships. The analysis system may generate visualizations showing the interconnections or relationships within the executing code, along with highlighted elements that may be limiting performance.08-22-2013
20100088683SYSTEM AND METHOD FOR SOFTWARE DIAGNOSTICS USING A COMBINATION OF VISUAL AND DYNAMIC TRACING - A software system is disclosed that provides remote troubleshooting and tracing of the execution of computer programs. The software system allows a remote software developer or help desk person to troubleshoot computer environment and installation problems such as missing or corrupted environment variables, files, DLLs, registry entries, and the like. In one embodiment the software system includes an information-gathering module that gathers run-time information about program execution, program interaction with the operating system and the system resources. The information-gathering module also monitors user actions and captures screen output. The information-gathering module passes the gathered information to an information-display module. The information-display module allows a support technician (e.g., a software developer, a help desk person, etc.) to see the user interactions with the program and corresponding reactions of the system. In one embodiment, the information-display module allows the support technician to remotely view environment variables, file access operations, system interactions, and user interactions that occur on the user's computer and locate failed operations that cause execution problems04-08-2010
20100083236COMPACT TRACE TREES FOR DYNAMIC BINARY PARALLELIZATION - Methods and apparatus relating to compact trace trees for dynamic binary parallelization are described. In one embodiment, a compact trace tree (CTT) is generated to improve the effectiveness of dynamic binary parallelization. CTT may be used to determine which traces are to be duplicated and specialized for execution on separate processing elements. Other embodiments are also described and claimed.04-01-2010
20100083237Reducing trace overheads by modifying trace operations - A method of compiling a computer program to improve trace efficiency is disclosed. The computer program comprises a plurality of trace operations for triggering output of trace data generated by said computer program, and the method of compiling comprises the steps of: transforming said computer program into code forming an intermediate version of said computer program; analysing said transformed code; replacing at least some of said trace operations with modified trace operations; transforming said code into code suitable for execution on a data processing system; and generating translation data relating said modified trace operations to said trace operations they replaced.04-01-2010
20090089760COMPUTER PROGRAM PRODUCT OF CODE COVERAGE UTILIZING EFFICIENT DYNAMIC MUTATION OF LOGIC (EDML) - A computer program product for code coverage utilizing efficient dynamic mutation of logic (EDML) are provided. A source code is read, and instrumentation points are located. Self Modifying Code (SMC) is inserted at the instrumentation points producing instrumented code. Additional functions are inserted in the source code to enable read and/or reset of code coverage statistics. The instrumented code is compiled, and executables are run for a period of time during which zero or more instrumentation points are executed. In response to executing instrumentation points, instructions are executed to record execution of the instrumented code. Instructions of the instrumented code overwrite themselves at certain points so that a next execution of the instrumentation points skips over the instrumented code at the certain points. Code coverage statistics are gathered and recorded. The code coverage statistics are reset to begin another period of time for gathering code coverage statistics.04-02-2009
20120297370Stack Analysis for Post Mortem Analysis - A debug tool that generates a call stack listing by analyzing the crash memory dump data without relying on register data values. The tool uses information gathered by the compiler and linker when the program was compiled and linked, including the stack's size and location in memory. By examining the stack location in the crash memory dump image in conjunction with the debugging data generated by the compiler an the linker and any existing trace data, the last valid frame may be reconstructed indicating the location of the crash.11-22-2012
20080216058Method for validating a graphical workflow translation - A method for validating a translation of a graphical workflow of activities into an arbitrary, but structured language uses as input a term of a high level graphically expressed language having a number of graphical elements related logically to each other and analyzes its content and/or structure in order to translate this content and/or structure into a structured set of instructions. The graphical workflow of activities is simulated to arrive at a first set of activity results. Each instruction is translated into a generic language in order to trace the execution of such instruction to arrive at a second set of results from the translated instructions. The first set of activity results is compared with the second set of results, and the translation is validated in case of a match among the first set of activity results and the second set of results.09-04-2008
20090037885EMULATING EXECUTION OF DIVERGENT PROGRAM EXECUTION PATHS - Methods, systems, and computer storage media having computer-executable instructions embodied thereon that, when executed, perform methods in accordance with embodiments hereof, for emulating execution of divergent program execution paths to determine whether any “would be” program defects exist in a particular divergent program execution path and/or to determine the nature of such “would be” program defects are provided. The dynamic execution state (e.g., register values and memory locations) of a program being executed is cloned at a point of potential divergence and a virtual processor having the same dynamic execution state is generated. Subsequently, utilizing the virtual processor, a test trace is initiated along the divergent program execution path and information gathered during the test trace is analyzed to identify any program defects that may have occurred had the program execution followed the divergent path.02-05-2009
20090007075Method and System for Tracing Profiling Information Using Per Thread Metric Variables with Reused Kernel Threads - A method and system for tracing profiling information using per thread metric variables with reused kernel threads is disclosed. In one embodiment kernel thread level metrics are stored by the operating system kernel. A profiler request metric information for the operating system kernel in response to an event. After the kernel thread level metrics are read by the operating system for a profiler, their values are reset to zero by the operating system kernel. The profiler then applies the metric values to base metric values to appropriate Java threads that are stored in nodes in a tree structure base on the type of event and whether or not the kernel thread has been reused. In another embodiment non-zero values of thread level metrics are entered on a liked list. In response to a request from a profiler, the operating system kernel reads each kernel thread's entry in the linked list and zeros each entry. The profiler can then update the intermediate full tree snapshots of profiling information with the collection of non-zero metric variables.01-01-2009
20100146488AUTOMATIC TEST TOOL FOR WEBPAGE DESIGN WITH MICRO-BROWSERS ON MOBILE PLATFORMS - Architecture that provides a convenient and effective test tool for testing and ensuring that webpages using micro-browsers are sufficiently designed and operational. A task library is developed for manipulating browsers on a handheld device, and includes one or more seamless methods that operate the different browsers in the same way. Seamless virtual functions that manipulate different micro-browsers include, but are not limited to browser launch, exiting a browser, navigating to a home page, clearing a cache, navigating to a webpage, reloading a webpage, getting the current info for a webpage, navigating back to a webpage, checking a page title, and capturing a screen, for example. Device features can also be manipulated to ensure consistency across the testing process.06-10-2010
20080244531Method and system for generating a hierarchical tree representing stack traces - A system and method are provided to generate a hierarchical tree representing stack traces. In one embodiment, stack trace elements in a plurality of stack traces relating to profiling of an application executing at a first virtual machine are identified, the stack trace elements relating to profiling events being detected during the profiling of the application. The identified stack trace elements are sorted as one of parent elements; parent/child elements, or child elements based on a number of times a stack trace element has appeared in the plurality of stack traces and its relationship with other elements in the plurality of stack traces. A tree having nodes to represent the stack trace elements is created such that that the child elements branch from the parent/child elements or the parent elements, and the parent/child elements branch from the parent elements.10-02-2008
20080244532Testing System, and a Method and Computer Program For Testing A System Management Program - A testing system for a reverse client-server system management program comprises a server connected to one or more recipient devices and emulating devices through one or more repeaters. The recipient devices act as targets for the management program and the emulating devices emulate one or more of the recipient devices, to enable an assessment of the scalability of the management program to a large number of targets. The repeaters direct management requests from the server to the target devices depending on the configuration of the hook and/or the nature of the operation requested by the management request. The recipient devices and emulating devices execute the required system management operation on receipt of a management request from the server (via the repeaters). The recipient devices and emulating devices generate and transmit a report detailing the outcome of the system management operation.10-02-2008
20080244530CONTROLLING TRACING WITHIN COMPILED CODE - Tracing within a processing environment is controlled. Trace directives are automatically included within code being compiled in order to control where one or more traces begin and end within the code. The trace directives provide a framework for mapping traces to well understood boundaries of the code.10-02-2008
20080244534SYSTEM AND METHOD FOR TROUBLESHOOTING SOFTWARE CONFIGURATION PROBLEMS USING APPLICATION TRACING - A software system is disclosed which facilitates the process of tracing the execution paths of a program, called a client or application. Trace data corresponding to selected system resources that interact with the execution of the application is collected during the tracing operation and stored in an application signature. A computer system user can generate trace options, trace the application, and compare the application signature to a known software configuration. The application signature is compared to a reference signature created by tracing the execution of the application on a system with the known software configuration. In another embodiment, the application signature is compared to a static configuration of a reference computer.10-02-2008
20090265692ACTIVE PROPERTY CHECKING - An exemplary method includes providing software for testing; during execution of the software, performing a symbolic execution of the software to produce path constraints; injecting issue constraints into the software where each issue constraint comprises a coded formula; solving the constraints using a constraint solver; based at least in part on the solving, generating input for testing the software; and testing the software using the generated input to check for violations of the injected issue constraints. Such a method can actively check properties of the software. Checking can be performed on a path for a given input using a constraint solver where, if the check fails for the given input, the constraint solver can also generate an alternative input for further testing of the software. Various exemplary methods, devices, systems, etc., are disclosed.10-22-2009
20090193397METHOD AND APPARATUS FOR FACILITATING DIAGNOSTIC LOGGING FOR SOFTWARE COMPONENTS - One embodiment of the present invention provides a system that facilitates diagnostic logging for software components. During operation, the system receives program code for a software component that was generated from an object model, where a key attribute has been specified for the object model. During execution of the program code, the system detects when an instance of the key attribute for the object model is accessed, and attaches state associated with the instance to a thread context in the runtime environment. The system then appends this state to a log during a logging operation to facilitate discovering and analyzing program faults.07-30-2009
20120297371Method and System for tracing individual Transactions at the Granularity Level of Method Calls Throughout Distributed Heterogeneous Applications without Source Code Modifications Including the Detection of Outgoing Requests - A monitoring system uses existing tracing data describing individual distributed transactions to determine if a recorded thread communication performed by the monitored transactions is internal to a monitored application or whether the recorded thread communication is an outgoing communication. Thread communications which are sent and received by threads that are monitored by the monitoring system are considered to be internal communications. Thread communications for which only the sending thread is monitored are considered to be outgoing communications. The determination process analyzes client side tracing data of the recorded thread communication and determines whether corresponding server side tracing data is available. If no corresponding server side tracing data is available, the thread communication is considered to be an outgoing communications. Examples of thread communications include HTTP requests, web service calls, and remote method invocations.11-22-2012
20080209404METHOD AND SYSTEM FOR ANALYZING MEMORY LEAKS OCCURRING IN JAVA VIRTUAL MACHINE DATA STORAGE HEAPS - An invention is disclosed for analyzing memory leaks occurring in Java Virtual Machine (JVM) data storage, consisting of a dynamically modifiable JVM “profiler” and an “object tracker” tool for analyzing the output from the profiler. Specifically, a method and system is disclosed for programming a JVM profiler used to analyze and correct memory leaks in stored data heaps, consisting of a program segment (or “stub”) initialized by the JVM application program interface to determine the parameters to be passed to the main profiler memory leak analysis program logic, which is then initialized by the stub to examine a minimal number of “heap dumps” in order to identify data elements or objects for the existence and/or correction of memory leaks. Updated information on data elements or objects can be requested from the profiler as needed by use of the object movement tracking option to record the details of subsequent changes in data memory storage status once a heap dump has been obtained.08-28-2008
20080270994METHOD AND APPARATUS OF PARTITIONED MEMORY DUMP IN A SOFTWARE SYSTEM - A method and apparatus of partitioned memory dump in a software system is provided, the apparatus comprising: a monitor for, during the execution of the software system, monitoring the memory allocations and deallocations of objects in the software system and according to the results of the monitoring, assigning the allocated objects in the software system into corresponding memory partitions, wherein the memory space of the software system is partitioned according to a given partitioning scheme; an event detector for detecting a triggering event of memory dump; and a dumper for dumping related memory partitions according to the detected triggering event of memory dump. Preferably, the apparatus further comprises an analyzer for analyzing the dumped information, and generating a new dump triggering event or a new partitioning scheme based on the analysis results.10-30-2008
20100146489AUTOMATIC COLLECTION OF DIAGNOSTIC TRACES IN AN AUTOMATION FRAMEWORK - A method for software test automation includes receiving system software in a test server; receiving test software and in a test server; configuring test environment resources for the test software; executing an automated test of the test software comprising: performing unit test of the test software; comparing anticipated performance results of the test software with actual results of the test software; determining whether there are differences in the anticipated performance and the actual performance; wherein in the event there are differences in the anticipated performance and the actual performance: applying trace settings; deleting runtime logs associated with the unit test; re-executing the unit test; storing trace data associated with the re-executed unit test; notifying a user of the re-executed unit test; providing the user with the stored trace data; and cleaning up the test environment resources.06-10-2010
20120198423Code Path Tracking - Methods, systems, and products are provided for code path tracking. Embodiments include identifying an instrumented trace point in software code to be path tracked; identifying a function executed at the instrumented trace point in the software code; identifying parameters for the function executed at the instrumented trace point; and recording a description of the function, the parameters, and the result of the execution of the function using the parameters.08-02-2012
20090055805Method and System for Testing Software - A method and system are disclosed for testing the cpu scalability of a software application. The method comprises the steps of running the software application a plurality of times on a computer system such that each time the software application is ran on the computer system, a different number of processors are used to run the software application. The method further comprises the steps of storing the resultant outputs of the computer system, and using those outputs to determine the cpu scalability of the software application. In a preferred embodiment of the invention, a software tool, referred to as (he harness, is loaded onto the computer system to perform the running, storing and using steps. For instance, each time that the software application is run on (he computer system, the software tool may configure a different subset of the processors to run the software application.02-26-2009
20080244533System for and Method of Capturing Performance Characteristics Data From A Computer System and Modeling Target System Performance - A system for, method of and computer program product captures performance-characteristic data from the execution of a program and models system performance based on that data. Performance-characterization data based on easily captured reuse distance metrics is targeted, defined as the total number of memory references between two accesses to the same piece of data. Methods for efficiently capturing this kind of metrics are described. These data can be refined into easily interpreted performance metrics, such as performance data related to caches with LRU replacement and random replacement strategies in combination with fully associative as well as limited associativity cache organizations. Methods for assessing cache utilization as well as parallel execution are covered.10-02-2008
20090089761METHOD, SYSTEM AND COMPUTER PROGRAM FOR DEBUGGING SOFTWARE APPLICATIONS IN A WEB ENVIRONMENT - A method and system are provided for debugging a software application in a data processing system that includes a server entity and client entities. For at least one of the client entities, a server component of the application running on the server entity is accessed, and a client component of the application is downloaded from the server entity. The client component is executed. Client log information relating to the execution of the client component is saved by invoking a log function provided by the client component; the client log information is saved into a non-persistent memory structure of the client component. The client log information is transmitted for use in the debugging of the application.04-02-2009
20120072888INFORMATION PROCESSING APPARATUS, LOGGING METHOD, AND NON-TRANSITORY COMPUTER-READABLE RECORDING MEDIUM ENCODED WITH LOGGING PROGRAM - An information processing apparatus includes an application executing portion which executes an application program, a setting portion which sets whether to keep a log of the application program executed by the application executing portion, and a logging portion which, in the case where it has been set to keep the log by the setting portion, keeps a log of the application program executed, wherein the logging portion includes a determination portion which determines whether the execution of the application program is assured externally, and a forced logging portion which keeps a log of the application program executed, in the case where it is determined that the execution of the application program is not assured externally, even if it has been set not to keep the log by the setting portion.03-22-2012
20090164979SYSTEM LANDSCAPE TRACE - This disclosure provides various implementations for supporting multiple system and application tracing. In one aspect, software can generate a globally unique identifier (GUID) for a first business process associated with a trace and transmit the GUID to a remote computer for association with a second business process related to the first business process. In another aspect, the software can identify a GUID for a trace that is executing for a first business process that is associated with a first application. The software can then associate the GUID with a second trace for a second business process related to the first business process, where the second business process is associated with a second heterogeneous application disparate from the first application. In some instances, the GUID may comprise a combination of a system identifier, a business process identifier, and a time identifier.06-25-2009
20090164980Cluster Application Trace - A system and method for tracing a clustered application are disclosed. A server system hosts the clustered application, and an instance tracer manages a shared memory segment for one or more nodes within an instance of each process of the clustered application. The instance tracer is adapted to serialize trace information for each of the one or more nodes and write the trace information directly to the shared memory segment according to a common time sequence. Preferably, the shared memory segment is arranged as a rollbuffer, and the trace information is written to the rollbuffer as a trace entry in sequential writer entries until a reader entry on the rollbuffer is reached.06-25-2009
20090164978METHOD AND SYSTEM FOR PROVIDING POST-MORTEM SERVICE LEVEL DEBUGGING - A computer program product comprises a computer useable medium. The computer useable medium has a computer readable program such that when the computer readable medium is executed on a computer, the computer is caused to configure an interceptor at a service invocation point corresponding to a component service of a software application. Further, the computer is caused to record, at the interceptor, data in a trace file. The data is associated with a service invocation at the service invocation point. Finally, the computer is caused to provide the trace file to a service level debugger that navigates through the trace file.06-25-2009
20090144706IDENTIFYING POTENTIAL LOCK CONDITIONS IN TRANSACTIONAL SOFTWARE APPLICATIONS - Methods, systems, and products for testing a transactional software application which interacts with a database structure. The software application includes a plurality of application units, which are adapted to be executed at least in part concurrently. The method includes executing the software application. Executing the software application includes executing a plurality of transaction operations on the database structure by a plurality of respective invocations of a database management system of the database structure by the respective plurality of application units. The method also includes determining locks being applied by the database management system on elements of the database structure for each transaction operation executed by each application unit individually. The method also includes identifying potential lock conditions of the software application in possible successions of application of the locks according to possible interleaving of the application units.06-04-2009
20080256519Tracking method for embedded system - A tracking method for embedded systems is disclosed. A stacking way is used for viewing and tracing. In the beginning, a program counter (PC) and a stack segment of a function are found out. Then an instruction of the function is learned according to the stack segment and further stack size of the function is calculated. In accordance with the stack size, a stack frame is viewed to find out a recursive program counter of a previous function. Next according to the recursive program counter, an entry point of the previous function is calculated. Therefore, the system knows the memory block is required by which function and further finds out what causes computer shut-down or program errors. Moreover, stack status before the error occurred in the stack frame is got so as to get a returning path that enables the processor going back to status before the error occurred.10-16-2008
20090013312Executable High-Level Trace File Generation System and Method - An executable high-level trace file generation system and method provide reduced debugging effort and time, particularly on initial startup of new or modified hardware. An executable program invokes high-level application programming interfaces (APIs), to perform various tasks. Instructions within the APIs generate a trace file documenting the invoked sequence of APIs by writing a line to a trace file that documents the API and input parameters received by the API. Upon completion of execution of the API, the return value may be documented as a comment line in the trace file. The resulting trace file is then re-executable as a script and may be edited to alter the sequence of APIs invoked and/or the arguments provided. The script interpreter may be a command line interface through which the APIs are invoked, and trace files may be similarly generated that document sequences of manually entered commands.01-08-2009
20090204951Sliding Granularity Time Stamping - In a method for tracing data within an integrated circuit, a default time stamp granularity is selected for a sequence of time stamps, wherein each time stamp has a resolution of 2**N. A sequence of trace events is captured and an elapsed time is determined between each time sequential pair of trace events in the sequence of trace events. A time stamp is formed to associate with each trace event of the sequence of trace events, wherein each time stamp has an associated time stamp granularity, wherein the time stamp has the default time stamp granularity if the elapsed time between a current trace event and a sequentially prior trace event is less than 2**N time slots, otherwise the time stamp granularity is slid to a larger value such that the elapsed time can be represented by N bits, whereby a small number N of bits can accurately represent a large range of elapsed times.08-13-2009
20090199163DEBUGGER ASSISTANCE FOR LOCATING VALUES AT RUNTIME - A software module for searching within a software debugging environment is provided. The software module comprises a search component and an interface component. The search component is configured to be implemented within a debugging tool configured to access a set of execution state data for a program being monitored by the debugging tool when execution of the program is stopped. The search component is configured to search the set of execution state data to locate instances of a particular value. The interface component is configured to allow a user to specify the particular value in a search query, submit the search query to the search component, and present a description of each instance of the particular value located by the search component to the user.08-06-2009
20090083715METHOD AND SYSTEM FOR INSTRUCTION TRACING WITH ENHANCED INTERRUPT AVOIDANCE - A method, system, apparatus, and computer program product is presented for tracing operations. A set of related methodologies can be used within instruction tracing software, such as a tracing program, to reduce its tendency to generate interrupts that cause unwanted effects in the system that is being captured. A first methodology allows access to protected memory blocks so that instructions may be read from those memory blocks. A second methodology provides for the trace output buffer to be accessed using physical addressing. A third methodology traces only instruction addresses, which are resolved later during a post-processing phase of operation. A fourth methodology comprises multiple different methods for obtaining copies of instructions that have already executed rather than obtaining them before they are executed.03-26-2009
20090070744CRM SYSTEM AND METHOD HAVING DRILLDOWNS, ACLs, SHARED FOLDERS, A TRACKER AND A MODULE BUILDER - A business application system, such as a CRM system, is provided wherein the system include deeper chart drill-downs, access control lists, shared folders, a tracker module and/or a modular builder.03-12-2009
20090083714REMOTE MONITORING OF LOCAL BEHAVIOR OF NETWORK APPLICATIONS - Computer-executable instructions comprising some or all of a program can be delivered to a client for execution on a real-time basis such that the client receives anew the computer-executable instructions for each new execution of the program. Such an environment enables instrumentation instructions to be inserted into the computer-executable instructions after a request and prior to the delivery of the computer-executable instructions. The inserted instrumentation instructions can be spread across multiple deliveries of the same computer-executable instructions, and they can be modified to account for information received from previously inserted instrumentation instructions. The instrumentation instructions can be inserted as part of the server process, the client process, or as part of a proxy server that can be used at the discretion of the program developer.03-26-2009
20110231826Detecting Real-Time Invalid Memory References - A method, system, and computer program product for identifying invalid memory references. In one embodiment, invalid memory references are identified as they occur. In another embodiment, the invalid memory references are identified within a customized operating system that runs within an application.09-22-2011
20090204950METHOD, SYSTEM AND COMPUTER PROGRAM PRODUCT FOR TEMPLATE-BASED VERTICAL MICROCODE INSTRUCTION TRACE GENERATION - Method, system and computer program product for template-based vertical microcode instruction trace generation. An exemplary embodiment includes an instruction trace generation method, including generating a testcase for a millicoded instruction in an instruction trace pool, wherein the millicoded instruction is included in a parent instruction trace, processing the testcase to generate a millicode instruction trace snippet, editing the millicode instruction trace snippet to generate a templatized millimode snippet, processing the parent instruction trace, accessing the templatized millimode snippet, updating the templatized millimode snippet with a value from the parent instruction trace, and generating a millicoded instruction trace from the updated templatized millimode snippet.08-13-2009
20090204949SYSTEM, METHOD AND PROGRAM PRODUCT FOR DYNAMICALLY ADJUSTING TRACE BUFFER CAPACITY BASED ON EXECUTION HISTORY - A method, system and program product for dynamically adjusting trace buffer capacity based on execution history. The method includes receiving, by a module configured to trace, a plurality of traces pertaining to one or more trace events generated during execution of a program being traced, the trace events generated including panel data and sequence data. The method further includes determining, using trace data captured from the plurality of traces received, whether or not a path for a trace event is a new path. If the path for the trace event is determined to be a new path, the method includes dynamically adjusting, by the module, an initial size of a trace buffer configured to store the trace data captured, such that, the module increases the initial size of the trace buffer upon making a determination that the trace event is a new trace event based on execution history.08-13-2009
20080288925METHOD FOR GENERATING TEST CASES FOR SOFTWARE PROGRAM - The method for generating test cases for a software program includes the step of setting a plurality of reference points in accordance with a sentence of the software program. The tracing pairs each including an initial test case as well as its adjacent vertex are set if one of them is among the reference points and the other one is not among the reference points. The essential test cases are chosen from the tracing pairs.11-20-2008
20120144374Capturing Replayable Information at Software Defect Locations in a Multi-Tenant Environment - 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.06-07-2012
20090249304Code Instrumentation Method and Code Instrumentation Apparatus - A code instrumentation method and a code instrumentation apparatus for instrumenting object codes of programs to enable memory access tracing. The code instrumentation method includes: identifying an object code block to be executed circularly in object codes; identifying at least one memory access instruction in the object code block where a memory address to be accessed during the circular execution of the object code block keeps unchanged; and inserting a routine for tracing the memory access to be executed by the at least one memory access instruction outside the object code block.10-01-2009
20090222796Viral trace - Tracing of the interaction of third party processes on resources used by a program under trace is performed. A viral tag is associated with the program under trace. When the program “touches” a portion of memory, the memory manager associates the viral tag with the memory locations in this portion of memory. When subsequent processes “touch” the tagged memory locations, they acquire the viral tag and then spread it to other memory locations that these subsequent processes touch. The viral tag may be slightly modified so as to identify it as being based on the original viral tag but having been acquired by another process. Each time the viral tag is spread to another program, the viral tag may be slightly modified to indicate that the viral tag is now associated with another entity although is still associated with the original viral tag.09-03-2009
20090249302Method and Apparatus to Trace and Correlate Data Trace and Instruction Trace for Out-of-Order Processors - In a data processing system, a marked bit is used to identify a data access instruction throughout the pipeline to indicate that the instruction meets user-specified criteria (e.g., a meets a data address range of interest). Based on the marked bit, an in-order program correlation message is generated which indicates when the data access instruction occurs relative to the instruction stream. The marked bit is also used to generate an in-order data trace message. As a result, the trace streams including only data access instructions meeting user-specified criteria may be post-processed and correlated precisely.10-01-2009
20130219370PROFILING AND SEQUENCING OPERATORS EXECUTABLE IN AN EMULATED COMPUTING SYSTEM - Methods and systems are disclosed for analyzing performance of a translated code stream executing within a central processing module. One method includes, during execution of one or more native instructions corresponding to each non-native operator in the code stream by the code execution unit, counting the occurrence of the non-native operator, determining a duration of execution of the one or more native instructions, and adding the non-native operator to a trace sequence. The method also includes, after execution of the code stream within the central processing module, generating a data file of non-native operators executed within the code stream, the data file of operators including a name of each non-native operator, an elapsed amount of time within the code execution unit that the one or more native operators corresponding to the non-native operator are executed, and a number of occurrences of the non-native operator within the code stream.08-22-2013
20090241095Call Stack Sampling for Threads Having Latencies Exceeding a Threshold - 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.09-24-2009
20090241096Dynamic Software Tracing - A method, computer program product and system for dynamically changing a trace level, and optionally the trace size, depending on a recognized critical path. In one embodiment of the invention, a method of dynamic software tracing includes identifying one or more critical patterns of a software code which can influence its execution; allocating a software logging metric to each identified critical pattern; searching for one or more critical patterns in the software code to determine one or more actual critical patterns; and attributing the software logging metric associated with each identified critical pattern to the actual critical pattern to discover areas in the software code that may impact performance.09-24-2009
20080307395Providing Registration of a Communication - A computer-implemented method for providing registration of a communication includes locating a reference in metadata for an object-processing framework. The reference identifies a portion of logic that performs a specific service. The method includes storing at least part of the located reference in a trace object. The method includes replacing the located reference in the metadata with a reference to the trace object.12-11-2008
20100153927TRANSFORMING USER SCRIPT CODE FOR DEBUGGING - User script code that is developed to be run in a host application, for example, as a macro can be transformed into debuggable code so that the host application may continue to operate during a debugging stop operation. Traceback methods can be created that call back into the host application to allow the host application to cooperatively operate and update its user-interface. The user script code can be transformed by injecting callbacks to the traceback methods at respective locations in the code where a stopping operation may be installed during debugging. Further, two or more debugging features can be combined into a single user script code transform using an iterator pattern function.06-17-2010
20090094583SYSTEM AND METHOD FOR TESTING COMPUTER PROGRAMS - A method for testing computer programs includes the steps of identifying at least one code subsection of a computer program to be tested, ascertaining one or more other code subsections required for executing the identified subsection, determining one or more input arguments required for executing the identified subsection and the other subsections, prompting a developer to provide at least one of the input arguments, and executing the identified subsection using the provided input arguments.04-09-2009
20090282391CONVERTING FORMAT STRINGS TO REGULAR EXPRESSIONS - In one embodiment, a method for correlating log entries in a log file to the line numbers of formatted-string output functions in source code, where the formatted-string output functions contain instructions to generate the log entries in the log file. The method includes locating the formatted-string output functions in the source code, where each formatted-string output function contains a format string. Each format string is processed to generate a corresponding regular expression to match log entries outputted by the corresponding formatted-string output function. Each regular expression is associated with the line number of the corresponding formatted-string output function. The resultant list of regular expressions and corresponding line numbers is processed with the log file, where log entries in the log file are modified to indicate the line numbers associated with matching regular expressions.11-12-2009
20100192133METHOD AND SYSTEM FOR ANALYZING MEMORY LEAKS OCCURRING IN JAVA VIRTUAL MACHINE DATA STORAGE HEAPS - A plurality of heap dump requests associated with an operating virtual machine (VM) program is received from a VM profiler interface module at a heap dump request processing module. In response to receipt of each heap dump request at the heap dump request processing module, a dynamic modifiable library identified within a dynamic modifiable configuration file is loaded into a memory, where the dynamic modifiable library comprises instructions associated with processing a current heap dump request. The instructions associated with processing the current heap dump request are executed. The dynamic modifiable library is unloaded from the memory. A plurality of heap dump files and a plurality of object movement event files generated by execution of the instructions are analyzed. A memory leak associated with the operating VM program is automatically identified based upon the analyzed plurality of heap dump files and the plurality of object movement event files.07-29-2010
20100262954Method for Locating Resource Leaks during Software Development - Disclosed is a method and a system for identifying a resource allocation in computer program code. The method comprises the steps of identifying computer program code that initiates a resource allocation process, generating a certificate for the identified computer program code and storing the certificate as a parameter in the computer program code initiating the resource allocation process, and in a table which further comprises adhering file and line data of the computer program code that initiates the resource allocation process, and performing a resource allocation call including the certificate.10-14-2010
20100192132SYSTEM AND METHOD FOR CUSTOMIZED ERROR REPORTING - An error reporting system within the operating system of a computer that provides error reporting and/or debugging for managed applications. The error reporting service supports a registration programming interface through which applications that use non-native or non-standard error reporting functions can register runtime exception modules. A similar interface may be provided for applications to register debuggers. In response to a failure, such as a crash or an application hang, the error reporting service can poll the registered components to ascertain whether any is adapted for use in conjunction with such a failure. If so, the appropriate registered components can be used to collect failure data and/or debug the failed application. In this way, the error reporting service, and an existing framework that supports aggregation of application error reports, can be customized, including to allow error reporting and debugging of non-native applications.07-29-2010
20100229158COMPUTER-READABLE RECORDING MEDIUM STORING VERIFICATION SUPPORT PROGRAM, INFORMATION PROCESSOR, AND VERIFICATION SUPPORT METHOD - An information processing and method include acquiring a trace group indicating instants of time of execution of processing operations and vestiges of contents of the execution, behavior information indicating behaviors of a processor of the arbitrary system, and state information indicating state transitions of an arbitrary hardware device other than the processor. A behavior trace searching unit searches when an arbitrary behavior is specified from behaviors indicated by the behavior information, a state trace searching unit searches when an arbitrary state transition is specified from the state transition indicated by the state information, an associating unit associates, the traces found by the behavior trace searching unit and the traces found by the state trace searching unit according to an instruction and an outputting unit outputs the traces associated by the associating unit as traces for a simulation of the behaviors.09-09-2010
20090044176Method and Computer Program Product for Dynamically and Precisely Discovering Deliquent Memory Operations - A method and computer product for dynamically and precisely discovering delinquent memory operations through integration of compilers, performance monitoring tools, and analysis tools are provided. The method includes compiling an application, and linking the application with a tracing library to generate executable, compiler annotated information and linker mapping information. The application is executed to obtain runtime trace information that includes hardware performance counters and tracing library instrumentation events. The trace information, the compiler annotated information, and the linker mapping information are analyzed to produce a delinquent memory operation file containing delinquent memory operation information. The delinquent memory operation information of the delinquent memory operation file is read by the compiler to perform memory reference mapping to guide static analysis and memory hierarchy optimization. The memory reference mapping maps delinquent memory operations precisely, both externally in a user source code and internally in a compiler intermediate representation.02-12-2009
20100242026ENHANCED THREAD STEPPING - Embodiments of the invention provide debugging techniques for multithreaded programs. For example, a debugger may reduce the time required to release inactive threads that hold resources needed by an active thread. For example, if a timer expires before a line of code finishes executing, the debugger assumes that the active thread requires a resource locked by an inactive thread and releases other threads. During subsequent execution of the line of code, the debugger reduces the timer length of the timer. In doing so, inactive threads are released sooner, thereby reducing the wait time a user experiences when debugging lines of code.09-23-2010
20120036501Method and System for Capturing System and User Events Using Hardware Trace Devices - A method including creating a storage buffer in a portion of memory of a computing device; inserting an instrumentation point in software of a further computing device, the instrumentation point corresponding to an event monitored by a hardware trace device, data corresponding to the event being stored in the storage buffer; executing the software; and processing the data, wherein the data is processed after a completion of the execution of the code.02-09-2012
20130219371TIME-BASED TRACE FACILITY - Method, system, and computer program product embodiments of a time-based trace facility for facilitating software debugging without interfering with the run-time behavior, performance or resource usage of the traced software are provided. The trace facility resides in a different address space than the target address space and uses different time-slices of CPU resources to execute the instructions in the address spaces. The trace facility uses a cross-memory mode to read the state data from the target address space in accordance with a time schedule. The trace facility writes the state data to a trace area, which may be located in either the target or trace address spaces or external storage. With this approach, the trace facility can read a large amount of state data frequently to construct the type of historical record needed to analysis run-time behavior, performance and resource usage.08-22-2013
20090328006INSTRUCTION-TRACE GENERATION PROGRAM, INSTRUCTION-TRACE GENERATING DEVICE, AND INSTRUCTION-TRACE GENERATING METHOD - An instruction-trace generating device generates an instruction trace of a first instruction string from a second instruction string obtained by sampling, at predetermined intervals, the first instruction string executed a plurality of times. The device includes a dividing unit dividing the second instruction string into partial instruction strings and causes the divided partial instruction strings to be stored in a storage unit; a similarity calculating unit calculating a similarity for each combination of all of the stored partial instruction strings; a selecting unit selecting one of the combinations of the partial instruction strings based on the similarity; a combination-pattern generating unit generating a plurality of combination patterns by combining instructions included in the selected partial instruction strings; a likelihood calculating unit calculating a likelihood for each of the combination patterns; and a partial-instruction-string replacing unit causing the combination patterns to be stored in the storage unit based on the likelihood.12-31-2009
20110067007AUTOMATIC THREAD DUMPING - A server node comprises a monitoring module to support automatic thread dumping. The monitoring module monitors execution of a multi-threaded Java program on a Java virtual machine. The monitoring module detects a pre-defined condition that occurs to one or more of the threads during the execution. Upon detection of the pre-defined condition, the monitoring module automatically invokes a thread dumping module to dump the threads that are currently running on the Java virtual machine.03-17-2011
20090019428Method for Analyzing Transaction Traces to Enable Process Testing - Techniques are provided for analyzing testing coverage of one or more software modules to provide process coverage statistics. The techniques include obtaining one or more coverage measures from a test specification document, performing a trace on each of the one or more coverage measures during a test, analyzing each trace to generate a run-time service choreography model for a process, wherein the model includes each of one or more service choreography patterns occurring in the process, and using the model to provide statistical data on test coverage according to a process definition.01-15-2009
20090320000METHOD AND SYSTEM FOR POWER MANAGEMENT USING TRACING DATA - A method for power managing hardware. The method includes determining hardware to power manage, sending a tracing request from a power management control to a tracing framework to obtain usage data of the hardware, and identifying a first probe to obtain first tracing data corresponding to the usage data in a first hardware control software component, where the first hardware control software is configured to interact with the hardware. The method further includes enabling the first probe, obtaining the first tracing data from the first probe, where the first tracing data is obtained when the first probe is encountered during execution of the first hardware control software, and modifying operation of the hardware using the first tracing data.12-24-2009
20090319999SIMULATING STEPPING THROUGH INTERPRETED CODE - The present invention extends to methods, systems, and computer program products for simulating stepping through interpreted code. Embodiments of the present invention facilitate debugging interpreted code. Thus, existing debugger technologies (e.g., those configured for use with compiled code) can be utilized to debug interpreted code. More specifically, existing debugger technologies can be used to step through interpreted code, without stepping into the code of interpreter itself Accordingly, users developing interpreted code can be provided a stepping experience of relatively the same quality provided to developers developing compiled code, without having to reengineer debuggers to compensate for interpreted code.12-24-2009
20100223598Collecting profile-specified performance data on a multithreaded data processing system - A method, apparatus, and computer program product for collecting performance data. In one illustrative embodiment, signaling is performed to start collecting the performance data by an operating system support unit in a multithreaded data processing system. Responsive to a thread switch to an incoming thread after signaling has occurred, the performance data for the incoming thread is collected using a thread specific data collection profile to form collected performance data if the incoming thread is associated with the thread specific data collection profile, wherein the thread specific data collection profile specifies a type of data to collect. Responsive to a subsequent thread switch, the collected performance data is sent to a number of destinations.09-02-2010
20090113398MANAGING THE TRACING OF THE EXECUTION OF A COMPUTER PROGRAM - A method and system for the management of tracing data of interest in a data processing system comprises identifying the location and length of one or more such units of interest as each unit is stored in main memory during execution of the program and recording a logical assignment of each unit of interest to a slot in a wrap around trace buffer. Copying of the units of interest to the trace buffer is deferred unless one or more predefined events occur. Such events may include an attempt to overwrite the data which has been logically assigned or a request for information stored in the trace buffer. The recorded assignments are discarded whenever it is calculated that the capacity of the trace buffer would be exceeded resulting in the corresponding units never needing to be copied to the trace buffer.04-30-2009
20090037887Compiler-inserted predicated tracing - One embodiment relates to a computer-implemented method of generating an executable program which includes inserting predicated calls to trace routines during compilation of the source code. Each predicated call comprises a function call that is conditional upon a value stored in a predicate register. The object code generated from compiling said source code is subsequently linked with object code which includes the trace routines. Another embodiment relates to a computer-implemented method of executing a deployed computer program with low-level tracing using compiler-inserted predicated tracing calls. A tracing mode is enabled by setting one or more predicate register bits in a microprocessor. Predicated calls to trace routines insert trace data into at least one trace buffer. Upon a system crash, a core file including said trace data is written out. Other embodiments, aspects and features are also disclosed.02-05-2009
20090037886APPARATUS AND METHOD FOR EVALUATING A FREE-RUNNING TRACE STREAM - A system includes a processor to generate a free-running trace stream and a probe with a real-time decoder to dynamically detect a trigger included in the free-running trace stream.02-05-2009
20090070745SYSTEM AND CORRESPONDING METHOD FOR TESTING SOFTWARE EMBEDDED IN AN ELECTRONIC DEVICE - A system includes an electronic device and an external tester to be temporarily coupled thereto. The electronic device includes an integrated circuit processor. The integrated circuit processor includes processor circuitry for executing dedicated code to perform a dedicated application, and an execution unit coupled to the processor circuitry. The external tester is to be temporarily coupled to the execution unit to collect execution characteristics while the processor circuitry executes the dedicated code to thereby test the dedicated code.03-12-2009
20100281468METHOD AND SYSTEM FOR MONITORING EXECUTION PERFORMANCE OF SOFTWARE PROGRAM PRODUCT - A method, computer program product and system for monitoring execution behavior of a program product in a data processing system include development of a trace tool having trace strings written in a human language and provided with data fields for diagnostic information relevant to executable portions of the program product. Identifiers of the trace tool, trace strings, and data fields and components of the diagnostic information are encoded using a coded binary language. After monitoring execution of the program product, a trace report of the trace tool is translated for an intended recipient from the coded binary language into the human language, whereas an unauthorized access to the contents of the trace record is restricted. The encoding or decoding operations are performed using databases containing the respective identifiers and components of the diagnostic information in the coded binary language and the human language.11-04-2010
20130139128METHOD FOR REMOTE DEBUGGING USING A REPLICATED OPERATING ENVIRONMENT - A debugging system receives traceback data representing logging of a system error of a target system. An operating environment of the target system is replicated by creating a virtual machine (VM) having characteristics represented by the state data representing an operating state of the target system. An analysis is performed on the traceback data within the VM to simulate the system error.05-30-2013
20130139129TEST METHOD FOR HANDHELD ELECTRONIC DEVICE APPLICATION - A test method for a handheld electronic device application is introduced. The test method is for testing a handheld electronic device installed thereon with an open operating platform and equipped with a touchscreen by executing a test program installed on the open operating platform to perform a test procedure. The test program identifies selected coordinates displayed on the touchscreen and corresponding to an application, instructs the open operating platform to execute the application based on the selected coordinates, records execution results, and exits an operating interface for the application to execute the application again. The test method cuts labor-related costs, maintains testing stability of the application, and yields reliable test results.05-30-2013
20130145350EFFICIENT, LARGE SCALE TRACE STORAGE SYSTEM - A diagnostic system includes one or more processors for executing machine-executable instructions and one or more machine-readable storage media for storing the machine-executable instructions. The instructions include a plurality of traces. Each trace is a trace of events executing on a computing system. The system also includes processing logic configured to partition data in the trace into a first trace independent component which includes trace-independent information and a second trace dependent component which includes trace instance information. The system further includes a memory for storing the first trace independent component in a first data structure and the second trace dependent component in a second data structure.06-06-2013
20110023019Monitoring File Access of Java Processes - A mechanism for monitoring file accesses by a process running in a Virtual Machine. File access information associated with a monitored process selected in a first view in a debugging interface is obtained from a file activity log and displayed as selectable file access events in a second view of the debugging interface, wherein each file access event represents a read or write operation performed on a file at a particular point in time by the monitoring process. An initial content of a file associated with the selected file access event and revisions made to the file by the monitored process within a defined period of time is retrieved from the file activity log upon detecting user selection of a file access event in the second view. The revisions are applied to the initial content of the file and displayed in a third view in the debugging interface.01-27-2011
20100333070Multiple ECU Software-In-The-Loop Simulation Environment - The invention relates to methods for evaluating the performance of a system having a plurality of electronic control unit (ECU) software programs. A plurality of first memory spaces are allocated for use by the software programs. At least one second memory space is allocated to be in communication with these first memory spaces. The output of at least one first software program is stored in at least one of said first memory spaces associated with that program, wherein said output is subsequently transmitted to at least one said second memory space, and wherein said output is further subsequently transmitted to at least one of said first memory spaces associated with at least one second software program. From this location, said output is accessed as an input for said second software program. The performance of the system is evaluated by executing said software programs and determining if the outputs of said programs satisfy the criteria of the system.12-30-2010
20100162216WORKLOAD PERFORMANCE PROJECTION VIA SURROGATE PROGRAM ANALYSIS FOR FUTURE INFORMATION HANDLING SYSTEMS - A performance projection system includes a test IHS and multiple currently existing IHSs. The performance projection system includes user application software and surrogate programs that execute on currently existing IHSs. The performance projection system measures user application software and surrogate program performance during execution on currently existing IHSs. The performance projection systems measures runtime program performance during execution of surrogate programs on a future semiconductor die IC design model or virtualized future system. Designers normalize and compare surrogate program runtime performance data with user application software performance data. Designers un-normalize the normalized runtime performance data to generate a projection of runtime performance on the future system.06-24-2010
20100180261SYSTEM AND METHOD FOR GENERATING A USER CALLSTACK TRACE - A system and method for constructing a user callstack trace in a computer to monitor a user defined Function of a user program in relation to one or more predetermined events is provided. The system and method provides generating a user callstack trace for display to the user from data in memory in relation to a predetermined event of interest to the user. The user callstack trace communicates information corresponding to the execution of the Function for the predetermined event independent of the plurality of outlined functions. The plurality of outlined functions are artificially generated in response to compiling the user program having the Function.07-15-2010
20110035730Tracking Database Deadlock - A method for tracking a deadlock in a computing system is disclosed. The deadlock is caused by at least one application, and the computing system is communicatively coupled to a computing device in a distributed manner wherein the computing device has the at least one application. The method includes identifying a source code line in the at least one application, wherein the at least one application includes a plurality of source code lines. The method includes generating a deadlock identifier by the computing system and transmitting a first response by the computing system to the application. The first response includes the deadlock identifier. The method further includes extracting the deadlock identifier from the first response, capturing the source code line, and transmitting a second response to the computer system by the application. The second response includes the source code line and the deadlock identifier. A system and a computer product are also disclosed.02-10-2011
20110113406SYMMETRIC MULTI-PROCESSOR LOCK TRACING - A symmetric multi-processor SMP system includes an SMP processor and operating system OS software that performs automatic SMP lock tracing analysis on an executing application program. System administrators, users or other entities initiate an automatic SMP lock tracing analysis. A particular thread of the executing application program requests and obtains a lock for a memory address pointer. A subsequent thread requests the same memory address pointer lock prior to the particular thread release of that lock. The subsequent thread begins to spin waiting for the release of that address pointer lock. When the subsequent thread reaches a predetermined maximum amount of wait time, MAXSPIN, a lock testing tool in the kernel of the OS detects the MAXSPIN condition. The OS performs a test to determine if the subsequent thread and address pointer lock meet the list of criteria set during initiation of the automatic lock trace method. The OS initiates an SMP lock trace capture automatically if all criteria or the arguments of the lock trace method are met. System administrators, software programmers, users or other entities interpret the results of the SMP lock tracing method that the OS stores in a trace table to determine performance improvements for the executing application program.05-12-2011
20110055818SOURCE CODE ANALYZING SYSTEM AND SOURCE CODE ANALYZING METHOD - Every time an assignment statement is executed during performing a simulation according to a second variable memory system, it is determined whether a value interpreted to have the same meaning is assigned to the assignment statement in the simulation according to a first variable memory system and in the simulation according to the second variable memory system. When the value interpreted to have the same meaning is not assigned, the value assigned according to the second variable memory system is overwritten by an expected value, and a report indicating that the assignment statement is a part dependent on a variable memory system is output.03-03-2011
20110119656Computing system, method and computer-readable medium processing debug information in computing system - Disclosed are a system, method and computer-readable medium related to processing debug information from an embedded system. Source code of an application program to be used in an embedded system may be compiled by a computing system. The application program may include a debug code line. A minimum amount of debug information is stored in an embedded system, reducing memory overhead and waste of clock cycles of a processor.05-19-2011
20110214109GENERATING STACK TRACES OF CALL STACKS THAT LACK FRAME POINTERS - A processing device executing an application analyzer analyzes a call stack having a plurality of stack frames to identify potential return addresses for the plurality of stack frames. The processing device records a value of each of the potential return addresses and records a location on the call stack for each of the potential return addresses. The processing device then determines which of the potential return addresses are actual return addresses based on debugging information and the recorded locations of the potential return addresses. The processing device generates a stack trace based on the actual return addresses.09-01-2011
20110214108ARCHITECTURE, SYSTEM AND METHOD FOR GENERATING VISUALIZATIONS FROM RUNNING EXECUTABLE CODE - A method and apparatus for generating visualizations from running executable code is described. In one embodiment, the method includes monitoring an executable software application while the software application is running. The method may also include capturing data indicative of runtime events that occur while the executable software application is run. In one embodiment, the method may further include generating a profile of the executable software application from the captured data, and rendering a visualization of the profile for display.09-01-2011
20090328007MEMORY LEAK DIAGNOSIS - A method and an apparatus for diagnosing memory leak. The method includes: tracing the allocation of objects; recording allocation paths and allocation time of each object; giving to each object one unique identifier (ID) corresponding to an allocation path; determining the allocation path to which each object belongs; organizing the objects which are allocated but still not collected, and counting the age generations of the objects of the similar type according to the allocation time of each object; ranking the allocation paths according to the age generations of the surviving objects; and analyzing the ranking of the allocation paths, in which the allocation path with higher rank is more probable to introduce memory leaks. Thus, the suspicious allocation path possibly incurring memory leaks is selected and reported to the user for analysis.12-31-2009
20110088017OFFLINE FORMAL VERIFICATION OF EXECUTABLE MODELS - A system and method for automatic formal verification of an executable system includes an assertion monitor configured to verify a system against an assertion in the specification. The assertion monitor includes a parser configured to generate a propositional formula representing an assertion in the specification using Boolean propositions, a filter configured to generate a trace of truth assignments for the propositional symbols and a trace verifier configured to verify the assertion using the trace of truth assignments for the propositional symbols and the propositional formula.04-14-2011
20090228873DISPLAY BREAKPOINTING BASED ON USER INTERFACE EVENTS - Techniques for monitoring breakpoints. An application having a breakpoint to be executed on a target device is received. The application is executed on the target device. A screen image corresponding to a display on the target device is captured in response to reaching the breakpoint while executing the application. The screen image is stored in a memory of the target device.09-10-2009
20100058298APPROXIMATE FUNCTIONAL MATCHING IN ELECTRONIC SYSTEMS - Methods and apparatuses for approximate functional matching are described including identifying functionally similar subsets of an integrated circuit design or software program, distinguishing control inputs of the subsets from data inputs, and assigning combinations of logic values to the input control signals to capture co-factors for functional matching.03-04-2010
20100058297SEAMLESS DEBUGGING AMONG DIFFERENT APPLICATION VIEWS - 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.03-04-2010
20110252407SYSTEM AND METHOD FOR INFORMATION EXTRACTION FROM WITHIN AN ACTIVE APPLICATION DURING EXECUTION - A system and method for providing detailed information about how a software application is running has a processor and memory including a shared memory. The method provides an automated way of extracting information from a first software application having a plurality of libraries as the application executes. A special library used to interrogate an execution application is placed in the execution path but does not use I/O resources while it is extracting information about an executing software application. An intercept causes the special library to execute, and information is seamless provided to an output device during execution of the interrogated application.10-13-2011
20100251220METHOD AND APPARATUS FOR DYNAMICALLY INSTRUMENTING A PROGRAM - A dynamic instrumentation method and apparatus which may trace, debug, and profile the execution of a running program without affecting the operation of the program, are provided. According to the method, a break instruction is inserted and executed at start of execution of a first instruction and immediately after execution of the last instruction of a function constituting the program. Environment values of the function before and after execution may be identified. The program may be dynamically instrumented without being affected by any tracing or debugging operations.09-30-2010
20100251219TRACING OBJECTS IN OBJECT-ORIENTED PROGRAMMING MODEL - A system and associated method for tracing state information of a target object. The target object is a data item of an application object executed in a virtual machine. Upon detecting a triggering event pertaining to the target object while executing the application object, the virtual machine stores the state information of the target object in a target state info object in a heap space such that the state information is maintained across instances of the virtual machine. The target object is associated with the target state info object by using a weak hash map entry such that the target state info object is garbage collected when the target object is garbage collected and such that the state information is not excessively accumulated. A system dump containing the target object and the target state info object is produced when the application object fails.09-30-2010
20110088016PROGRAM ANALYSIS THROUGH PREDICATE ABSTRACTION AND REFINEMENT - An analysis engine is described for performing static analysis using CEGAR loop functionality, using a combination of forward and backward validation-phase trace analyses. The analysis engine includes a number of features. For example: (1) the analysis engine can operate on blocks of program statements of different adjustable sizes; (2) the analysis engine can identify a subtrace of the trace and perform analysis on that subtrace (rather than the full trace); (3) the analysis engine can form a pyramid of state conditions and extract predicates based on the pyramid and/or from auxiliary source(s); (4) the analysis engine can generate predicates using an increasingly-aggressive series of available discovery techniques; (5) the analysis engine can selectively concretize procedure calls associated with the trace on an as-needed basis and perform other refinements; and (6) the analysis engine can add additional verification targets in the course of its analysis, etc.04-14-2011
20100242027IDENTIFYING GROUPS AND SUBGROUPS - Aspects of the subject matter described herein relate to automatically identifying groups and subgroups in dependency data. In aspects, a data structure that indicates dependencies between components is analyzed to create groups that are related by dependencies. The groups are further analyzed to create subgroups that depend on shared components but that do not depend on each other. Information about the components is used to generate names for the groups that are indicative of the components included in the groups. The groups, their names, and their relationships may then be displayed.09-23-2010
20110072418TRACING MEMORY UPDATE FOR DEBUGGING COMPUTER PROGRAM - A system, method, and computer program product for expediting the identification of computer program code that is the source of errors in the execution of a computer program. A debugger monitors a specified memory address, or group of addresses for updates, during execution of the computer program. In response to determining that a running computer program has updated the memory address, the processor executes a watchpoint handler to identify the source of errors in a computer program executing in a data processing system. The watchpoint handler gathers trace information associated with the faulty processing thread, and records the trace information to a memory location. The watchpoint handler may also apply filters to the trace information to identify the source of the error, saving valuable debugging time.03-24-2011
20110258610OPTIMIZING PERFORMANCE OF INTEGRITY MONITORING - A system, method and computer program product for verifying integrity of a running application program on a computing device. The method comprises: determining entry points into an application programs processing space that impact proper execution impact program integrity; mapping data elements reachable from the determined entry points into a memory space of a host system where the application to verify is running; run-time monitoring, in the memory space, potential modification of the data elements in a manner potentially breaching program integrity; and initiating a response to the potential modification. The run-time monitoring detects when a data transaction, e.g., a write event, reaches a malicious agent's entry point, a corresponding memory hook is triggered and control is passed to a security agent running outside the monitored system. This agent requests the values of the data elements, and determines if invariants that have been previously computed hold true or not under the set of retrieved data values.10-20-2011
20100088682PROGRAM EVALUATION APPARATUS AND PROGRAM EVALUATION METHOD - An apparatus for evaluating a performance of a program includes: a storage unit for storing the program embedded with a plurality of trace statements; a processor executes a process including: executing the program embedded with a plurality of trace statements cyclically; calculating each time intervals of each cycle of execution of the program from a start test program till an end program; and evaluating the performance of the program on the basis of information of the time intervals.04-08-2010
20120204156SOFTWARE APPLICATION RECREATION - 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.08-09-2012
20090222797APPARATUS AND METHOD FOR PROVIDING A TRIGGER - A real-time trigger apparatus and method for using the same including a trigger logic block configured to output a trigger signal, and at least one reference register configured to store a traced value calculated by the trigger logic block, wherein the trigger signal is based at least in part on the traced value.09-03-2009
20080320450RECOVERABLE RETURN CODE TRACKING AND NOTIFICATION FOR AUTONOMIC SYSTEMS - A system, method and article of manufacture return code management in autonomic systems and more particularly to managing execution of operations in data processing systems on the basis of return code tracking. One embodiment provides a method for managing execution of an operation in a data processing system. The method comprises tracking return codes received from previous executions of the operation in the data processing system, determining an execution behavior of the operation from the tracked return codes, and managing a subsequent execution of the operation on the basis of the determined execution behavior.12-25-2008
20100281469SYMBOLIC PREDICTIVE ANALYSIS FOR CONCURRENT PROGRAMS - A symbolic predictive analysis method for finding assertion violations and atomicity violations in concurrent programs is shown that derives a concurrent trace program (CTP) for a program under a given test. A logic formula is then generated based on a concurrent static single assignment (CSSA) representation of the CTP, including at least one assertion property or atomicity violation. The satisfiability of the formula is then determined, such that the outcome of the determination indicates an assertion/atomicity violation.11-04-2010
20130014088CONTINUOUS QUERY LANGUAGE (CQL) DEBUGGER IN COMPLEX EVENT PROCESSING (CEP) - A method including receiving, at a computer system, debugging configuration information specifying a functional area of a data stream processing server to be debugged, is described. Furthermore, the method includes identifying, by the computer system, an object associated with the functional area that has been instantiated by the data stream processing server, determining, by the computer system, that tracing for the object is enabled to perform the debugging, and instantiating, by the computer system, a tracelet associated with the object. Further, the method includes stepping, by the computer system, through the tracelet associated with the object to debug the object, and displaying, by the computer system, a visual representation of debugging results associated with the object.01-10-2013
20120311543REMOVAL OF ASYNCHRONOUS EVENTS IN COMPLEX APPLICATION PERFORMANCE ANALYSIS - A method and apparatus for identifying a minimum call tree data structure from a plurality of call tree data structures are provided. With the apparatus and method, call tree data structures are generated for two or more executions of a build of a computer program. The apparatus and method perform a “tree-minimization” operation in which the two or more call trees generated during runs of the computer program are walked and only those nodes that are present in each of the tree data structures are maintained in a minimized tree data structure. In addition, the minimum values for these common nodes are maintained in the minimized tree data structure. In this way, asynchronous events are removed from the minimum tree data structure and analysis may focus on those areas of the computer program that are consistent between runs of the computer program.12-06-2012
20120311542DYNAMIC INTERFACE REDUCTION FOR SOFTWARE MODEL CHECKING - Architecture employs an iterative process that incrementally discovers inter-component interactions and explores local state spaces within each component. Thus, the architecture lazily constructs the behavior of the environment of a component in the target software system, and integrates the construction of the inter-component interactions with the model checking process itself, and hence, does not need to eagerly construct the interface process. Component-based state space reduction is applied during the exploration of the whole system. The architecture decomposes a target software system into a set of loosely coupled components where interactions between the components tend to be significantly simpler than interactions within each component. An iterative algorithm facilitates the component-based state space reduction, which is exponential, on the real large-scale software systems.12-06-2012
20110258611VISUALIZATION OF RUNTIME ANALYSIS ACROSS DYNAMIC BOUNDARIES - 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.10-20-2011
20110258609METHOD AND SYSTEM FOR SOFTWARE DEFECT REPORTING - A method and system ties together the identification of a defect during testing with the supporting application code on the systems that led to the generation of a defect. The association between the two is through the use of a unique Trace ID. This Trace ID is unique to each interaction between the consumer (e.g. client browser) and the provider system(s) (web application server, back office systems, etc). When a potential defect is identified by the end user or tester, the present invention “collects” the associated log messages using the unique Trace ID and attaches those to the defect. The software developer providing the defect triage can then readily review the associated log files without having to manually search the supporting log files manually.10-20-2011
20110258612METHODS AND SYSTEMS FOR DEBUGGING BYTECODE IN AN ON-DEMAND SERVICE ENVIRONMENT - Methods and systems for debugging byte code in an on-demand service environment system including a system for simulating execution debug in a multi-tenant database environment. In one embodiment, such a method includes receiving a request at a web-server of the system, wherein the request comprises a request for services from a multi-tenant database implementation within the system, in which the multi-tenant database implementation includes elements of hardware and software that are shared by a plurality of separate and distinct customer organizations, each of the separate and distinct customer organizations being remotely located from a host organization having the system executing therein. The method further includes determining one or more trace preferences are active for the request, sending the request to a logging framework communicatively interfaced to the multi-tenant database implementation, processing the request via the logging framework, and capturing at least a portion of the execution data emitted responsive to execution of the plurality of events for use in simulating execution debug of the events.10-20-2011
20100115494SYSTEM FOR DYNAMIC PROGRAM PROFILING - A system and method for efficient whole program profiling of software applications. A computing system comprises a dynamic binary instrumentation (DBI) tool coupled to a virtual machine configured to translate and execute binary code of a software application. The binary code is augmented with instrumentation and analysis code during translation and execution. Characterization information of each basic block is stored as each basic block is executed. A dynamic binary analysis (DBA) tool inspects this information to identify hierarchical layers of cycles within the application that describe the dynamic behavior of the application. A sequence of basic blocks may describe paths, a sequence of paths may describe a stratum, and a sequence of strata may describe a stratum layer. Statistics of these layers and hot paths may be determined and stored. This data storage yields a whole program profile comprising program phase changes that accurately describes the dynamic behavior of the application.05-06-2010
20110138363COMBINING METHOD PARAMETER TRACES WITH OTHER TRACES - Implementations of the present disclosure provide methods including executing an application, generating a method parameter trace, the method parameter trace providing one or more parameter values corresponding to one or more methods called during execution of the application, generating an event trace, the event trace identifying one or more events occurring during execution of the application, and combining the method parameter trace and the event trace to provide a profile of events occurring during each of the one or more methods based on the one or more parameter values.06-09-2011
20120151451Post-execution software debugger with event display - A method finds an error in a computer program. A sequence of machine instructions performed by a processor is recorded as trace data. Further, at least one event is selected from a plurality of events. In addition, an operating system instruction address is determined for the at least one event. Further, at least a portion of the trace data is searched for the operating system instruction address. The execution time for an operating system instruction stored in the operating system instruction address is determined. The execution time is searched through in the database to find task related data. The task related data is displayed.06-14-2012
20120151450Platform-Agnostic Diagnostic Data Collection and Display - A data collection system may instrument and collect data from arbitrary executable code by loading the executable code into memory and instrumenting the code according to monitoring conditions. The instrumentation may include pointers or bindings to a data collector that may gather and store information when the monitoring condition exists. A display module may allow a programmer to browse the results. The data collection system may operate on any type of native code or intermediate code and may operate with or without symbol tables.06-14-2012
20110154296MULTI TRACE PARSER - A method and a system for tracing the execution of multiple software products. The system includes: a collecting tool that is configured for collecting and internally listing in a list trace files; a determining device for determining the format of each trace file on the list, and selecting, as function of the format and for each trace file on the list, an associated parser, the associated parser being configured to read the listed trace file and extract trace data of the listed trace file; a translator for translating the extracted trace data into a new dataset; and a Graphical User Interface for displaying at least a subset of said new dataset.06-23-2011
20100031239Systems, Methods, and Media for Testing Software Patches - Systems, methods, and media for testing software patches are provided (02-04-2010
20110307870EXECUTION CAPTURE AND REPLAY BASED DEBUGGING - A debugging tool is provided that is capable of recording code paths taken during a program's execution, and along the way capture the memory state at configurable points in time such as function exits or statements. The tool also records interactions with external systems like a database, and captures which statements resulted in interactions with these systems. An analysis of the output of the debugging tool enables a developer to understand which part of the code executed; what the value of relevant variables were at configurable points in time; and which code statements correlate to which interactions with external systems.12-15-2011
20090172645CALL STACK EVALUATION TO ASSURE PROPER FRAMEWORK ACCESS - A computer program product, system and method for verifying a call stack is provided and includes framework modules accessing an image of a call stack, verifying the call stack is compatible with a called framework module, and performing a default operation if the call stack is not compatible with a called framework module.07-02-2009
20090172644SOFTWARE FLOW TRACKING USING MULTIPLE THREADS - 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.07-02-2009
20110321016INJECTION CONTEXT BASED STATIC ANALYSIS OF COMPUTER SOFTWARE APPLICATIONS - Embodiments of the invention generally relate to injection context based static analysis of computer software applications. Embodiments of the invention may include selecting a sink within a computer software application, tracing a character output stream leading to the sink within the computer software application, determining an injection context of the character output stream at the sink, where the injection context is predefined in association with a state of the character output stream at the sink, identifying any actions that have been predefined in association with the identified injection context, and providing a report of the actions.12-29-2011
20120047492DEPLOYMENT OF A TOOL FOR TESTING MIGRATED APPLICATIONS - Configuration information associated with software installed on a production system may be discovered. A script is automatically generated for capturing data traffic from and to the software installed on the production system using the configuration information. The script may be executed to capture data traffic of the software running on the production system. A migrated version of the software may be executed on a test system using requests extracted from the captured data traffic. The responses in the captured data traffic may be compared with responses from the migrated version of the software.02-23-2012
20120005658Programmatic Root Cause Analysis For Application Performance Management - Programmatic root cause analysis of application performance problems is provided in accordance with various embodiments. Transactions having multiple components can be monitored to determine if they are exceeding a threshold for their execution time. Monitoring the transactions can include instrumenting one or more applications to gather component level information. For transactions exceeding a threshold, the data collected for the individual components can be analyzed to automatically diagnose the potential cause of the performance problem. Time-series analytical techniques are employed to determine normal values for transaction and component execution times. The values can be dynamic or static. Deviations from these normal values can be detected and reported as a possible cause. Other filters in addition to or in place of execution times for transactions and components can also be used.01-05-2012
20110167412UNIVERSAL CAUSALITY GRAPHS FOR BUG DETECTION IN CONCURRENT PROGRAMS - A system and method for predictive analysis includes generating an execution trace on an instrumented version of source code for a multithreaded computer program. Interleavings which potentially lead to a violation in the program are statically generated by performing a static predictive analysis using a Universal Causality Graph (UCG) to generate alternative interleavings that might lead to an error. The UCG includes a unified happens-before model for the concurrent program and a property being analyzed. The interleavings are symbolically checked to determine errors in the program.07-07-2011
20080270995Method for Automatic Detection of Build Regressions - A method and apparatus for automatically performing regression processing on trace data are provided. With the apparatus and method, call tree data structures are generated for two or more executions of two or more builds of a computer program. The apparatus and method perform a “tree-minimization” operation on each set of call tree data structures for each of the builds to generate minimized call tree data structures for each build of the computer program. The minimized call tree data structures are then subtracted from one another to generate a subtracted minimized call tree data structure. From this subtracted minimized call tree data structure, the portions of the computer program that are different from build to build and which appreciably and consistently affect the difference in execution of the computer program from build to build may be identified. Thus, the analyst's attention is directed to these areas of the computer program code which may be optimized in order to obtain better execution of the computer program.10-30-2008
20120159454PROBE INSERTION VIA BACKGROUND VIRTUAL MACHINE - A performance monitoring system is described herein that works with a hypervisor to reserve resources outside of a virtual machine to monitor performance of an application running within the virtual machine. The application receives the guaranteed amount of resources specified by the virtual machine's specifications, and the monitoring consumes resources not associated with the virtual machine. The application running in the virtual machine is already isolated by the hypervisor from the physical machine, and thus additional burdens on the physical machine that allow the hypervisor to continue meeting guarantees to the virtual machine will not impact application performance. The performance monitoring system provides instrumentation of deployed applications that information technology (IT) personnel can dynamically turn on and off without affecting the performance of the deployed application. The performance monitoring system provides a robust framework for monitoring production applications without affecting the performance of those applications during execution.06-21-2012
20110107309Valgrind Suppressions File Editor - A computer-implemented method involving detecting a creating or opening of a suppression file presenting a suppression edits, executing an auto complete search in response to input to define a suppressions and storing the suppression file to be utilized with a profiling tool to hide data defined by the suppression file.05-05-2011
20100095279METHOD FOR AUTOMATICALLY TESTING MENU ITEMS OF APPLICATION SOFTWARE - An automatic testing method is used for automatically testing multiple menu items of application software. The application software is executed to display a window including the multiple menu items on a screen. The method includes the following steps. Firstly, multiple serial numbers are assigned to respective menu items of the application software by automatic testing tool software. Then, an automatic testing script including multiple command symbols and the serial numbers is produced. The functions of the multiple menu items of the window are implemented, thereby outputting an automatic testing result.04-15-2010
20100095278TRACING A CALLTREE OF A SPECIFIED ROOT METHOD - A specification of a routine name of a root of a call tree and a specification of a desired depth of call tree tracing are obtained. Upon entering a given routine in a program, a determination is made whether the given routine is the root. Responsive to determining that the given one of the routines is the root, trace information for the routine forming the root is output. Furthermore, upon entering a given one of the routines called, directly or indirectly, by the routine forming the root, a determination is made whether the given one of the routines called, directly or indirectly, by the routine forming the root of the call tree is within the desired depth from the routine forming the root of the call tree; and if this is the case, trace information is output for given one of the routines called, directly or indirectly, by the routine forming the root of the call tree.04-15-2010
20110099539ANALYSIS AND TIMELINE VISUALIZATION OF THREAD ACTIVITY - Analyzing the performance of multi-threaded applications. An analysis and visualization of thread executions is performed on a graphical timeline using samples of thread execution. This allows users to understand when their application threads are executing, what they were executing, the degree of concurrency in thread execution, and the order in which work is performed in their application. The visualizations and analysis also allow users to sample thread execution contexts using a graphical user interface, as well as the generation of execution profile reports that may be filtered for a specific time range of execution and a subset of the threads running in the application.04-28-2011
20120174076SYSTEMS AND METHODS FOR PROFILING SERVERS - Systems and methods for implementing a server profiling device are provided. For example, one method of profiling servers includes implementing a replacement call to intercept a system call using a library wrapper function, and determining a thread identifier for the system call. The method also includes collecting data for an operation of the thread identifier, and creating an in-memory table to store the collected data for the thread identifier. The method also includes obtaining a stack-trace for a number of running threads and combining the stack-trace with the data collected for the thread identifier, and presenting the stack-trace combined with the data collected through a user interface.07-05-2012
20120174077Backward post-execution software debugger - A method finds an error in a computer program. A plurality of execution breakpoints are set in the computer program. A portion of the execution of the computer program is simulated as recorded in the trace data in the reverse order until one a plurality of conditions is met, wherein one of the plurality of conditions is an attempt to execute a machine instruction associated with one of the plurality of execution breakpoints.07-05-2012
20120124561Obtaining Notes for Software Objects - A computer-implemented method for obtaining notes for software objects includes: reproducing, in a customer computer system, a problem that has been detected in the customer computer system; performing a trace while reproducing the problem, the trace identifying at least one object in the customer computer system as being involved in reproducing the problem; identifying, from among multiple notes in a notes repository, at least a first note as applying to the identified object, the identified first note configured for implementation in the customer computer system; and presenting the identified first note in the customer computer system.05-17-2012
20120317551Post-compile instrumentation of object code for generating execution trace data - The invention is directed to instrumenting object code of an application and/or an operating system on a target machine so that execution trace data can be generated, collected, and subsequently analyzed for various purposes, such as debugging and performance. Automatic instrumentation may be performed on an application's object code before, during or after linking. A target machine's operating system's object code can be manually or automatically instrumented. By identifying address space switches and thread switches in the operating system's object code, instrumented code can be inserted at locations that enable the execution trace data to be generated. The instrumentation of the operating system and application can enable visibility of total system behavior by enabling generation of trace information sufficient to reconstruct address space switches and context switches.12-13-2012
20120317550Forward post-execution software debugger - A method and system debug a computer program by using trace data, which is a recording of the sequence of machine instructions executed by a program during a time period along with the addresses and values of memory locations accessed and modified by each machine instruction. After the time period, the method and system use the trace data to simulate the execution of the program during the time period under the control of a debugger. In addition, the method and system use the trace data to simulate the execution of the program during the time period backwards in time under the control of the debugger.12-13-2012
20120317549Automatic Rules Based Capturing of Graphical Objects for Specified Applications - Graphical objects presented by a computer system are captured by monitoring execution of an application on the computer system, and capturing one or more graphical objects of a graphical user image presented by the computer system and associated with the application. The one or more graphical objects are captured automatically in accordance with a pre-defined set of rules for the application.12-13-2012
20120137274SOFTWARE APPLICATION FEEDBACK COLLECTION SYSTEM AND METHOD - A software application feedback collection system includes a creating module, a usage recorder, an exception recorder, and a sending module. The creating module creates a feedback file in a storage system of the computing device when the feedback file does not exist. The usage recorder obtains usage information regarding usage of the software application and stores the usage information in the feedback file. The exception recorder acquires exception information regarding an exception of the software application and stores the exception information in the feedback file. The sending module sends the feedback file to a server via a network according to a determination that a predetermined criterion is met.05-31-2012
20120137273TRACE VISUALIZATION FOR OBJECT ORIENTED PROGRAMS - A method is provided to produce an information structure that indicates call hierarchy relationships among calls of a trace log file and that indicates time sequence relationships among calls of the trace log file, the method comprising: producing call records that correspond to calls identified in the trace log file; creating call hierarchy indicia that indicate hierarchical relationships among calls that correspond to the call records; and creating time sequence indicia that indicate time sequence relationships among calls that correspond to the call records.05-31-2012
20100175052SYSTEM AND METHOD FOR AUTOMATIC GENERATION OF TEST DATA TO SATISFY MODIFIED CONDITION DECISION COVERAGE - The tool, MC/DC-Automatic Tool Generator automatically generates test data to satisfy Modified Condition Decision Coverage (MCDC) from input code/model. This tool reduces the effort required to generate MCDC test data significantly. In order to reduce the time required by model checkers, abstraction and optimization methodologies have been implemented to analyze typical reactive software model/code.07-08-2010
20120254839SIMULATING BLACK BOX TEST RESULTS USING INFORMATION FROM WHITE BOX TESTING - Systems, methods are program products for simulating black box test results using information obtained from white box testing, including analyzing computer software (e.g., an application) to identify a potential vulnerability within the computer software application and a plurality of milestones associated with the potential vulnerability, where each of the milestones indicates a location within the computer software application, tracing a path from a first one of the milestones to an entry point into the computer software application, identifying an input to the entry point that would result in a control flow from the entry point and through each of the milestones, describing the potential vulnerability in a description indicating the entry point and the input, and presenting the description via a computer-controlled output medium.10-04-2012
20100050162AUTOMATICALLY DETECTING NON-MODIFYING TRANSFORMS WHEN PROFILING SOURCE CODE - 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.02-25-2010
20090106741UNIFIED TRACING SERVICE - A computer is programmed with multiple software programs to record structures including (a) unstructured information to denote a transition between portions of code, and (b) metadata related to one or more attributes of the information. In addition, the computer writes two additional types of structures: section type, and dump type. The section type structure has metadata to indicate a beginning and an end, to bracket a group of structures located therebetween. The dump type has a dump header and a dump body. The dump header includes a symbol to indicate it's of dump type. The dump body is a set of values of an object used by the software program(s) during execution by the computer. A group of structures, within a section type, may include structures of each of the trace record type, dump type and section type.04-23-2009
20090049428ERROR TRACING WITH CONTEXT HISTORY - Trace messages generated during execution of programming code are logged in a trace log. The logged trace messages logged during execution of a portion of the programming code are deleted from the trace log when the portion of programming code executes without an error. The logged trace messages are kept in the trace log when an error occurs during execution of the portion of the programming code. The trace log is output when the execution of the programming code ends.02-19-2009
20120185830SOFTWARE PROBE MINIMIZATION - A method of developing a tracing solution for the execution of blocks of computer code. The method comprises representing each block of code of an initial tracing solution as a vertex on an initial tracing solution graph. The vertices on the initial tracing solution graph constitute an initial set of vertices The method further comprises checking whether there are any redundant vertices in the initial set of vertices. Redundant vertices are vertices not needed for a tracing solution. If there are any redundant vertices in the initial set of vertices, one ore more of the redundant vertices is eliminated from the initial set of vertices, thereby deriving a reduced set of vertices.07-19-2012
20120185831EXECUTABLE HIGH-LEVEL TRACE FILE GENERATION METHOD - An executable high-level trace file generation method provides reduced debugging effort and time, particularly on initial startup of new or modified hardware. An executable program invokes high-level application programming interfaces (APIs), to perform various tasks. Instructions within the APIs generate a trace file documenting the invoked sequence of APIs by writing a line to a trace file that documents the API and input parameters received by the API. Upon completion of execution of the API, the return value may be documented as a comment line in the trace file. The resulting trace file is then re-executable as a script and may be edited to alter the sequence of APIs invoked and/or the arguments provided. The script interpreter may be a command line interface through which the APIs are invoked, and trace files may be similarly generated that document sequences of manually entered commands.07-19-2012
20110239197INSTANCE-BASED FIELD AFFINITY OPTIMIZATION - Dynamic determination of affinity between fields of structure may be determined based on accesses to the same instance. The affinity may be utilized in determining a data layout of a structure so as to optimize performance of a target program. The affinity determination may be an estimation based upon a trace of an execution of the target program. Access relation between proximate accesses to fields of the same instance may be utilized to estimate an optimized data layout of the structure.09-29-2011
20100229159METHOD OF TRACING OBJECT ALLOCATION SITE IN PROGRAM, AS WELL AS COMPUTER SYSTEM AND COMPUTER PROGRAM THEREFOR - 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.09-09-2010
20100229157EXTRACTING AND COLLECTING PLATFORM USE DATA - A system for reporting information about how selected components of an operating system are used by applications on a computing device. A manifest of components is provided from a management server to a computing device. The manifest specifies components of the operating system for which usage information is to be collected. The computing device surveys applications for calls to the components specified in the manifest. Surveys may be performed by static scanning and/or dynamic monitoring. In static scanning, application files are scanned for keyword strings specified in the manifest. Keyword string matches are recorded to a log file. In dynamic monitoring, calls from executing applications to components specified by the manifest are identified and logged. A report is generated from the log and sent to the management server. The management server then aggregates and analyzes reports from multiple computing devices to enable developers to assess how the components are being used.09-09-2010
20120102468REGISTRATION-BASED REMOTE DEBUG WATCH AND MODIFY - A remote debugging technique provides anonymity of program variables and selective debugging capability by providing a registration facility by which program variables are registered locally with a debugging module. An external program then communicates with the debugging modules and observes and/or modifies the program variables by specifying either an index or a variable name. The need to publish symbols is thereby averted and only the variables that a developer is interested in observing need be registered.04-26-2012
20100131931SAMPLING TECHNIQUES FOR DYNAMIC DATA-RACE DETECTION - This document describes a dynamic data race detector that utilizes adaptive sampling techniques. The adaptive sampling techniques include locating threads during execution of a multi-threaded program and identifying thread-specific hot paths, thread-specific cold paths and lockset paths during execution of the program. Once these paths are identified, they are sampled, potentially at different rates. Any information gained during the sampling may be stored in a data race log, which a developer may use to correct any identified program bugs05-27-2010
20080222613METHOD AND APPARATUS FOR DATA PROCESSING - A method and system can include multiple data handling stages for manipulating tracked information associated with content distributed to users and/or computers, such as static objects, media objects, and/or software objects, for example. The content can be distributed as widget instances and the associated tracked information can be received over a network. The information received can be associated with a session corresponding to each widget instance and/or with multiple identifiers, such as widget, user, content, session, content aggregation point, processor, and/or placement identifiers, for example. Data handling processes, including sorting, storing, filtering, combining, queuing, and/or authenticating, for example, can be performed during the data handling stages. The processed information can be used to determine modifications to a behavior associated with widgets and/or widget containers.09-11-2008
20130179866Debugging A High Performance Computing Program - Methods, apparatus, and computer program products are disclosed for debugging a high performance computing program by gathering lists of addresses of calling instructions for a plurality of threads of execution of the program, assigning the threads to groups in dependence upon the addresses, and displaying the groups to identify defective threads.07-11-2013
20120254838METHOD AND APPARATUS FOR TRACING MEMORY ACCESSES - Apparatus, computer-readable storage medium and a method executed by a computer for tracing the memory accesses of an object-oriented program comprises assigning a unique identification to each class object created from at least one class in the object-oriented program by modifying a class definition of the at least one class. In response to an unloading of one of the class objects, obtaining class unloading related information from a runtime environment of the object-oriented program and obtaining the unique identification of the unloaded class object according to the returned information. Then releasing memory space assigned to the unloaded class object for storing the memory access information of the unloaded class object.10-04-2012
20120254837TASK SWITCH IMMUNIZED PERFORMANCE MONITORING - A performance monitoring technique provides task-switch immune operation without requiring storage and retrieval of the performance monitor state when a task switch occurs. When a hypervisor signals that a task is being resumed, it provides an indication, which starts a delay timer. The delay timer is resettable in case a predetermined time period has not elapsed when the next task switch occurs. After the delay timer expires, analysis of the performance monitor measurements is resumed, which prevents an initial state or a state remaining from a previous task from corrupting the performance monitoring results. The performance monitor may be or include an execution trace unit that collects taken branches in a current trace and may use branch prediction success to determine whether to collect a predicted and taken branch instruction in a current trace or to start a new segment when the branch resolves in a non-predicted direction.10-04-2012
20100287538METHOD AND SYSTEM FOR DATA CENTRIC HEAP PROFILING - A method and system for data centric heap profiling is disclosed. In one embodiment, a method, implemented in a computing device, for data centric heap profiling includes generating a type table for data structure types in source code using a compiler of the computing device. The method also includes identifying each heap allocation site and a corresponding data structure type in the source code using the compiler. The method further includes generating a data centric view of a heap o fan application compiled from the source code based on the each heap allocation site and the corresponding data structure type using a debugger of the computing device when a snapshot of the heap is requested during an execution of the application.11-11-2010
20100287537METHOD AND SYSTEM FOR ANOMALY DETECTION IN SOFTWARE PROGRAMS WITH REDUCED FALSE NEGATIVES - A method, system and article of manufacture are disclosed for detecting anomalies in a software program. The method comprises the steps of running the software program as a client; and the software program sending to a server a multitude of tokens at specified points in the program, each of the tokens having information about the software program. The server implements code to analyze said tokens and to compare information in the tokens to stored data to identify anomalies in the software program. In a preferred embodiment, the tokens identify patterns of operation of the software programs, and the implementing step includes the step of comparing these program patterns with stored acceptable patterns to identify anomalous program patterns. This comparing may be done by the logging, as potential anomalies, selected ones of the program patterns that do not match any of the stored acceptable patterns.11-11-2010
20100287536PROFILING APPLICATION PERFORMANCE ACCORDING TO DATA STRUCTURE - During runtime of a binary program file, streams of instructions are executed and memory references, generated by instrumentation applied to given ones of the instructions that refer to memory locations, are collected. A transformation is performed, based on the executed streams of instructions and the collected memory references, to obtain a table. The table lists memory events of interest for active data structures for each function in the program file. The transformation is performed to translate memory addresses for given ones of the instructions and given ones of the data structures into locations and variable names in a source file corresponding to the binary file. At least the memory events of interest are displayed, and the display is organized so as to correlate the memory events of interest with corresponding ones of the data structures.11-11-2010
20100318972Trace Correlation for Profiling Subroutines - In one or more embodiments, a data processing system can include at least one core capable of executing instructions of an instruction set architecture and a trace unit coupled to the at least one core. A call to a subroutine can be detected, and in response, a program trace correlation (PTC) message can be generated and sent to a trace port. Data associated with an execution of the subroutine and/or performance of the data processing system can be sampled and sent to the trace port. A return from the subroutine can be detected, and in response, a trace message can be generated and sent to the trace port. The PTC message and the trace message can be correlated, and the correlation of the PTC message and the trace message can be used to determine a boundary for the subroutine and/or the sampled data associated with the execution of the subroutine.12-16-2010
20120284698PROGRAM SUBSET EXECUTION AND DEBUG - In response to identification of an error in operation of a system, a debugging module determines where to set a debug entry point for a program subset debug session. An initial file state is captured for at least one file accessed by the system in response to initiation of a subsequent execution of the system. Prior to detection of execution of the system at the debug entry point, any file inputs and file outputs (I/Os) detected during the subsequent execution of the system are queued. Debug entry point metadata, including the captured initial at least one file state, the queued file I/Os, and an image of all instantiated objects at the debug entry point, is stored in response to detection of execution of the system at the debug entry point.11-08-2012
20130159977OPEN KERNEL TRACE AGGREGATION - A kernel trace system is described that acts as a kernel driver to insert traces into an open system kernel using existing kernel probe application-programming interfaces (APIs) and copies these events to an existing logging module for transfer to user space. The new module aggregates kernel traces to a performance logging module. A performance logging module can be extended with the kernel trace system herein to include new events in an open kernel not originally included in the implementation of the performance logging module. In this way, the kernel trace system can cause events to be logged that were not logged in the kernel as provided by the operating system vendor, and can do so without requiring that a new version of the operating system be built. The probes can be inserted dynamically at run time on an existing kernel to extract additional trace information.06-20-2013
20110314452TRACING JUST-IN-TIME COMPILATION WITH POINTERS TO LOCAL VARIABLES - In one embodiment, a trace optimizing engine may create an optimized trace of an operation segment of a software program. A memory 12-22-2011
20120030657METHOD AND SYSTEM FOR USING A VIRTUALIZATION SYSTEM TO IDENTIFY DEADLOCK CONDITIONS IN MULTI-THREADED PROGRAMS BY CONTROLLING SCHEDULING IN REPLAY - A method and system for determining potential deadlock conditions in a target multi-threaded software application. The target application is first run in a virtual machine and the events within the application are recorded. The recorded events are replayed and analyzed to identify potential lock acquisition conflicts occurring between threads of the application. The potential lock acquisition conflicts are identified by analyzing the order in which resource locks are obtained and pairs of resources that have respective locks obtained in different orders are analyzed. These analyzed pairs are used to define a different order of events in the target application that, when the target application is re-run with the second order of events, may trigger a deadlock condition. The target application is then re-run with the different order of events in an attempt to trigger and then identify potential deadlock situations.02-02-2012
20120030656SYSTEM AND METHOD FOR PARAMETRIC SYSTEM EVALUATION - A method and system for evaluating a system are described. A parameter space comprising one or more parameters corresponding to the system and/or an application executed on the system is defined. Additionally, one or more search functions for selecting a parameter from the parameter space to evaluate a desired characteristic of the system are determined. Further, at least one parameter from the parameter space is selected using the one or more search functions and the application is executed using the selected parameter. Subsequently, the execution of the application is monitored and metrics associated with the application are recorded. The method further includes iteratively selecting another parameter from the parameter space based on the recorded metrics and executing the application using the selected another parameter.02-02-2012
20130205281TRACER BASED RUNTIME OPTIMIZATION FOR DYNAMIC PROGRAMMING LANGUAGES - A method and an apparatus that generate tracer data randomly and infrequently for origins and destinations of values created during runtime of a compiled code of a source code is described. A tracer graph may be updated to record the origins and destinations of the values during the runtime. The compiled code may be optimized to reduce processing resources between the origins and the destinations of the values according to the tracer graph. The optimized compiled code may be executed for at least a portion of the source code.08-08-2013

Patent applications in class Tracing