US6282701B1 - System and method for monitoring and analyzing the execution of computer programs - Google Patents
System and method for monitoring and analyzing the execution of computer programs Download PDFInfo
- Publication number
- US6282701B1 US6282701B1 US09/126,126 US12612698A US6282701B1 US 6282701 B1 US6282701 B1 US 6282701B1 US 12612698 A US12612698 A US 12612698A US 6282701 B1 US6282701 B1 US 6282701B1
- Authority
- US
- United States
- Prior art keywords
- trace
- client
- execution
- program
- information
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Expired - Lifetime
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3664—Environments for testing or debugging software
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/34—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
- G06F11/3466—Performance evaluation by tracing or monitoring
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3636—Software debugging by tracing the execution of the program
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/32—Monitoring with visual or acoustical indication of the functioning of the machine
- G06F11/323—Visualisation of programs or trace data
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/34—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
- G06F11/3466—Performance evaluation by tracing or monitoring
- G06F11/3495—Performance evaluation by tracing or monitoring for systems
Definitions
- the present invention relates to software tools for assisting software developers in the task of monitoring and analyzing the execution of computer programs, such as during the debugging process.
- debuggers Despite the significant diversity in software tracing and debugging programs (“debuggers”), virtually all debuggers share a common operational model: the developer notices the presence of a bug during normal execution, and then uses the debugger to examine the program's behavior. The second part of this process is usually accomplished by setting a breakpoint near a possibly flawed section of code, and upon reaching the breakpoint, single-stepping forward through the section of code to evaluate the cause of the problem.
- the second problem is that some bugs give rise to actual errors only during specific execution conditions, and these conditions cannot always be reproduced during the debugging process.
- a program error that occurs during normal execution may not occur during execution under the debugger, since the debugger affects the execution of the program.
- This situation is analogous to the famous “Heizenberg effect” in physics: the tool that is used to analyze the phenomena actually changes its characteristics.
- the Schuenberg effect is especially apparent during the debugging of time-dependent applications, since these applications rely on specific timing and synchronization conditions that are significantly altered when the program is executed step-by-step with the debugger.
- the imbedded tracing code is designed to provide information regarding the execution of the application. Often, this imbedded code is no more than code to print messages which are conditioned by some flag that can be enabled in response to a user request.
- the imbedded code solution depends on inserting the tracing code into the source prior to compiling and linking the shipped version of the application. To be effective, the imbedded code must be placed logically near a bug in the source code so that the trace data will provide the necessary information. Trying to anticipate where a bug will occur is, in general, a futile task. Often there is no imbedded code where it is needed, and once the application has been shipped it is too late to add the desired code.
- Another drawback of current monitoring systems is the inability to correctly handle parallel execution, such as in a multiprocessor system.
- the monitoring systems mentioned above are designed for serial execution (single processor) architectures.
- serial techniques for parallel systems may cause several problems.
- First, the sampling activity done in the various parallel entities (threads or processes) may interfere with each other (e.g., the trace data produced by one entity may be over written by another entity).
- the function call graph in a serial environment is a simple tree. In a parallel processing environment, the function call graph is no longer a simple tree, but a collection of trees. There is a time-based relationship between each tree in the collection.
- One aspect of the present invention is a software system that facilitates the process of identifying and isolating bugs within a client program by allowing a developer to trace the execution paths of the client.
- the tracing can be performed without requiring modifications to the executable or source code files of the client program.
- the trace data collected during the tracing operation is collected according to instructions in a trace control dataset, which is preferably stored in a Trace Control Information (TCI) file.
- TCI Trace Control Information
- the developer generates the TCI file by using a trace options editor program having a graphical user interface.
- the options editor displays the client's source code representation on a display screen together with controls that allow the software developer to interactively specify the source code and data elements to be traced.
- the options editor may use information created by a compiler or linker, such as debug information, in order to provide more information about the client and thereby make the process of selecting trace options easier.
- the developer then uses a trace analyzer program, also having a graphical user interface, to decode the trace information into a human-readable form, again using the debug information, and displays translated trace information on the display screen to allow the developer to analyze the execution of the client program.
- a trace analyzer program also having a graphical user interface
- the trace options editor and the trace analyzer are combined into a single program called the analyzer.
- the analyzer is preferably configured to run under the control of a multi-process operating system and to allow the developer to trace multiple threads and multiple processes.
- the tracing library is preferably configured to run in the same process memory space as the client thereby tracing the execution of the client program without the need for context switches.
- the software system provides a remote mode that enables the client program to be traced at a remote site, such as by the customer at a remote customer site, and then analyzed at the developer site.
- a remote mode the developer sends the TCI file for the particular client to a remote user site together with a small executable file called the tracing “agent.”
- the agent is adapted to be used at the remote user site as a stand-alone tracing component that enables a remote customer, who does not have access to the source code of the client, to generate a trace file that represents execution of the client application at the remote site.
- the trace file is then sent to the developer site (such as by email), and is analyzed by the software developer using the analyzer.
- the remote mode thus enables the software developer to analyze how the client program is operating at the remote site, without the need to visit the remote site, and without exposing to the customer the source code or other confidential details of the client program.
- the software system also preferably implements an online mode that enables the software developer to interactively trace and analyze the execution of the client.
- the analyzer and agent are effectively combined into one program that a developer can use to generate trace options, run and trace the client, and display the trace results in near real-time on the display screen during execution of the client program.
- FIG. 1A is a block diagram illustrating the use of the system to create a trace control information file.
- FIG. 1B is a block diagram illustrating the use of the system in remote mode.
- FIG. 1C is a block diagram illustrating the use of the system to analyze a trace log file.
- FIG. 2 is a block diagram illustrating the use of the system in online mode.
- FIG. 3A is an illustration of a typical main frame window provided by the system's trace analyzer module.
- FIG. 3B is an illustration of a typical main frame window showing multiple threads.
- FIG. 4 illustrates a process list window that lists the processes to be traced.
- FIG. 5 illustrates the trace options window that allows a developer to select the functions to be traced and the information to be collected during the trace.
- FIG. 6 illustrates a file page window that provides a hierarchical tree of trace objects listed according to hierarchical level.
- FIG. 7 illustrates a class page window that provides a hierarchical tree of trace objects sorted by class.
- FIG. 8 illustrates the process page window that provides a hierarchical tree that displays the traced process, and the threads for each process.
- FIG. 9 illustrates the running process window that allows the user to attach to and start tracing a process that is already running.
- FIG. 10 illustrates the start process window that allows the user to load an executable file, attach to the loaded file, execute the loaded file, and start tracing the loaded file.
- FIG. 11 shows a trace detail pane that displays a C++ class having several members and methods, a class derived from another classes, and classes as members of a class.
- FIG. 12 illustrates a trace tree pane, showing a break (or tear) in the trace tree where tracing was stopped and then restarted.
- FIG. 13 is a flowchart which illustrates the process of attaching to (hooking) a running process.
- FIG. 14 is a flowchart which illustrates the process of loading an executable file and attaching to (hooking) the program.
- the present invention provides a new model for tracing the execution path of and debugging a computer program.
- this tracing model is implemented within a set of tracing and debugging tools that are collectively referred to as the BugTrapper system (“BugTrapper”).
- the BugTrapper tools are used to monitor and analyze the execution of a computer program, referred to as a client.
- One feature of the BugTrapper is that it does not require special instructions or commands to be imbedded within the source code of the client, and it does not require any modifications to be made to the source or executable files of the client.
- “Tracing,” or “to trace,” refers generally to the process of using a monitoring program to monitor and record information about the execution of the client while the client is running.
- a “trace” generally refers to the information recorded during tracing.
- the BugTrapper tools collect data while the client is running.
- the BugTrapper tools instrument the client by inserting interrupt instructions at strategic points defined by the developer (such as function entry points) in the memory image of the client.
- This instrumentation process is analogous to the process of connecting a logic analyzer to a circuit board by connecting probes to test points on the circuit board.
- the BugTrapper collects trace information about the client without the need for a context switch, and then allows the client to continue running.
- BugTrapper implementations described herein operate under, and are therefore disclosed in terms of, the Windows-NT and Windows-95 operating systems. It will be apparent, however, that the underlying techniques can be implemented using other operating systems that provide similar services. Other embodiments of the invention will be apparent from the following detailed description of the BugTrapper.
- the BugTrapper provides two modes of use, remote mode and online mode.
- remote mode a developer can trace the remote execution of a program that has been shipped to an end user (e.g. a customer or beta user) without providing a special version of the code to the user, and without visiting the user's site or exposing the source code level details of the program to the user.
- the system can also be used in an online mode wherein the developer can interactively trace a program and view the trace results in real time.
- Step 1 a developer 112 uses a program called the BugTrapper analyzer 106 to create a file called a trace control information (TCI) file 120 .
- TCI trace control information
- the TCI file 120 contains instructions that specify what information is to be collected from a program to be traced (the client).
- the analyzer 106 obtains information about the client from a build (e.g., compile and link) by-product, such as a link map file, or, as in the preferred embodiment, a debug information file 121 .
- the debug information file 112 will be created by a compiler and will contain information such as the names and addresses of software modules, call windows, etc. for the specific client.
- the developer 112 then sends the TCI file 120 and a small tracing application called the agent 104 to a user 110 as shown in FIG. 1 B.
- the user 110 runs the agent 104 and the client 102 and instructs the agent 104 to attach to the client 102 .
- the agent attaches to the client 102 by loading a client-side trace library 125 into the address space of the client 102 .
- An agent-side trace library 124 is provided in the agent 104 .
- the client-side trace library 125 and the agent-side trace library 124 are referred to collectively as the “trace library.”
- the agent-side trace library 124 and the client-side trace library 125 exchange messages through normal interprocess communication mechanisms, and through a shared memory trace buffer 105 .
- the agent-side trace library 124 uses information from the TCI file 102 to attach the client-side trace library 125 into the client 102 , and thereby obtain the trace information requested by the developer 112 .
- a context can be a process, a thread, or any other unit of dispatch in a computer operating system.
- the client 102 can be any type of software module, including but not limited to, an application program, a device driver, or a dynamic link library (DLL), or a combination thereof.
- the client 102 can run in a single thread, or in multiple processes and/or multiple threads.
- the agent 104 attaches to the client 102 using a process known as “attaching.”
- the agent 104 attaches to the client 102 , either when the client 102 is being loaded or once the client 102 is running.
- the agent 104 extracts trace information, such as execution paths, subroutine calls, and variable usage, from the client 102 .
- the TCI file 120 contains instructions to the client-side trace library 125 regarding the trace data to collect.
- the trace data collected by the client-side trace library 125 is written to the trace buffer 105 .
- the agent 104 copies the contents of the trace buffer 105 to a trace log file 122 .
- the log data is written to a file automatically, such as when the client terminates.
- the user 110 sends the trace log file 122 back to the developer 112 .
- the developer 112 uses the analyzer 106 to view the information contained in the trace log file 122 .
- the analyzer 106 obtains information from the debug information file 121 . Since the analyzer 106 is used to create the TCI file 120 and to view the results in the trace log file 122 , the developer can edit the TCI file 120 or create a new TCI file 120 while viewing results from a trace log file 122 .
- Remote mode is used primarily to provide support to users 110 that are located remotely relative to the developer 112 .
- the agent 104 is provided to the user 110 as a stand-alone component that enables the user to generate a trace log file that represents the execution of the client.
- the TCI file 120 and the trace log file 122 both may contain data that discloses secrets about the internal operation of the client 102 and thus both files are written using an encoded format that is not readily decipherable by the user 110 .
- the developer 112 is not divulging information to the user that would readily divulge secrets about the client 102 or help the user 110 in an attempt to reverse engineer the client 102 .
- the Agent traces the client without any need for modification of the client.
- the developer 112 does not need to build a special version of the client 102 executable file and send it to the customer, neither does the customer need to pre-process the client executable file before tracing.
- the agent 104 acts essentially as a black box that records the execution path of the client 102 .
- the trace itself is not displayed on the screen, but immediately after the bug reoccurs in the application, the user 110 can dump the trace data to the trace log file 122 and send this file to the developer 112 (such as by email) for analysis.
- the developer 112 uses the analyzer 106 to view the trace log file created by the user 110 and identify the problematic execution sequence.
- the user 110 does not need access to the source code or the debug information.
- the agent 104 , the TCI file 120 , and the trace log file 122 are preferably small enough to be sent via email between the developer 112 and the user 110 . Further details regarding the remote mode of operation are provided in the sections below.
- the BugTrapper may also be used in an online mode rather than remote mode as shown in the previous figures.
- the BugTrapper is used by the developer 112 to locally analyze a client 102 , which will typically be a program that is still being developed.
- the online mode can be used as an aid during the development as a preliminary or complementary step to using a conventional debugger. In many cases it is hard to tell exactly where a bug resides and, therefore, where breakpoints should be inserted. Online mode provides the proper basis for setting these breakpoints. Later, if further analysis is required, a more conventional debugger can be used.
- the analyzer 106 is used to perform all of its normal operations (e.g.
- the agent 104 uses the analyzer 106 to run the client 102 and attach the client-side trace library 125 to the client 102 .
- the analyzer 106 reads the trace buffer 105 in near real-time to provide near real-time analysis functionality.
- the analyzer 106 immediately displays the trace information to the developer 112 .
- the developer 112 uses the analyzer 106 to interactively create trace control information (TCI).
- TCI may be sent to the client-side trace library 125 via file input/output operations or through conventional inter-process communication mechanisms such as shared memory, message passing or remote procedure calls.
- the TCI indicates to the client-side trace library 125 what portions of the client 102 to trace, and when the tracing is to be performed.
- the client-side trace library 125 collects the trace information and relays the information back to the analyzer 106 , which displays the information in near real-time within one or more windows of the BugTrapper.
- the client 102 is run in conjunction with the client-side trace library 125 .
- the client-side trace library 125 is attached to the in-memory image of the client 102 and generates trace information that describes the execution of the client 102 .
- the TCI file 120 provided by the developer 112 , specifies where tracing is to take place and what information will be stored. Because the client is traced without the need for context switches, the effect of this tracing operation on the performance of the client 102 is minimal, so that even time-dependent bugs can be reliably diagnosed. As described below, this process does not require any modification to the source or object code files of the client 102 , and can therefore be used with a client 102 that was not designed to be traced or debugged.
- the analyzer 106 is used to analyze the trace data and isolate the bug.
- the developer 112 may either analyze the trace data as it is generated (online mode), or the developer 112 may analyze trace data stored in the trace log file 122 (mainly remote mode). As described below, the assembly level information in the trace log file is converted back to a source level format using the same debug information used to create the TCI file 120 .
- the analyzer 106 provides the developer 112 with execution analysis options that are similar to those of conventional debuggers, including options for single stepping and running forward through the traced execution of the client 102 while monitoring program variables.
- the analyzer 106 allows the developer 112 to step backward in the trace, and to search for breakpoints both in the future and in the past.
- the attaching mechanism used to attach the client-side trace library 125 to the client 102 involves replacing selected object code instructions (or fields of such instructions) of the memory image of the client 102 with interrupt (INT) instructions to create trace points.
- the locations of the interrupts are specified by the TCI file 122 that is created for the specific client 102 .
- INT interrupt
- the client-side trace library 125 logs the event of passing the trace point location and captures pre-specified state information, such as values of specific program variables and microprocessor registers.
- the instructions that are replaced by the interrupt instructions are maintained within a separate data structure to preserve the functionality of the application.
- the analyzer 106 comprises a User Interface module that reads trace data, either from the trace buffer 105 (during on-line mode tracing) or from the trace log file 122 (e.g. after remote tracing) and displays the data in a format, such as a trace tree, that shows the sequence of traced events that have occurred during execution of the client 102 .
- Much of the trace data comprises assembly addresses.
- the analyzer 106 uses the debug information 121 to translate the traced assembly addresses to comprehensive strings that are meaningful to the developer. In order to save memory and gain performance, this translation to strings is preferably done only for the portion of the trace data which is displayed at any given time, not the whole database of trace data.
- the debug information 121 is preferably created by a compiler when the client is compiled. Using the debug information 121 the analyzer translates function names and source lines to addresses when creating the TCI file 120 . Conversely, the analyzer 106 uses the debug information 121 to translate addresses in the trace data back into function names and source lines when formatting a display for the user interface.
- the analyzer 106 uses the debug information 121 to translate addresses in the trace data back into function names and source lines when formatting a display for the user interface.
- build information may be used as well, including, for example, information in a linker map file and the Type Library information available in a Microsoft OLE-compliant executable.
- the debug information is never used by the trace libraries 124 , 125 or the agent 102 , but only by the analyzer 106 . This is desirable for speed because debug information access is typically relatively slow. This is also desirable for security since there is no need to send to the user 110 any symbolic information that might disclose confidential information about the client 102 .
- the analyzer 106 allows the developer 112 to open multiple trace tree windows and define a different filter (trace control instructions) for each of window.
- each window filter is preferably examined separately to see if the record should be displayed.
- the filters from the various windows are combined in order to create the TCI file 120 , which is read by the client-side trace library 125 .
- the multiple windows with different filters are handled by the User Interface, and the client-side trace library 125 reads from a single TCI file 120 .
- FIG. 3A is an illustration of a typical frame window 300 provided by the analyzer 106 .
- the analyzer frame window 300 displays similar information both when performing online tracing (online mode) and when displaying a trace log file (remote mode).
- the frame window 300 is a split frame having four panes.
- the panes include a trace tree pane 310 , an “executable” pane 314 , a trace detail pane 316 , and a source pane 318 .
- the analyzer frame 300 further provides a menu bar 304 , a dockable toolbar 306 , and a status bar 312 .
- the menu bar 304 provides drop-down menus labeled “File,” “Edit,” “View,” “Executable,” and “Help.”
- the trace tree pane 310 contains a thread caption bar 320 , described below in connection with the Analyzer. Below the thread caption bar 320 is a trace tree 330 .
- the trace tree 330 is a hierarchical tree control that graphically displays the current trace information for the execution thread indicated in the thread caption bar 320 .
- the trace tree 330 displays, in a hierarchical tree graph, the sequence of function calls and returns (the dynamic call tree) in the executable programs (collectively the client 102 ) listed in the executable pane 314 .
- FIG. 3 illustrates a single thread header and thread tree combination (the items 320 and 330 ). However, multiple thread captions and thread tree combinations will be displayed when there are context switches between multiple threads or processes.
- the executable pane 314 displays an “executable” listbox 361 .
- Each line in the executable listbox 361 displays information about an executable image that is currently being traced.
- Each line in the list box 361 displays a filename field 360 , a process id (PID) field 362 , and a status field 364 .
- Typical values for the status field 364 include “running,” “inactive,” and “exited.”
- the trace detail pane 316 contains a trace detail tree 350 , which that is preferably implemented as a conventional hierarchical tree control.
- the trace detail tree 350 displays attributes, variables such as arguments in a function call window, and function return values of a function selected in the trace tree 330 .
- the source pane 318 displays a source listing of one of the files listed in the source listbox 361 .
- the source listing displayed in the source pane 318 corresponds to the source code of the function selected in the trace tree 330 or to the selected source line.
- the source code is automatically scrolled to the location of the selected function.
- the frame window 300 also contains a title bar which displays the name of the analyzer 106 and a file name of a log or Trace Control Information (TCI) file that is currently open. If the current file has not yet been saved, the string “-New” is concatenated to the file name display.
- TCI Trace Control Information
- the status bar 312 displays the status of the analyzer 106 (e.g. Ready), the source code file containing the source code listed in the source code pane 318 , and the line and column number of a current line in the source pane 318 .
- the toolbar 306 provides windows tooltips and the buttons listed in Table 1.
- FIG. 3B shows a typical frame window 300 with multiple threads in the trace tree pane 310 .
- FIG. 3B shows a separate trace tree for each thread and a thread caption bar (similar to the thread caption bar 320 shown in FIG. 3A) for each thread.
- the TCI file 120 specifies one or more clients 102 and the specific elements (functions, processes and so on) to be traced either in online or remote mode.
- the TCI information is specified in a trace options window (described in the text associated with FIG. 5 ).
- the TCI file 120 is used to save trace control information so that the same trace options can be used at a later time and to send trace control information to a user 110 to trace the client 102 .
- the subsections that follow provide a general overview of selecting trace information for a TCI file 120 and descriptions of various trace options, different ways to access the trace options, and how to use the trace options to specify elements to be traced.
- the TCI file 120 for a client 102 is interactively generated by the software developer 112 using the analyzer 106 .
- the analyzer 106 displays the source structure (modules, directories, source files, C++ classes, functions, etc.) of the client 102 using the source code debug information 121 generated by the compiler during compilation of the client 102 .
- debug information 121 may be in an open format (as with a COFF structure), or proprietary format (such as the Microsoft PDB format), and can be accessed using an appropriate application program interface (API).
- API application program interface
- the developer 112 selects the functions and source code lines to be traced. This information is then translated into addresses and instructions that are recorded within the TCI file.
- trace points may be added to the memory image of the client 102 by scanning the image's object code “on the fly” for specific types of object code instructions to be replaced.
- Trace control information is defined for a specific client 102 .
- the developer 112 In order to access the trace tool, the developer 112 first adds the desired programs 110 to the list of executables shown in the executable pane 314 shown in FIG. 3 .
- the executable is preferably compiled in a manner such that debug information is available. In many development environments, debug information may be included in an optimized “release” build such that creation of the debug information does not affect the optimization.
- the debug information is stored in a PDB file. If during an attempt to add the executable to the Executable pane 314 a PDB file is not found by the analyzer 106 , the developer 112 is prompted to specify the location of the PDB file. Once an executable has been added to the Executable pane 314 , the developer 112 can set the trace control information using the available trace options described below.
- the developer selects an executable file to run as the client 102 .
- the developer 112 double-clicks the ⁇ New Executable> text 365 in the executable pane 314 to open a file selection window thus allowing the developer 112 to select the required executable.
- the developer 112 can click the Run button on the toolbar 306 , or select the Run option from the “Executable” menu after selecting the ⁇ New Executable> text.
- the file selection window provides a command line arguments text box to allow the developer 112 to specify command line arguments for the selected executable file.
- a trace options window (as described below in connection with FIG. 5.) is displayed which allows the developer 112 to specify which functions to trace.
- the executable starts running and BugTrapper starts tracing.
- trace data is collected and the trace data are immediately displayed in the analyzer frame window 300 as shown in FIG. 3 .
- a process list window 400 is displayed, as shown in FIG. 4 .
- the process list window 400 displays either an applications list 402 or a process list (not shown).
- an application is a process that is attached to a top level window.
- the applications list 402 displays a list of all of the applications that are currently running.
- the process list window 400 also provides a process list, which is a list of the processes that are currently running.
- the applications list 402 is selected for display by an applications list tab and the process list is selected for display by pressing the applications list tab.
- the developer 112 clicks the Applications tab or the Processes tab as required, and then selects the application or process to be traced.
- the process list window 400 also provides a refresh button to refresh the application list and the process list, and an OK button to close the process list window 400 .
- the analyzer 106 displays a trace options window 500 , as shown in FIG. 6 below.
- the application or process selected in the process list window 400 becomes the client 102 .
- the analyzer 106 can display trace data for multiple processes and applications (multiple clients); however, for the sake of simplicity, the operation of the analyzer 106 is described below primarily in terms of a single client 102 .
- the trace options window 500 allows the developer 112 to select the functions to be traced. Selecting trace options is described below in the text in connection with FIG. 5 .
- the client-side trace library 125 After selecting trace options and closing the trace options window 500 , the client-side trace library 125 is attached to the client 102 , and the client 102 continues to run. The client-side trace library 125 thereafter collects trace information that reflects the execution of the client 102 and sends the trace information to the analyzer 106 for display.
- the developer can also add an executable file (e.g. a windows .exe file) to the executable pane 314 without actually running the executable file.
- an executable file e.g. a windows .exe file
- the developer 112 selects the ⁇ New Executable> text 365 and then clicks the Add button on the toolbar 306 , whereupon a file selection window is displayed.
- the developer 112 uses the file selection window to select the desired executable and closes the file selection window.
- the file selection window provides a text field to allow the developer to enter command line arguments for the executable.
- the trace options window 500 is displayed which enables the developer 112 to select the functions to trace.
- the selected executable is inserted into the Executable pane 314 with the status “Inactive.”
- the developer can then begin a trace on the inactive executable by selecting the executable in the executable pane 314 and clicking the “Run” or “Attach” buttons on the toolbar 306 .
- the developer 112 can only create a new TCI file 120 when the executable list 361 contains the names of one or more executable files.
- the developer 112 selects “Save” from the “File” menu.
- the developer can also open a previously saved TCI file 120 and then modify the TCI file 120 using the trace options window 500 .
- the developer 112 can select an executable from the executable pane and click the “Run” or “Attach” button from the toolbar to start tracing.
- FIG. 5 illustrates the trace options window 500 .
- the trace options window 500 is divided into two panes, a filter tree pane 501 and a source code pane 504 .
- the filter tree pane 501 is a multi-page pane having four pages: a file page 602 which is selected by a file tab 510 ; a class page 702 which is selected by a class tab 512 ; a name page 502 which is selected by a name tab 514 ; and a process page 802 which is selected by a process tab 516 .
- the name page 502 is shown in FIG. 5 .
- the file page 602 is shown in FIG. 6, the class page 702 is shown in FIG. 7, and the process page 802 is shown in FIG. 8 .
- the trace options window also provides an “advanced” button 520 and an “add DLL” button 522 .
- the trace options window 500 allows the developer 112 to specify which functions to trace and what to display in the trace tree 330 .
- the trace options window 502 allows the developer 112 to filter out functions which have already been traced. These functions will be redisplayed where they were traced if they are later re-select for tracing. If a function is not selected for tracing in the trace options window 500 , it will not be displayed in the trace tree 330 . If a function that was not traced is filtered in again, it will not appear in that portion of the information that has already been displayed.
- Step 4 depicts the elements that are displayed in the trace window, with the symbol ⁇ ⁇ ⁇ representing a tear in the trace as described below in connection with FIG. 12 .
- the process tab 516 corresponding to the process page 802 , is not displayed prior to activating a process.
- Each of the four pages in the filter tree pane 501 displays a tree that the developer 112 can use to select the functions to be traced and analyzed.
- the source code pane 504 displays a source code fragment that contains the source code for the selected function and enables the developer 112 to select the specific source lines to be traced.
- Each line of executable source in the source code pane 504 is provided with a check box displayed along the left edge of the pane 504 . The developer 112 checks the box to select the corresponding source line for tracing.
- the “advanced” button 520 opens a window which allows the developer 112 to specify which elements to display during the trace (e.g. arguments, pointers, “this” class members and return values) and the maximum string length to be traced.
- the add DLL button 522 opens a window which allows the developer 112 to specify DLL files to be traced. This is useful when a DLL is loaded dynamically, as described below.
- the developer 112 uses the filter tree pane 501 to select functions to be traced.
- Four page selection tabs at the top of the filter tree pane 501 enable the developer 112 to view the functions classified (sorted) according to file (on the file page 602 ), class (on the class page 702 ), name (on the name page 502 ) or process (on the process page 802 ).
- the way the functions are organized is different for each classification tab.
- the tree structure that is displayed in each of the four pages operates in the same way, even though the data elements in the tree are different for each page.
- the following discussion relating to the filter tree applies to any of the four pages of the filter tree pane 502 .
- the filter tree is a tree of function names with check boxes to the left of each name. Function check boxes appear blank, checked or dimmed as follows:
- the developer 112 uses the check boxes to selected the functions to trace and then closes the trace options window by clicking an OK button.
- the file page 602 shown in FIG. 6, provides a hierarchical tree that lists the objects according to their hierarchical level in the following order:
- the source file structure is taken from the debug information (e.g., .PDB) files 121 for the client 102 . If the full path name of the source file is not contained in the .PDB file, then the functions contained in that source file are located in a separate branch of the trace tree 330 under the title ⁇ Unknown Directory>. Functions that are included in the .PDB file, but whose source file is unknown, are located in a separate branch of the trace tree 330 under the title ⁇ Unknown Source File>.
- debug information e.g., .PDB
- the class page 702 provides a hierarchical tree that lists the trace objects sorted by class, ignoring their distribution amongst source files. Functions, which do not belong to a specific class are located in a separate branch of the trace tree 330 under the title ⁇ Functions>.
- the name page 502 shown in FIG. 5, provides a hierarchical tree that lists functions sorted alphabetically by name. Leading underscores and class names for methods are ignored.
- the process page 802 shown in FIG. 8, provides a hierarchical tree that displays each process that has been selected for tracing. Under each process is a list of the threads for that process.
- DLL files that are not linked with the executable but rather are loaded dynamically are not shown by default in the trace options window 500 .
- the dynamically loaded DLL file should be added to the list of DLL files using the Add DLL button 522 in the Trace Options window 500 . Clicking the add DLL button 522 displays a file selection window. Using the file selection window, the developer 112 then selects the required DLL file. The selected DLL file is added to the filter tree in the filter tree pane 502 of the trace options window 500 .
- the BugTrapper can also trace DLL files loaded by an executable, even when the executable does not contain debug information. For example, if the developer 112 writes a DLL file as an add-on (e.g., an ActiveX control) to a commercial program (e.g. Microsoft Internet Explorer), the developer 112 can activate BugTrapper on the commercial program and perform a trace on the add-on.
- an add-on e.g., an ActiveX control
- a commercial program e.g. Microsoft Internet Explorer
- the BugTrapper also allows the developer 112 to specify various function attributes to be displayed in the trace detail pane 316 of the analyzer frame window 300 , (shown in FIG. 3) while performing a trace.
- the developer 112 can choose to display arguments, pointers, “this” class members and return values.
- a “this” class member is a class member that is referenced by the C++ “this” pointer.
- the developer 112 can also specify the maximum string length to be displayed. Selecting more options generally reduces the number of records in the trace log file and thus reduces the amount of execution time that is logged.
- the discussion below regarding the cyclic trace buffer provides further details of how much execution time is actually logged.
- the advanced button provides access to an advanced options window (not shown).
- Selecting the arguments checkbox causes function arguments to be displayed in the trace detail pane 316 .
- Selecting the “pointers” checkbox causes data to which a first level function argument of the pointer type points to be displayed. In other words, selecting the pointers checkbox causes function arguments that are pointers to be de-referenced for the display.
- the developer 112 may select the “this” checkbox to have “this” to have all members in a class displayed in the trace detail pane 316 when there is a call to a method which has a this pointer.
- the developer 112 may select the return checkbox to have function return values displayed in the trace detail pane 316 .
- the BugTrapper also allows the developer 112 to control tracing of specific source lines.
- a checkbox is located to the left of each executable source line, which can be traced.
- the developer 112 selects the required function in the filter tree pane 502 and the analyzer 106 displays the appropriate source code fragment in the source code pane 504 . If analyzer cannot locate the source code, then the source code is not displayed and the developer 112 may press the spacebar or right-click in the source code pane 504 and select a “Source Location” command from a pop-up menu.
- the “Source Location” command opens a dialog box which allows the developer 112 to specify a source code file to be displayed in the source code pane 504 .
- the appropriate source code is then displayed in the source code pane 504 , as shown in FIG. 5 .
- the developer clicks the check boxes corresponding to the desired lines.
- the developer 112 can either press CTRL+A to select the whole source code file, or drag the mouse along several lines and thereby select a group of lines. The developer 112 can then click on any checkbox in the selected area to check all the selected lines or click on a checkbox that is already checked to deselect all selected the lines. If lines of code in a file are selected for tracing, then the filename is displayed in blue.
- the developer 112 may also select which variables (e.g., local variables, global variables, static variables, etc.) should be traced for each traced line.
- TCE Extended Trace Control Information
- the TCE file is identified by a .TCE extension.
- the developer may save a TCI file 120 by clicking the save button on the toolbar 306 , whereupon the trace control information is saved.
- the first time that information is saved to a new TCI file 120 a file selection window appears.
- the developer 112 may select the type of file (TCI or TCE) in a “Save as” type box.
- the TCI file 120 can be used to trace a local client 102 at a later time, or it can be sent to a user 110 for use with the agent 104 to trace a client 102 at a remote site.
- the developer 112 sends the user 110 a self-extracting zip file that contains the agent 104 and the TCI file 120 .
- the agent 104 is an executable module which the developer 112 can provide to a user 110 along with a Trace Control Information (TCI) file in order to trace a client 102 .
- TCI Trace Control Information
- the developer 112 uses the analyzer 106 to view the contents of the trace log file and analyze the trace information in the log file 122 . Trace analysis using the analyzer 106 is discussed in subsequent sections of this disclosure.
- the present section discusses the procedures for starting the agent 104 , including the first step performed by the user 110 to run the agent 104 .
- the present section also discloses techniques for selecting the TCI file 120 , specifying a directory for the trace log file 122 , specifying the client 102 , and, finally, using the agent 104 to control the logging of trace data.
- the agent 104 is an easy-to-run standalone application, with step-by-step instructions provided on the screen. To trace an application, the user 102 needs both the agent 104 and the TCI file 120 .
- the TCI file 120 is prepared, as described above, by the developer 112 and contains information about the client 102 and the specific functions to be traced.
- the developer supplies the agent 104 as a self extracting zip file that can be installed by simply double clicking on the zip file name.
- the user 110 can launch the agent 102 .
- the agent 102 displays a TCI select window (not shown) which is a conventional file select dialog that allows the user to select the TCI file 120 .
- the agent 104 provides a log file window, which allows the user 110 to select a directory for the log file 122 .
- the default log file is the last log file that was opened by the agent 104 .
- the next step in using the agent 104 is to specify the client 102 executable(s) to trace.
- an attach to running processes window (running window) 900 is displayed, as shown in FIG. 9 .
- the running window 900 provides a finish button 902 , a cancel button 904 , a back button 906 , and a list of processes 908 .
- the list of processes 908 shows any currently running processes that are specified in the TCI file 120 .
- the list of processes 908 shows all processes that are specified in the TCI file 120 that are not currently running as disabled (grayed).
- the running window 900 allows the user 102 to select a currently running process to trace by selecting items in the list 908 .
- the user 110 will deselect any executables that are to be re-run from the start (that is, when the user does not want to attach to an executable that is already running).
- the user 110 selects a process from the list 908 , and then presses the finish button 902 to cause the BugTrapper to attach to the client processes and starts to collect trace data.
- a start processes window (start window) 1000 is displayed, as shown in FIG. 10 ,.
- the start window 1000 provides a finish button 1002 , a cancel button 1004 , a back button 1006 , and a list of executable files 1010 .
- the start window 1000 also provides a path field 1012 , a parameters field 1014 , and a directory field 1016 .
- the list of files 1010 shows any currently running processes that are specified in the TCI file.
- the start window 1000 allows the user to specify executables that are not currently running to be traced.
- the agent 104 will run the selected client(s) 102 and trace them according to the information in the TCI file 120 .
- the file list 1010 displays the executables, which are listed in the TCI file. Each item in the file list 1010 is provided with a check box. To specify the executables to run, the user 102 checks the boxes for the desired executables in the file list 1010 . If the file path in the file list 1010 is not correct, then the user may enter the correct file path in the path field 1012 . The user 110 may also add command line arguments in the parameters field 1014 . The file path and command line steps may be repeated as needed to specify the file path and commands for additional executables. When the finish button 1002 is clicked, an agent window (described below) is displayed and the agent 104 runs the specified executables, attaches to the executable processes, and starts tracing.
- an agent window (described below) is displayed and the agent 104 runs the specified executables, attaches to the executable processes, and starts tracing.
- the agent window (not shown) is displayed by the agent 104 .
- the agent window displays the names of the TCI file and the log file.
- the agent window also contains an animated icon whose movement indicates whether trace data is currently being collected while the client 102 is running.
- the agent window also contains: a “Start/Stop” button to start or stop the trace; a “Clear” button to clear the trace buffer 105 , a “Dump” button to save the contents of trace buffer 105 to the log file; and an “Exit” button to exit the agent 104 .
- the “Stop/Start” button allows the user 110 to stop and restart tracing when desired. Stopping the trace may improve system performance.
- the “Start/Stop” button toggles between Stop and Start according to the tracing status. The animated icon moves when tracing is in progress.
- the “Clear” button allows the user 110 to clear the trace buffer 105 . The cleared information is not stored in the log file 122 unless the user first uses the dump button.
- the dump button allows the user 110 to save the contents of the trace buffer 105 to the log file 122 . On the first save after a new process had been started, the agent 104 overwrites the old log file 122 (if one exists). On subsequent saves, new information will be appended to the existing log file 122 .
- Clicking the exit button causes the agent 104 to exit.
- the trace buffer is written to the log file. Note that the trace information is written to the log file when either dump or exit is clicked and also when the traced application crashes or terminates.
- the user 110 will preferably use the dump button frequently if it appears likely that the entire operating system may crash.
- the user may select to write every trace line to the disk as it is traced, or, the user may select to write trace lines periodically every N seconds. Such writing is useful, for example, when it appears likely that the entire operating system may crash.
- the analyzer 106 is used to analyze a trace, either online as an application runs or off-line using a remote trace log.
- the general topics that fall under the rubric of trace analysis include, starting an online trace, opening a previously saved trace log file, viewing trace information, interpreting the trace information, working with trace information, and additional trace functions that are available when performing an online trace.
- the BugTrapper allows the developer 112 to trace a client 102 executable in order to pinpoint an element in the client 102 code that causes a bug.
- the primary device for displaying trace information in the analyzer 106 is the trace tree 330 in the trace tree pane 310 shown in FIG. 3 .
- the trace control information (TCI) filters can be modified during trace analysis to filter out some of the available trace data according to the needs of the developer 112 .
- Analysis of a remote trace is started by opening a previously saved trace log file and displaying the trace information that it contains in the trace tree pane 310 .
- the log file 122 may either have been created by saving trace information using the analyzer 106 , or the log file 122 may have been created at a remote location using the agent 104 .
- a trace log file 122 is opened by using an “Open Log” command from the “File” pull down menu found on the menu bar 304 . Once a trace log file 122 is open, the title bar 302 displays the name and path of the opened log file 122 . Once a trace log file 122 is open, the developer can view the trace information using various panes in the analyzer frame window 300 . Trace information is displayed in the trace tree pane 310 , the trace detail pane 316 , and the source pane 318 .
- the trace tree 330 in the trace tree pane 310 , is a hierarchical tree showing trace data collected from the client 102 .
- Trace data includes information about events that took place during execution of the client 102 , including function calls, function returns, selected source lines, etc.
- the developer 112 can use the mouse to choose any function from the trace tree, whereupon the arguments and return values for the chosen function are shown in the trace detail pane 316 , and the source for the chosen function is displayed in the source pane 318 .
- the types of trace information displayed for both online traces and a trace from log files is almost identical, however the log file trace provides a static display, while the online trace is dynamic and can be viewed as the trace information is being collected.
- the trace tree 330 displays a hierarchical tree of the sequence of function calls and returns in the client 102 .
- the number of lines in the trace tree is shown in the trace tree pane title bar 308 .
- the trace tree 330 is organized in a standard tree structure and the developer 112 can click on the tree control buttons to collapse or expand the view of functions belonging to lower hierarchical levels. Clicking on a function or a source line in the trace tree pane 310 causes the trace detail pane 316 and the source pane 318 to change to display information relevant to the function. Selecting a function in the trace tree 330 and pressing the delete button on the keyboard removes the selected function from the trace. This is equivalent to filtering the function out of the trace.
- the trace data is written to a buffer in memory called the trace buffer 105 , and from there either displayed in the trace tree pane 310 (when performing an online trace) or written to a log file (when performing a remote trace).
- the trace buffer 105 is organized as a circular buffer of fixed size. The size of the trace buffer 105 can be set by the developer 112 . When the trace buffer 105 is full, new trace records overwrite the oldest records contained in the buffer 105 .
- the trace information could be stored in a buffer, which simply added trace records without overwriting old records.
- loss of old data is acceptable because, when the client 102 malfunctions, the developer 112 is usually interested in the most recent records prior to the malfunction. Thus, there is usually little need to keep all of the records, especially the oldest ones.
- the size of the trace buffer 105 is set so that it will be big enough to hold a large number of records without consuming too many system resources. Typically, 20,000 to 40,000 records are kept.
- the trace records are preferably appended to the end of the log file 122 .
- old records are not deleted, and the trace size is limited only by the available disk space.
- the trace tree is actually an image of the trace buffer 105 . Because of this, the trace tree will not display more records than the trace buffer 105 contains, so old records are deleted (“scrolled out” of the display).
- the rows counter at the top of the trace tree pane 310 indicates the number of records in the trace buffer 105 and the number of rows in the trace tree. Because the buffer 105 is circular, the number of rows in the trace tree 330 continuously grows during the beginning of the tracing process until the buffer wraps (typically 20,000 to 40,000 records). Thereafter, the number remains approximately at the same level as old records are overwritten with new records.
- the exact number of records that are kept in the trace buffer 105 depends on the size of the trace records.
- the size of each trace record is determined by the TCI options specified by the developer 112 . For example, if the developer 112 requires tracing of “this” class members, the size of the records will increase and the number of records in the buffer will decrease.
- the analyzer 106 and the agent 104 can trace a multi-threaded and multi-processed client 102 .
- a thread caption bar 320 For multi-process applications, similar horizontal bars, called process caption bars (not shown), separate trace lines belonging to different processes.
- the thread caption bar 320 and the process caption bar separate the trace tree 330 into sections. These caption bars represent a context switch in the application, between threads and between processes. Process caption bars are similar to the thread caption bar 320 , therefore any future mention of threads also applies to processes in multi-process applications.
- the thread caption bar 320 contains a name field, a process ID number field, and a thread ID number field 321 .
- the trace tree 330 itself, there is an up arrow at the top of each section, and a down arrow at the bottom of each section. Clicking the up arrow causes the displayed trace tree 330 to jump to the previous point in the trace tree 330 where the thread gained control. Clicking the down arrow causes the displayed trace tree 330 to jump to the next point in the trace tree 330 where the thread gains control.
- the trace tree 330 also provides an expand/collapse control button 326 to allow the developer 112 to expand and collapse the current thread view.
- the trace tree pane 310 also provides a vertical scroll bar for scrolling up and down through the trace tree 330 .
- the trace tree pane 310 When the trace tree pane 310 is scrolled up or down to a section containing functions of lower hierarchical levels, the portion of the trace tree 330 displayed in the window is shifted leftwards.
- the depth of this shift, with respect to the first function called in the process, is indicated by a stack level indicator 328 appearing in a rectangle in the upper left corner under the thread caption bar 320 (as shown in FIG. 3 ).
- the trace detail pane 316 shows available details describing the function selected in the trace tree view.
- FIG. 11 shows a trace detail pane 1116 that displays a C++ class having several members and methods, a class derived from another classes, and classes as members of a class.
- the trace details are displayed in a trace detail tree 350 which is a hierarchical tree structure.
- a right arrow 351 in the trace detail pane 316 marks where the function is called.
- a left arrow at the bottom of the detail tree 350 marks where the function returned to its caller.
- an argument in the call window of a function is of the aggregate type, the argument's components will be displayed beneath the right arrow 351 in the form of a hierarchy tree. If an argument is of the pointer type, and pointers were selected in the advanced trace options, then the value displayed in the trace detail tree 350 will be that of the data to which the pointer points. However, for pointer fields that reside within arguments, only the address contained in the pointer will be displayed. In other words, in the preferred embodiment, the pointer is de-referenced only for the first level arguments. One skilled in the art will understand that other pointers could be de-referenced as well, and that the trace detail tree 350 could display the value pointed to by arguments deeper than the first level.
- the trace detail pane 316 also shows time stamps.
- the time stamps display the time that a function is called and the time that the function returns to its caller.
- the arguments are an array of known size, then the elements of the array will be displayed. If the array size is unknown, then the value displayed is the value of the first array element. If the argument is of character pointer type, then the string value is displayed. If the argument is numeric, then the decimal, hex, or decimal and hex values are displayed, depending on the selection made in the advanced trace options. Right-clicking the mouse when it points in the trace detail pane 316 displays a popup menu which allows the developer 112 to select how numeric arguments are displayed (as decimal, hex, or decimal and hex values).
- the source pane 318 shows the source code for the selected function or source line selected in the trace tree 330 .
- the source code listed in the source pane 318 is automatically scrolled to the location of the selected object, if possible.
- the line in the source code is displayed in bold and is pointed to by an arrow.
- the analyzer 106 looks for the source file in the current directory and in the directory indicated in the .PDB file. If the source file is not found, the source pane remains blank.
- the developer 112 can change the source file search path in order to display the source code. To change the source file path the developer should select a function in the trace tree 330 , then right-click in the source pane to open a pop-up menu, and then select the “Source Location” from the pop-up menu.
- the developer 112 can add additional source directories and remove source directories by selecting the “Options” command from the “View” menu on the menu bar 304 .
- Source file paths can also be removed.
- the analyzer 106 provides several features which make it easier to analyze trace information and pinpoint a bug in the client 102 . These features can be used both while performing an online trace and while viewing trace information from a remote log file 122 . Analysis features include: saving trace information to a log file 122 ; printing the trace tree 350 ; searching for trace elements; locating a function in the trace options window 500 ; filtering the trace information; adding, editing, deleting and locating bookmarks; clearing the trace tree pane; and displaying multiple windows. Additional features available for online tracing include saving trace information to the log file 122 .
- the “Find” button on the toolbar 306 is used to initiate a search for an element in the trace tree 330 .
- Clicking the Find button opens a “Find what” dialog box in which the developer 112 can enter a search text string.
- the find what dialog provides a “Find Next” button to start a search for the occurrence of the specified search text.
- the first occurrence of the specified text is highlighted in the relevant pane.
- Functions in the source code displayed in source pane 318 can be located in the trace options dialog 500 by right-clicking inside the source code in the source pane 318 .
- the right-click opens a pop-up menu.
- the developer selects a “Locate in Trace Options” command from the pop-up menu to open the trace options window 500 .
- the trace options window 500 will open with the desired function displayed and highlighted.
- the trace filter previously described in the text relating to FIG. 5 is a tool that enables the developer 112 to select the functions to trace.
- the trace continues in the background, and when the developer 112 closes the trace options window 500 the new filter is applied to the display in the trace window 300 .
- the developer 112 can also use the trace options window 500 to change the display while performing an off-line trace. This enables the developer 112 to filter out traced elements and display a subset of the traced information.
- the information contained in the log file is not modified, only the display changes.
- a bookmark allows the developer 112 to mark trace lines (functions or source lines) in the trace tree 330 .
- the developer 112 can also edit the name of a bookmark or delete the bookmark it as required.
- Bookmarks are inserted in the trace tree 330 by using the bookmark button on the toolbar 306 . Bookmarks allow easy jumps to the bookmarked element.
- the developer will: select the trace line (a function or source line in the trace tree 330 ) to mark; press the bookmark button to open the bookmark window; type the bookmark name in the bookmark widow; and click the OK button.
- a waiving flag icon 332 appears on the left of the bookmarked trace line in the trace tree 330 .
- the bookmark name is displayed whenever the cursor is placed over the bookmarked line.
- the developer 112 repeats the steps to create a bookmark.
- the developer 112 can press a delete button on the bookmark window.
- the “Goto Bookmark” command from the “Edit” menu is used to go to a bookmark in the trace tree 330 .
- Each instance of the analyzer 106 can be open simultaneously. Each instance can define different filter options for each window. This feature is especially useful for multi-threaded applications, where it is convenient to observe each thread in a separate window.
- the analyzer 106 provides for starting and stopping of an online trace. All trace points are disabled when tracing is stopped. Stop is helpful if the trace adversely influences the application performance and it appears that the subsequent operations in the client 102 are not relevant to the problem being analyzed.
- the Start/Stop Tracing button on the toolbar 306 is used to toggle tracing on and off. Tracing is stopped or restarted as specified. When tracing is stopped, the boundaries of the lost tree portion appear in the trace tree pane 330 as a tear 1202 , as shown in FIG. 12 . When tracing is resumed, the trace tree 330 continues under the tear 1202 .
- the sections that follow discuss various internal operational and implementation details of the agent 104 , the analyzer 106 , the trace libraries 124 , 125 , and how these elements interact with the client 102 and the operating system.
- One aspect of the present invention is the attaching mechanism used by the BugTrapper to collect trace information.
- tracing is accomplished by attaching to the memory image of the application (i.e., the copy of the executable code that is loaded into RAM or other memory for execution).
- the memory image of the application i.e., the copy of the executable code that is loaded into RAM or other memory for execution.
- Attaching to the client 102 in memory allows function calls, returns, and other source lines to be traced.
- the attaching mechanism also allows for the tracing of any executable, including optimized (release) builds, multi-threading and multi-processes, longjumps, signals, exceptions, and recursions.
- the BugTrapper client-side trace library 125 is attached to the client 102 , in part, by modifying certain executable instructions of the memory image of the client 102 .
- This process is generally called “executable code instrumentation,” or simply “instrumentation.”
- the instrumentation process is performed such that the functionality of the client 102 is preserved. Because the instrumentation is made only on the memory image, there is no need to pre-process or modify the source code or executable files of the client 102 .
- Use of the client-side trace library 125 provides significant advantages over the prior art by eliminating the need for context switches when debugging a program. Context switching has the effect of significantly slowing down the rate of execution.
- the tracing implementation provided by BugTrapper can therefore be used to study the real time behavior of a program and detect bugs resulting from such behavior.
- a preferred embodiment runs under the Windows-NT and Windows-95 operating systems supplied by Microsoft Inc. The following description of the internal details of the BugTrapper will thus be described in terms of the Windows-NT/95 operating systems with the understanding that the invention is not limited to said systems.
- the trace libraries 124 , 125 include a number of callable functions (discussed below). By using the callable functions, and system functions provided by the Win32 API (application program interface), the trace libraries performs two major tasks: (1) attaching specialty functions to application, and (2) tracing the execution of the application's executable code. Both of these tasks are described separately below.
- the agent-side trace library 124 is primarily responsible for attaching the client-side trace library 125 to the client 102 .
- the agent-side trace library 124 also provides communication with the client-side library 125 .
- the client-side trace library 125 is primarily responsible for placing data in the trace buffer 105 .
- client process is used to refer to the executable code of the client 102 that has been loaded into a memory space for execution.
- BugTrapper refers both to BugTrapper Agent or BugTrapper Analyzer, depending whether it is operating in the Online mode or the Remote mode.
- the act of attaching to a currently running process is known as a Process Attach.
- the act of attaching to a new process, during the creation of the new process, in order to trace the new process from its start is known as a Creation Attach.
- a Creation Attach it is desirable to pause the client 102 process as close as possible to its entry point so that virtually all of the functions executed by the client 102 will be traced.
- each process resides at a distinct location or “address space” in memory.
- a DLL such as the client-side trace library 125 , which resides in another address space, cannot simply be loaded into the same address space as the client process.
- BugTrapper forces the client process to load the client-side trace library 125 DLL (using a process called injection) into the process space of the client process.
- the injection process for Process Attach in Windows-NT is accomplished by using the CreateRemoteThread( ) function of the Win32 API, to create a remote thread in the client process and to force the newly created thread to run code in the client process.
- the code that is run by the remote thread is a copy of an injection function copied to the remote thread using the Win32 API WriteProcessMemory( ) function.
- the Process Attach involves the following sequence of events shown in FIG. 13 beginning with a procedure block 1302 where the function inst_attache of the tracing library is called in BugTrapper, using the process ID (“PID”) of the client (client) process as an argument.
- the function inst_attach( ) performs the following operations:
- the new thread created in step 4 starts executing at the address to which the injection function was previously copied in step 3.
- the procedure then advances from the procedure block 1302 to a procedure block 1304 where the injection function starts running in the new thread of the client process.
- the injection function loads the client-side trace library 125 .
- the procedure advances from the procedure block 1304 to a procedure block 1306 where the client-side trace library 125 runs in the context of the new thread while the instrumentation is taking place.
- the client-side trace library 125 communicates with BugTrapper (i.e., the agent-side trace library 124 ), handling commands, and actually performing the instrumentation.
- BugTrapper i.e., the agent-side trace library 124
- the procedure advances from the procedure block 1306 to a procedure block 1308 where the client-side trace library 125 exits, and the injection function destroys its own thread and stops executing by calling the ExitThread( ) function.
- the client 102 continues to run, without any substantial alteration to the functionality of the client 102 .
- Creation Attach is accomplished under Windows-NT by creating the client process in a suspended state, by using the CREATE_SUSPENDED flag in the CreateProcess( ) function.
- the previously described procedure cannot be used, since none of the system DLLs in the client process have been initialized.
- KERNEL32.DLL is not loaded, the client-side trace library 125 cannot be loaded.
- the present attaching procedure overcomes this difficulty by performing the following attaching procedure, which begins at a procedure block 1402 shown in FIG. 14 .
- the attaching procedure begins in block 1402 , in which the client process is created in a CREATE_SUSPENDED state.
- the attaching procedure then advances to a procedure block 1404 .
- BugTrapper makes a call to the inst_prepare( ) of the agent-side trace library 124 .
- the inst_prepare function using WriteProcessMemory( ) and VirtualAllocEx( ), allocates memory in the client process and copies a small assembly language code segment into the allocated space.
- the procedure then proceeds to a procedure block 1406 where the inst_prepare function overwrites the entry point of the client executable in the client process with a jump instruction to the new assembly code.
- the attaching procedure then advances to a procedure block 1408 wherein the inst_prepare function allows the client process to resume, and thereby start the initialization process for the client process.
- execution continues to the entry point of the client executable, which now contains a jump to the new assembly code.
- the attaching procedure advances from the procedure block 1408 to a procedure block 1410 .
- the assembly code restores the original client entry point, and suspends the client process. At this point, the client process is suspended without running any executable code, but is past the initialization stage.
- the attaching procedure then advances to a procedure block 1412 .
- BugTrapper can now call inst_attach( ) to attach to the client process and start instrumenting it.
- the attaching procedure can allow the client process to resume.
- the assembly code simply jumps directly back to the original entry point of the client 102 , and execution of the client 102 starts with the proper instrumentation.
- the patch removes the patch applied on the kernel32.dll entry point and restores the original kernel32.dll code.
- the injection function loads the client-side trace library 125 .
- the injection function initializes the client-side trace library 125 and the communication channel in the client process so that the two trace libraries 124 , 125 can communicate.
- BugTrapper calls the inst 95_attach_to_running_process function in the agent-side trace library 124.
- the inst 95_attach_to_running_process function executes the following sequence of operations:
- create_remote_thread (not to be confused with the CreateRemoteThread API call in Windows-NT), that performs the following operations:
- a device driver intercepts the INT 1 interrupt that is caused by the first executed instruction of the above mentioned valid thread. Upon receiving the interrupt, the device driver sets the instruction pointer to the start address of the injection function that was copied onto the shared heap, and clears the single step flag in the valid thread context. After clearing the single step flag, the driver proceeds as if the interrupt was successfully handled, and returns the control to Windows-95.
- the injection function starts to execute in the context of the client process.
- the injection function continues as in the case of Creation Attach described above and creates a new thread that subsequently performs the loading of the client-side trace library 125 into the address space of the client 102 .
- the injection function executes the breakpoint instruction, which immediately causes an INT 3 interrupt that is intercepted by the device driver.
- the device driver restores the thread context that was stored immediately after the thread was suspended and then the device driver returns the control to Windows-95.
- the trace function involves tracing the execution of the instrumented client process and reporting certain events to BugTrapper.
- the client-side trace library 125 accomplishes the tracing function by using breakpoints, and by reporting information concerning the status of the client process upon reaching the breakpoints.
- the execution trace is stored within a fixed size circular trace buffer 105 in memory.
- the remote mode of operation the contents of the trace buffer 105 are copied to a trace log file 122 .
- the trace log file 122 thus contains trace information that reflects a time window ending with the writing of the log file 122 .
- the length of this time window is generally dependent upon the size of the trace buffer 105 .
- the trace buffer 105 is small enough to allow the trace log file 122 to be sent to the developer's site using standard email programs.
- the display is constantly being updated mirroring the trace buffer 105 . The displayed information can also be saved to a log file 122 and later re-displayed.
- the process of tracing the execution of the client 102 involves the steps of installing breakpoints, triggering breakpoints, and catching breakpoints.
- Breakpoints are installed by overwriting the target address of the assembly instruction to be traced with an INT 3 instruction, occupying a single byte of space.
- the original byte at that address, along with other information, is stored in a data structure created by the agent-side trace library 124 .
- the data structure which describes all trace points, is preferably a hash table comprising a corresponding array of records for each hash value.
- the hashing is implemented with the target address as a parameter, allowing for a very fast searching for information concerning a trace point by using its address.
- Breakpoints are triggered whenever the target address gets executed.
- the breakpoint instruction When the target address is executed, the breakpoint instruction generates an INT 3 interrupt.
- this interrupt On Windows NT this interrupt is handled by the Windows-NT kernel-mode handler.
- the kernel-mode handler transfers the execution to the user-mode routine KiUserExceptionDispatcher inside NTDLL.DLL (the system DLL).
- KiUserExceptionDispatcher routine handles the task of locating a corresponding exception filter for the particular kind of exception.
- the KiUserExceptionDispatcher function When the client-side trace library 125 is initially loaded, a patch is applied to the KiUserExceptionDispatcher function, having the effect of forcing a call to a function in the client-side trace library 125 before processing the exception.
- This function (the BugTrapper exception handler), determines whether the breakpoint occurred as a result of the tracing or for another reason. An exception that is not the result of tracing (i.e., no trace point has been installed at this target address) will result in a return of execution to KiUserExceptionDispatcher.
- the handler When an exception is the result of the tracing, the handler notifies the appropriate routines in the tracing library 125 and defers the breakpoint, thereby allowing the original instruction at the target address to execute.
- the original byte at the target address is restored, returning execution while setting the Single Step flag in the FLAGS register of the x86 processor.
- the Single Step flag causes an INT 1 interrupt to occur as a result of the execution of the original instruction. This interrupt is also treated as an exception, eventually reflecting into the BugTrapper exception handler.
- the handler restores the breakpoint instruction at the target address and returns for second time, allowing the client process code to continue running as if nothing happened.
- interception of the INT3 and INT1 interrupts is done by a device driver.
- the driver registers its interrupt handler for INT1 and INT3 interrupts.
- the interrupt handler checks to see if the interrupt occurred in the context of the client process. If the interrupt occurred in the client process, then the interrupt handler changes the instruction pointer of the thread to the address of a function in the client-side trace library 125 , and passes back on its stack any data needed by the function (such as thread context). After this function handles the trace point, it triggers an additional INT 3 interrupt that is recognized by the device driver.
- the device driver acts as if the interrupt has been successfully handled, causing the traced thread to continue execution.
- the device driver recognizes that an interrupt has occurred not in the context of the client process, then the device driver passes the interrupt to the operating system interrupt handler (thus not affecting the normal behavior of other programs in the system or the operating system itself).
- the client-side trace library 125 When tracing a plain source line (e.g., not a function entry or exit point), the client-side trace library 125 inserts data in the trace buffer to indicate that a trace point has been reached.
- a special mechanism is used because tracing of information regarding both the entry to and exit from the function is desired. This is preferably accomplished by modifying the return address of the function. The return address is located on the stack. The original return address is saved and a new return address point is inserted. The new return address points to a special assembly stub inside the client-side trace library 125 . Therefore, when the function returns the assembly stub is called.
- the stub reports to the client-side trace library 125 function that the function has exited, and the client-side trace library 125 writes this trace point to the trace buffer. The stub then jumps to the real return address of the function.
- a function In certain environments it is possible for a function to be entered but not properly exited. The function ceases running (with its stack erased and execution continuing elsewhere), but never returns to its caller. Therefore, for tracing purposes, it never returned to the BugTrapper assembly stub. For example, this would happen when a C++ exception occurs inside the a function and the exception handler at an outer function instructs the function generating the exception to exit, or when the setjmp( )/longjmp( ) functions are used in C/C++ programs. To detect and trace such events, the microprocessor's stack pointer register (ESP) is checked whenever a trace point triggers to determine whether any functions have exited. The stack pointer normally grows down.
- ESP stack pointer register
- the BugTrapper attaching technology can be used with multi-process and multi-threaded applications. Every trace record is associated with a process and a thread. Stack information is separately kept for each context. Therefore, the BugTrapper can trace two or more client executables at the same time. This allows BugTrapper to display any context switches between the processes and threads of the client(s) 102 .
- the BugTrapper supports the tracing of Dynamically Linked Libraries (DLLs), including all sub-formats such as OCX, Active-X, drivers (DRV), etc.
- DLLs Dynamically Linked Libraries
- the tracing of DLLs is accomplished by analyzing the client 102 process to find the DLLs it uses, and by displaying the source structures of the DLLs to the user. The user can then specify trace points within the DLLs as is done for any other executable.
- BugTrapper finds the base address into which the DLL was loaded, and uses the address to translate the addresses in the debug information to actual addresses in the running image.
- the BugTrapper also supports the tracing of DLLs for which no debug information is available, such as system DLL's.
- the tracing of such DLLs is accomplished by tracking the exported functions used by the DLLs. This is done by analyzing the DLL exported function table in the client 102 to retrieve information concerning the exported function names and addresses. If the types of the parameters passed to these functions are known (e.g., if the header file including the declarations of the functions is available), then the parameter values and return value are also logged.
- the BugTrapper also supports tracing of sub-processes. For example, when a first process P1 and a second process P2 are listed in the executable pane 314 , and P1 spawns P2 as a sub-process, then BugTrapper will start tracing P2. This is done by tracing the CreateProcess function in all of the traced processes, even if the developer 112 did not specify tracing the CreateProcess function. By tracing CreateProcess, BugTrapper will know that P1 is going to spawn a sub-process, and BugTrapper can identify that the sub-process name (P2 in the present example) is listed in the executable pane 314 . the client-side trace library will then create the sub-process and attach to the sub-process using the “Creation Attach” mechanism discussed above.
- Variables and memory values can also be traced by BugTrapper.
- the user can view variable values as in an ordinary debugger.
- the variables may include function arguments, the C++ “this” pointer, function return values, local variables, global variables, static variables, etc.
- the data to which a pointer is pointing can also be traced. This information can be viewed for optimized builds, which cannot always be done by current debuggers. Tracking of variables in memory is accomplished by first analyzing the debug information to find the address (global, static, stack, or dynamic address) of the variable and the data it holds. BugTrapper then uses these addresses to dump to the trace log file 122 the memory content according to variable size.
- BugTrapper records the point where the failure occurred, even if the line was not specified in the TCI file 120 . All stack variables are saved by using the Win32 debug API and the system library IMAGEHLP.DLL.
- Communication between the client-side trace library 125 and the agent-side trace library 124 (in the agent 104 or the analyzer 106 ) can be divided into two categories. Category one comprises normal messages. Category two comprises trace data.
- Normal messages include commands sent to the client-side trace library 125 such as, start trace function at a given address, or suspend tracing. Normal messages also include notifications sent by the client-side trace library 125 , such as creation of a sub-process or run-time loading of a DLL.
- IPC Windows InterProcess Communication
- Trace data itself is sent using a different mechanism, because of the quantity of data.
- Trace data comprises: function calls (including the assembly address of the called function); values of parameters for each call; function return values (including function address); tracing of other source lines specified in the TCI file 120 (including their address); variables value at these addresses; etc.
- the trace records are written to a shared memory area called the trace buffer 105 , and from there either displayed in the BugTrapper user interface by the analyzer 106 (when performing an online trace) or written to a log file by the agent 104 (when performing a remote trace).
- the client-side trace library 125 running in context of the various traced threads and processes, and the agent-side trace library 124 , prevent simultaneous access to the trace buffer using a standard locking mechanism such as Mutex (in Windows-95) or Interlocked Functions (in Windows-NT).
- a standard locking mechanism such as Mutex (in Windows-95) or Interlocked Functions (in Windows-NT).
- the client-side trace library 125 preferably only writes trace data to the trace buffer 125 in shared memory.
- the client-side trace library 125 preferably performs no I/O to the disk or to the display. Disk I/O and display updates are done later by the agent 104 or the analyzer 106 . This reduces the performance penalty imposed on the client 102 .
- the analyzer 106 holds, together with the above-mentioned calls index, a special array SA, where SA[i] contains the number of visible records from record number 1000*i to 1000*(i+1). Use of the SA array greatly speeds up the task of locating desired trace information.
- SA[0] 950 and the appropriate record is 1550.
- the SA array provides for very fast vertical scrolling. The SA array is updated each time a new record is read from the trace buffer 105 or the log file 122 , or when the developer 112 collapses or expands some of the trace tree.
- the analyzer 106 when the analyzer 106 draws a trace tree, it performs the following steps: (1) lock the trace buffer 105 ; (2) scan new records and update the calls index and the SA array; (3) read and analyze the records that must be shown; (4) merge the records with the debug information 121 and create strings for each record; (5) draw the page; and (6) unlock the shared memory trace buffer 105 . Note that when reading data from a trace log file 122 only steps 3-5 are performed, since steps 1, 2, and 6 are unnecessary.
Abstract
Description
TABLE 1 |
Buttons on the |
Menu | |||
Button | Equivalent | Key | Description |
“Open” | File | Open | Ctrl + 0 | Opens an existing Trace Control |
Information file. | |||
“Save” | File | Save | Ctrl + S | Saves the current Trace Control |
Information to a file. | |||
“Clear” | Edit | Clear All | Clears the Trace Tree pane, | |
the Trace Detail pane, and the | |||
Source pane. | |||
“Find” | Edit | Find | Ctrl + F | Finds a specific string in the |
executable source code or trace | |||
tree. | |||
“Bookmark” | Edit | Book- | Adds or deletes a bookmark for | |
mark | the currently selected function, | ||
or edits the name of an | |||
existing bookmark. | |||
“Window” | View | New | Opens a new instance of the | |
Window | analyzer. | ||
“Start/Stop” | Executable | | Starts or stops tracing the execu- | |
Start/Stop | tables listed in the Executable | ||
Trace | pane. | ||
“Add” | Executable | | Ins | Adds an executable to the Exe- |
Add | cutable pane, without running it, | ||
so that it can be run and traced | |||
at a later date. | |||
“Run” | Executable | | F5 | When the <New Executable> |
Run | string is selected, adds an execu- | ||
table to the Executable pane, | |||
starts this executable and | |||
begins tracing. When an execu- | |||
table which is not running is | |||
selected in the Executable | |||
pane, starts this executable and | |||
begins tracing. | |||
“Attach” | Executable | | When the <New Executable> | |
Attach | string is selected, attaches a | ||
running executable to the Execu- | |||
table pane and begins tracing. | |||
When an executable that is not | |||
traced is selected, attaches the | |||
running process of this execu- | |||
table, if it exists. | |||
“Terminate” | Executable | | Terminates the executable | |
Terminate | currently selected in the | ||
Executable pane. | |||
“Options” | Executable | | Opens the Trace Options | |
Trace Options | window in which you can spec- | ||
ify the elements that you want to | |||
trace for the selected executable. | |||
f1 ( ) { } | ||
f2 ( ) { } | ||
main ( ) { |
while (1) { |
getchar (c); | |
f1 ( ); | |
f2 ( ); |
} |
} | ||
Claims (31)
Priority Applications (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US09/126,126 US6282701B1 (en) | 1997-07-31 | 1998-07-30 | System and method for monitoring and analyzing the execution of computer programs |
PCT/US1999/017251 WO2000007100A1 (en) | 1998-07-30 | 1999-07-29 | System and method for remotely analyzing the execution of computer programs |
AU54610/99A AU5461099A (en) | 1998-07-30 | 1999-07-29 | System and method for remotely analyzing the execution of computer programs |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US5516597P | 1997-07-31 | 1997-07-31 | |
US09/126,126 US6282701B1 (en) | 1997-07-31 | 1998-07-30 | System and method for monitoring and analyzing the execution of computer programs |
Publications (1)
Publication Number | Publication Date |
---|---|
US6282701B1 true US6282701B1 (en) | 2001-08-28 |
Family
ID=26733919
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/126,126 Expired - Lifetime US6282701B1 (en) | 1997-07-31 | 1998-07-30 | System and method for monitoring and analyzing the execution of computer programs |
Country Status (1)
Country | Link |
---|---|
US (1) | US6282701B1 (en) |
Cited By (378)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20010034880A1 (en) * | 2000-03-02 | 2001-10-25 | Jonathan Dzoba | Configurable debug system using source and data objects |
US20020023260A1 (en) * | 1997-12-23 | 2002-02-21 | Ab Initio Software Corporation | Method for analyzing capacity of parallel processing systems |
US6378124B1 (en) | 1999-02-22 | 2002-04-23 | International Business Machines Corporation | Debugger thread synchronization control points |
US20020049962A1 (en) * | 2000-10-23 | 2002-04-25 | Michael Kelbaugh | Product testing and bug tracking system |
US20020049801A1 (en) * | 2000-05-19 | 2002-04-25 | International Business Machines Corporation | Remote tracing of data processing nodes in an asynchronous messaging network |
US20020073401A1 (en) * | 2000-12-07 | 2002-06-13 | International Business Machines Corporation | Method of detecting zombie breakpoints |
US20020073400A1 (en) * | 2000-07-26 | 2002-06-13 | Michael Beuten | Method for monitoring a program execution using a debug logic |
US6412106B1 (en) | 1999-06-16 | 2002-06-25 | Intervoice Limited Partnership | Graphical system and method for debugging computer programs |
US20020091974A1 (en) * | 2000-12-18 | 2002-07-11 | Szydlowski Craig P. | Method and apparatus for interfacing application system via the internet |
US6427233B1 (en) * | 1999-12-17 | 2002-07-30 | Inventec Corporation | Method for addressing the dynamic windows |
US6434738B1 (en) * | 1999-04-22 | 2002-08-13 | David Arnow | System and method for testing computer software |
US20020120919A1 (en) * | 2000-12-27 | 2002-08-29 | International Business Machines Corporation | Monitoring execution of an hierarchical visual program such as for debugging a message flow |
US20020120918A1 (en) * | 2000-12-27 | 2002-08-29 | International Business Machines Corporation | Monitoring messages during execution of a message flow |
US20020129339A1 (en) * | 1998-12-23 | 2002-09-12 | Callahan Charles David | Parallelism performance analysis based on execution trace information |
US20020138753A1 (en) * | 1999-05-11 | 2002-09-26 | Munson John C. | Method and system for simplifying the structure of dynamic execution profiles |
US20020174416A1 (en) * | 2001-05-15 | 2002-11-21 | International Business Machines Corporation | Storing and restoring snapshots of a computer process |
US20020178206A1 (en) * | 2001-05-25 | 2002-11-28 | Siemens Medical Solutions Health Services Corporation | System and method for monitoring computer application and resource utilization |
US6493834B1 (en) * | 1999-08-24 | 2002-12-10 | International Business Machines Corporation | Apparatus and method for dynamically defining exception handlers in a debugger |
US6499048B1 (en) | 1998-06-30 | 2002-12-24 | Sun Microsystems, Inc. | Control of multiple computer processes using a mutual exclusion primitive ordering mechanism |
US20030005107A1 (en) * | 2000-02-14 | 2003-01-02 | Adi Dulberg | Support network |
US20030014694A1 (en) * | 2001-07-03 | 2003-01-16 | Francois Draperi | Process monitor module |
WO2003007105A2 (en) * | 2000-11-24 | 2003-01-23 | Catharon Productions, Inc. | Computer multi-tasking via virtual threading |
US6513155B1 (en) * | 1997-12-12 | 2003-01-28 | International Business Machines Corporation | Method and system for merging event-based data and sampled data into postprocessed trace output |
US6526567B1 (en) * | 1999-03-24 | 2003-02-25 | International Business Machines Corporation | System and method for optimizing a device driver by incorporating debugging and tracing |
US20030046664A1 (en) * | 2001-09-04 | 2003-03-06 | James Pangburn | Flexible horizontal stack display and editor |
US20030046667A1 (en) * | 2001-08-30 | 2003-03-06 | International Business Machines Corporation | Method and system for obtaining performance data from software compiled with or without trace hooks |
US20030051194A1 (en) * | 2001-09-13 | 2003-03-13 | International Business Machines Corporation | Portable SCSI bus analyzer |
US20030056200A1 (en) * | 2001-09-19 | 2003-03-20 | Jun Li | Runtime monitoring in component-based systems |
US6539500B1 (en) * | 1999-10-28 | 2003-03-25 | International Business Machines Corporation | System and method for tracing |
US20030061342A1 (en) * | 2001-09-27 | 2003-03-27 | International Business Machines Corporation | Apparatus and method of representing real-time distributed command execution status across distributed systems |
US20030065976A1 (en) * | 2001-10-01 | 2003-04-03 | Bennett David L. | Logic analyzer having a disassembler employing symbol table information for identifying op-codes |
US20030079206A1 (en) * | 2001-10-18 | 2003-04-24 | International Business Machines Corporation | Debugger capable of providing warnings for unreachable breakpoints |
US20030084009A1 (en) * | 2001-10-30 | 2003-05-01 | International Business Machines Corporation | Product support of computer-related products using intelligent agents |
US6587967B1 (en) * | 1999-02-22 | 2003-07-01 | International Business Machines Corporation | Debugger thread monitor |
US20030131337A1 (en) * | 2002-01-07 | 2003-07-10 | Perumainar Asok K. | Educational method and tool for isolating and teaching programming language concepts |
US20030131284A1 (en) * | 2002-01-07 | 2003-07-10 | Flanagan Cormac Andrias | Method and apparatus for organizing warning messages |
US6593940B1 (en) * | 1998-12-23 | 2003-07-15 | Intel Corporation | Method for finding errors in multithreaded applications |
US6598180B1 (en) * | 1999-12-30 | 2003-07-22 | International Business Machines Corporation | Method, system and program products for selectively debugging program versions executing with in a computing environment |
US20030145253A1 (en) * | 2002-01-18 | 2003-07-31 | De Bonet Jeremy S. | Method and system for isolating and protecting software components |
US6611276B1 (en) * | 1999-08-31 | 2003-08-26 | Intel Corporation | Graphical user interface that displays operation of processor threads over time |
US6615370B1 (en) * | 1999-10-01 | 2003-09-02 | Hitachi, Ltd. | Circuit for storing trace information |
US20030167421A1 (en) * | 2002-03-01 | 2003-09-04 | Klemm Reinhard P. | Automatic failure detection and recovery of applications |
DE10210145A1 (en) * | 2002-03-07 | 2003-09-25 | Phoenix Contact Gmbh & Co | Procedures for displaying error messages in software applications |
US20030182655A1 (en) * | 2002-03-25 | 2003-09-25 | Hewlett Packard Company | Unwinding instrumented program code |
US20030208746A1 (en) * | 2002-05-02 | 2003-11-06 | International Business Machines Corporation | Conditional breakpoint encountered indication |
US20030217155A1 (en) * | 2002-05-20 | 2003-11-20 | Siemens Information And Communication Networks, Inc. | Send of software tracer messages via IP from several sources to be stored by a remote server |
US6658416B1 (en) * | 2000-07-10 | 2003-12-02 | International Business Machines Corporation | Apparatus and method for creating an indexed database of symbolic data for use with trace data of a computer program |
US6658622B1 (en) * | 1998-12-14 | 2003-12-02 | International Business Machines Corporation | Self-diagnosing and self-correcting data entry components with dependency behavior |
US6662358B1 (en) * | 1997-12-12 | 2003-12-09 | International Business Machines Corporation | Minimizing profiling-related perturbation using periodic contextual information |
EP1376365A2 (en) * | 2002-06-28 | 2004-01-02 | Canon Kabushiki Kaisha | Method for acquiring logs for program debugging |
EP1376366A2 (en) * | 2002-06-28 | 2004-01-02 | Canon Kabushiki Kaisha | Method for acquiring logs for program debugging |
US6678883B1 (en) * | 2000-07-10 | 2004-01-13 | International Business Machines Corporation | Apparatus and method for creating a trace file for a trace of a computer program based on loaded module information |
US6681331B1 (en) | 1999-05-11 | 2004-01-20 | Cylant, Inc. | Dynamic software system intrusion detection |
US6681384B1 (en) * | 1999-12-23 | 2004-01-20 | International Business Machines Corporation | Multi-threaded break-point |
US6684348B1 (en) * | 1999-10-01 | 2004-01-27 | Hitachi, Ltd. | Circuit for processing trace information |
US6701460B1 (en) * | 1999-10-21 | 2004-03-02 | Sun Microsystems, Inc. | Method and apparatus for testing a computer system through software fault injection |
US6701363B1 (en) * | 2000-02-29 | 2004-03-02 | International Business Machines Corporation | Method, computer program product, and system for deriving web transaction performance metrics |
US20040054991A1 (en) * | 2002-09-17 | 2004-03-18 | Harres John M. | Debugging tool and method for tracking code execution paths |
US20040059962A1 (en) * | 2002-09-23 | 2004-03-25 | Per-Ola Robertsson | Bi-directional probing of software |
US6715140B1 (en) * | 1999-11-18 | 2004-03-30 | Fujitsu Limited | Program trace method and apparatus, and storage medium |
US6721941B1 (en) * | 1996-08-27 | 2004-04-13 | Compuware Corporation | Collection of timing and coverage data through a debugging interface |
US20040078785A1 (en) * | 2002-10-22 | 2004-04-22 | Bala Dutt | System and method for marking software code |
US20040078691A1 (en) * | 2002-10-18 | 2004-04-22 | Cirne Lewis K. | Transaction tracer |
US20040078688A1 (en) * | 2002-10-18 | 2004-04-22 | Xavier Pouyollon | File path resolving debugger |
US20040075690A1 (en) * | 2002-10-18 | 2004-04-22 | Cirne Lewis K. | User interface for viewing performance information about transactions |
US6732307B1 (en) | 1999-10-01 | 2004-05-04 | Hitachi, Ltd. | Apparatus and method for storing trace information |
US6738083B2 (en) * | 2000-12-20 | 2004-05-18 | Siemens Information And Communication Networks, Inc. | Method and system of displaying telecommunication trace diagnostic information |
KR100433549B1 (en) * | 2002-05-11 | 2004-05-31 | 삼성전자주식회사 | Method and apparatus for analyzing software |
US6745383B1 (en) | 1999-12-29 | 2004-06-01 | Veritas Operating Corporation | Early warning mechanism for enhancing enterprise availability |
US6748584B1 (en) * | 1999-12-29 | 2004-06-08 | Veritas Operating Corporation | Method for determining the degree to which changed code has been exercised |
US20040117690A1 (en) * | 2002-12-13 | 2004-06-17 | Andersson Anders J. | Method and apparatus for using a hardware disk controller for storing processor execution trace information on a storage device |
US6754891B1 (en) * | 1998-08-31 | 2004-06-22 | Red Hat, Inc. | Debugger system using tracepoints for computer software |
US6754612B1 (en) * | 2000-06-29 | 2004-06-22 | Microsoft Corporation | Performance markers to measure benchmark timing of a plurality of standard features in an application program |
US6772106B1 (en) * | 1999-08-20 | 2004-08-03 | Hewlett-Packard Development Company, L.P. | Retargetable computer design system |
US20040168157A1 (en) * | 2003-02-18 | 2004-08-26 | Robert Hundt | System and method for creating a process invocation tree |
US6785883B1 (en) * | 1999-01-19 | 2004-08-31 | Siemens Aktiengesellschaft | Software system for tracing data |
US20040199828A1 (en) * | 2003-04-01 | 2004-10-07 | International Business Machines Corporation | Method and apparatus for tracing troubleshooting events for aiding technical assistance |
US6804814B1 (en) | 1999-12-29 | 2004-10-12 | Veritas Operating Corporation | Method for simulating back program execution from a traceback sequence |
US20040205704A1 (en) * | 1999-12-27 | 2004-10-14 | Miller Donald W. | Transparent monitoring system and method for examining an executing program in real time |
US6813770B1 (en) | 2000-04-21 | 2004-11-02 | Sun Microsystems, Inc. | Abstract syntax notation to interface definition language converter framework for network management |
US20040220684A1 (en) * | 2003-03-14 | 2004-11-04 | Shinji Fukui | Display and edit device, display method and program product |
US20040221269A1 (en) * | 2003-05-02 | 2004-11-04 | Ray Kenneth D | User debugger for use on processes running in a high assurance kernel in an operating system |
US20040225923A1 (en) * | 1999-09-09 | 2004-11-11 | Microsoft Corporation | Object-based software management |
US6820253B1 (en) * | 2000-09-27 | 2004-11-16 | Intel Corporation | Method and system for interprocedural analysis with separate compilation |
US6832302B1 (en) * | 2001-10-24 | 2004-12-14 | At&T Corp. | Methods and apparatus for detecting heap smashing |
US20040255273A1 (en) * | 2003-06-16 | 2004-12-16 | Microsoft Corporation | Reformulating resources with nodes reachable from defined entry points |
US20040268213A1 (en) * | 2003-06-16 | 2004-12-30 | Microsoft Corporation | Classifying software and reformulating resources according to classifications |
US20040268302A1 (en) * | 2003-06-26 | 2004-12-30 | Microsoft Corporation | Framework for determining and exposing binary dependencies |
US20040268308A1 (en) * | 2003-06-26 | 2004-12-30 | Microsoft Corporation | Mining dependencies for testing and risk management |
US6839748B1 (en) | 2000-04-21 | 2005-01-04 | Sun Microsystems, Inc. | Synchronous task scheduler for corba gateway |
US20050015775A1 (en) * | 1997-10-28 | 2005-01-20 | Microsoft Corporation | Software component execution management using context objects for tracking externally-defined intrinsic properties of executing software components within an execution environment |
US6848097B1 (en) * | 1998-11-13 | 2005-01-25 | Cray Inc. | Debugging techniques in a multithreaded environment |
US20050034109A1 (en) * | 2001-06-04 | 2005-02-10 | Microsoft Corporation | Method and system for program editing |
US20050038975A1 (en) * | 2000-12-29 | 2005-02-17 | Mips Technologies, Inc. | Configurable co-processor interface |
US6859898B1 (en) * | 1999-09-30 | 2005-02-22 | Toyoda Koki Kabushiki Kaisha | Monitor apparatus for sequential-function-chart-type programmable controller |
US20050060696A1 (en) * | 2003-08-29 | 2005-03-17 | Nokia Corporation | Method and a system for constructing control flows graphs of binary executable programs at post-link time |
US6871348B1 (en) * | 1999-09-15 | 2005-03-22 | Intel Corporation | Method and apparatus for integrating the user interfaces of multiple applications into one application |
US20050066311A1 (en) * | 2003-09-22 | 2005-03-24 | International Business Machines Corporation | Autonomic execution tracking and correction of functions |
US20050061221A1 (en) * | 2001-11-02 | 2005-03-24 | Mariusz Paszkowski | Superhydrophobic coating |
US6873934B1 (en) * | 2000-06-29 | 2005-03-29 | Microsoft Corporation | Performance markers to measure benchmark timing of features in a program |
US6883120B1 (en) | 1999-12-03 | 2005-04-19 | Network Appliance, Inc. | Computer assisted automatic error detection and diagnosis of file servers |
US20050091643A1 (en) * | 2003-10-28 | 2005-04-28 | International Business Machines Corporation | Control flow based compression of execution traces |
US20050091644A1 (en) * | 2001-08-24 | 2005-04-28 | Microsoft Corporation | System and method for using data address sequences of a program in a software development tool |
US20050108689A1 (en) * | 2003-11-13 | 2005-05-19 | Hooper Donald F. | Instruction operand tracing for software debug |
US20050138536A1 (en) * | 2003-11-13 | 2005-06-23 | Smith Zachary S. | Systems and methods for identifying similar bugs |
US20050144507A1 (en) * | 2000-09-19 | 2005-06-30 | Kuo-Chun Lee | Method and apparatus for remotely debugging an application program over the internet |
US20050144599A1 (en) * | 2003-12-26 | 2005-06-30 | Microsoft Corporation | Source server |
US6915324B1 (en) | 2000-04-21 | 2005-07-05 | Sun Microsystems, Inc. | Generic and dynamic mapping of abstract syntax notation (ASN1) to and from interface definition language for network management |
US6918065B1 (en) | 1999-10-01 | 2005-07-12 | Hitachi, Ltd. | Method for compressing and decompressing trace information |
US20050160431A1 (en) * | 2002-07-29 | 2005-07-21 | Oracle Corporation | Method and mechanism for debugging a series of related events within a computer system |
US20050183067A1 (en) * | 2004-02-12 | 2005-08-18 | International Business Machines Corporation | Method and apparatus for automatic detection of build regressions |
US20050183070A1 (en) * | 2004-02-12 | 2005-08-18 | International Business Machines Corporation | Method and apparatus for averaging out variations in run-to-run path data of a computer program |
US20050183075A1 (en) * | 2004-02-12 | 2005-08-18 | International Business Machines Corporation | Method and apparatus for removal of asynchronous events in complex application performance analysis |
US6934947B1 (en) * | 1999-05-10 | 2005-08-23 | Robert Zeidman | Visual tool for developing real time task management code |
US6944614B1 (en) * | 1999-11-24 | 2005-09-13 | Ncr Corporation | Query monitor playback mechanism for post-mortem performance analysis |
US6950935B1 (en) | 2000-04-21 | 2005-09-27 | Sun Microsystems, Inc. | Pluggable authentication modules for telecommunications management network |
US20050216915A1 (en) * | 1999-04-05 | 2005-09-29 | Microsoft Corporation | Method of ranking messages generated in a computer system |
US20050222992A1 (en) * | 2004-03-05 | 2005-10-06 | Takashi Kondo | Computer system analyzing apparatus and computer system analyzing method |
US20050251792A1 (en) * | 2004-05-06 | 2005-11-10 | Smith David W | System for adaptively determining executable application operation characteristics |
US20050273757A1 (en) * | 2004-06-07 | 2005-12-08 | Anderson Craig D | Methods, systems, and computer program products for summarizing operational behavior of a computer program |
US6978444B1 (en) * | 2000-08-01 | 2005-12-20 | International Business Machines Corporation | Computer-implemented method and system for automatically invoking a predetermined debugger command at a desired location of a single thread of a program |
US6978303B1 (en) * | 1999-10-26 | 2005-12-20 | Iontal Limited | Monitoring of computer usage |
US20050283765A1 (en) * | 2004-06-19 | 2005-12-22 | Apple Computer, Inc. | Software performance analysis using data mining |
US20050283676A1 (en) * | 2004-06-22 | 2005-12-22 | International Business Machines Corporation | System and method for boundary trace with reproduction facility |
US20050289517A1 (en) * | 2004-06-24 | 2005-12-29 | International Business Machines Corporation | System and methods for client and template validation |
US20060005149A1 (en) * | 2001-04-20 | 2006-01-05 | Microsoft Corporation | Method and system for displaying categorized information on a user interface |
US6988263B1 (en) | 2000-07-10 | 2006-01-17 | International Business Machines Corporation | Apparatus and method for cataloging symbolic data for use in performance analysis of computer programs |
US6996516B1 (en) * | 1998-02-05 | 2006-02-07 | Ns Solutions Corporation | Apparatus for analyzing software and method of the same |
US7010586B1 (en) | 2000-04-21 | 2006-03-07 | Sun Microsystems, Inc. | System and method for event subscriptions for CORBA gateway |
US20060070041A1 (en) * | 2004-09-29 | 2006-03-30 | Microsoft Corporation | Constrained execution regions |
US20060070077A1 (en) * | 2004-09-30 | 2006-03-30 | Microsoft Corporation | Providing custom product support for a software program |
WO2006033932A2 (en) * | 2004-09-17 | 2006-03-30 | Sun Microsystems, Inc. | Method and system for simplifying the debugging of a program comprising user-written code and non-user written code |
US20060075390A1 (en) * | 2004-09-16 | 2006-04-06 | International Business Machines Corporation | Method and system for tracing components of computer applications |
US7032214B1 (en) | 2000-06-29 | 2006-04-18 | Microsoft Corporation | Performance markers to measure performance of features in a program |
US20060085691A1 (en) * | 2004-10-20 | 2006-04-20 | Rivera Jose G | Method and apparatus for logging the execution history of an operating system kernel |
US7043668B1 (en) | 2001-06-29 | 2006-05-09 | Mips Technologies, Inc. | Optimized external trace formats |
US7055070B1 (en) * | 2001-04-30 | 2006-05-30 | Mips Technologies, Inc. | Trace control block implementation and method |
US7058928B2 (en) | 1999-12-23 | 2006-06-06 | Identify Software Ltd. | System and method for conditional tracing of computer programs |
US7065675B1 (en) | 2001-05-08 | 2006-06-20 | Mips Technologies, Inc. | System and method for speeding up EJTAG block data transfers |
US7069544B1 (en) | 2001-04-30 | 2006-06-27 | Mips Technologies, Inc. | Dynamic selection of a compression algorithm for trace data |
US20060161394A1 (en) * | 2000-02-14 | 2006-07-20 | Nextnine, Inc. | Support network |
US20060167955A1 (en) * | 2005-01-21 | 2006-07-27 | Vertes Marc P | Non-intrusive method for logging of internal events within an application process, and system implementing this method |
US20060184829A1 (en) * | 2005-02-14 | 2006-08-17 | Cheong Gerald I | Web-based analysis of defective computer programs |
US7103883B2 (en) * | 1998-10-29 | 2006-09-05 | Texas Instruments Incorporated | System and method for translating include files |
US20060200701A1 (en) * | 2005-03-01 | 2006-09-07 | Microsoft Corporation | Kernel-mode in-flight recorder tracing mechanism |
US7124072B1 (en) | 2001-04-30 | 2006-10-17 | Mips Technologies, Inc. | Program counter and data tracing from a multi-issue processor |
US20060242627A1 (en) * | 2000-12-26 | 2006-10-26 | Shlomo Wygodny | System and method for conditional tracing of computer programs |
US20060248512A1 (en) * | 2005-04-28 | 2006-11-02 | Microsoft Corporation | Active execution tracing visualization |
US20060248514A1 (en) * | 2005-04-28 | 2006-11-02 | Microsoft Corporation | Active execution tracing |
US7134116B1 (en) | 2001-04-30 | 2006-11-07 | Mips Technologies, Inc. | External trace synchronization via periodic sampling |
US7133820B2 (en) * | 2000-03-15 | 2006-11-07 | Arc International | Method and apparatus for debugging programs in a distributed environment |
US20060259823A1 (en) * | 2005-05-16 | 2006-11-16 | Texas Instruments Incorporated | Determining operating context of an executed instruction |
US7140004B1 (en) * | 2000-06-13 | 2006-11-21 | Tellme Networks, Inc. | Method and apparatus for zero-footprint phone application development |
US20060265693A1 (en) * | 2005-05-20 | 2006-11-23 | Microsoft Corporation | Methods and apparatus for software profiling |
US7146473B1 (en) * | 2003-11-14 | 2006-12-05 | Sun Microsystems, Inc. | Mechanism for ring buffering in an arbitrary-action tracing framework |
US20060277441A1 (en) * | 2005-06-02 | 2006-12-07 | Seagate Technology Llc | Unified debug system with multiple user-configurable trace volumes and trace buffers |
US7159101B1 (en) | 2003-05-28 | 2007-01-02 | Mips Technologies, Inc. | System and method to trace high performance multi-issue processors |
US20070006168A1 (en) * | 2003-02-13 | 2007-01-04 | Dimpsey Robert T | Apparatus and method for dynamic instrumenting of code to minimize system perturbation |
US20070011497A1 (en) * | 2005-06-03 | 2007-01-11 | Microsoft Corporation | System and method for economizing trace operations |
US7165190B1 (en) | 2002-07-29 | 2007-01-16 | Oracle International Corporation | Method and mechanism for managing traces within a computer system |
US7168066B1 (en) | 2001-04-30 | 2007-01-23 | Mips Technologies, Inc. | Tracing out-of order load data |
US20070027999A1 (en) * | 2005-07-29 | 2007-02-01 | Allen James P | Method for coordinated error tracking and reporting in distributed storage systems |
US7178133B1 (en) | 2001-04-30 | 2007-02-13 | Mips Technologies, Inc. | Trace control based on a characteristic of a processor's operating state |
US7181728B1 (en) | 2001-04-30 | 2007-02-20 | Mips Technologies, Inc. | User controlled trace records |
US20070044075A1 (en) * | 2005-08-17 | 2007-02-22 | Maarten Koning | Method for analysis of source code and display of corresponding output through a marking scheme |
US7185367B2 (en) | 1999-05-11 | 2007-02-27 | Cylant, Inc. | Method and system for establishing normal software system behavior and departures from normal behavior |
US20070050764A1 (en) * | 2005-08-30 | 2007-03-01 | Microsoft Corporation | Hierarchical virtualization with a multi-level virtualization mechanism |
US20070050683A1 (en) * | 2005-08-25 | 2007-03-01 | International Business Machines Corporation | Virtual flight recorder hosted by system tracing facility |
US20070061739A1 (en) * | 2005-09-12 | 2007-03-15 | Vitaliy Stulski | Object reference monitoring |
US7200588B1 (en) | 2002-07-29 | 2007-04-03 | Oracle International Corporation | Method and mechanism for analyzing trace data using a database management system |
US20070083813A1 (en) * | 2005-10-11 | 2007-04-12 | Knoa Software, Inc | Generic, multi-instance method and GUI detection system for tracking and monitoring computer applications |
US7206843B1 (en) | 2000-04-21 | 2007-04-17 | Sun Microsystems, Inc. | Thread-safe portable management interface |
US7228175B2 (en) | 2002-05-15 | 2007-06-05 | Cardiac Pacemakers, Inc. | Cardiac rhythm management systems and methods using acoustic contractility indicator |
US7228346B1 (en) | 2000-04-21 | 2007-06-05 | Sun Microsystems, Inc. | IDL event and request formatting for corba gateway |
US20070130119A1 (en) * | 2005-12-01 | 2007-06-07 | Phillips Brent R | User/process runtime system trace |
US20070130320A1 (en) * | 2005-12-01 | 2007-06-07 | Morgan Fabian F | Efficient, centralized management of application log configuration settings |
US7231551B1 (en) | 2001-06-29 | 2007-06-12 | Mips Technologies, Inc. | Distributed tap controller |
US20070143323A1 (en) * | 2005-12-15 | 2007-06-21 | Wily Technology, Inc. | Correlating cross process and cross thread execution flows in an application manager |
US20070143743A1 (en) * | 2005-12-15 | 2007-06-21 | Wily Technology, Inc. | Use of execution flow shape to allow aggregate data reporting with full context in an application manager |
US7237090B1 (en) | 2000-12-29 | 2007-06-26 | Mips Technologies, Inc. | Configurable out-of-order data transfer in a coprocessor interface |
US20070150255A1 (en) * | 2000-03-02 | 2007-06-28 | Texas Instruments Incorporated | Emulation export sequence with distributed control |
US7240334B1 (en) * | 2000-06-29 | 2007-07-03 | International Business Machines Corporation | Methods, systems, and computer program products for deferred computer program tracing |
US20070169052A1 (en) * | 2005-12-15 | 2007-07-19 | Wily Technology, Inc. | Execution flow shape compression for aggregate data reporting in an application manager |
US7251810B1 (en) * | 2000-04-26 | 2007-07-31 | Microsoft Corporation | Minimal instrumentation for lossless call profiling |
US20070226773A1 (en) * | 2006-03-21 | 2007-09-27 | Novell, Inc. | System and method for using sandboxes in a managed shell |
US20070266045A1 (en) * | 2006-05-11 | 2007-11-15 | Computer Associates Think, Inc. | Hierarchy for characterizing interactions with an application |
US20070266149A1 (en) * | 2006-05-11 | 2007-11-15 | Computer Associates Think, Inc. | Integrating traffic monitoring data and application runtime data |
US20070277222A1 (en) * | 2006-05-26 | 2007-11-29 | Novell, Inc | System and method for executing a permissions recorder analyzer |
US7305660B2 (en) | 2003-08-29 | 2007-12-04 | International Business Machines Corporation | Method to generate a formatted trace for an embedded device |
US20080002811A1 (en) * | 2006-06-29 | 2008-01-03 | Allison John W | Treatment delivery optimization |
US20080016500A1 (en) * | 2006-07-17 | 2008-01-17 | Computer Associates Think,Inc. | Method and System for Storing Trace Events in a Database Table |
US20080028461A1 (en) * | 2006-07-26 | 2008-01-31 | Novell, Inc. | System and method for dynamic optimizations using security assertions |
US20080022843A1 (en) * | 2006-07-28 | 2008-01-31 | Apple Computer, Inc. | Execution difference identification tool |
US20080046961A1 (en) * | 2006-08-11 | 2008-02-21 | Novell, Inc. | System and method for network permissions evaluation |
US20080059625A1 (en) * | 2002-03-29 | 2008-03-06 | Barnett Paul T | Method of semi-automatic data collection, data analysis, and model generation for the performance analysis of enterprise applications |
US7343529B1 (en) | 2004-04-30 | 2008-03-11 | Network Appliance, Inc. | Automatic error and corrective action reporting system for a network storage appliance |
US20080066063A1 (en) * | 2006-07-21 | 2008-03-13 | Novell, Inc. | System and method for preparing runtime checks |
US20080072276A1 (en) * | 2006-08-24 | 2008-03-20 | Novell, Inc. | System and method for applying security policies on multiple assembly caches |
US20080079983A1 (en) * | 2006-09-21 | 2008-04-03 | Fowler Ii Melvin Eugene | Graphical user interface for job output retrieval |
US20080109796A1 (en) * | 2006-11-08 | 2008-05-08 | Nicolai Kosche | Method and Apparatus for Associating User-Specified Data with Events in a Data Space Profiler |
US7376937B1 (en) | 2001-05-31 | 2008-05-20 | Oracle International Corporation | Method and mechanism for using a meta-language to define and analyze traces |
US7380239B1 (en) * | 2001-05-31 | 2008-05-27 | Oracle International Corporation | Method and mechanism for diagnosing computer applications using traces |
US20080127107A1 (en) * | 2006-09-07 | 2008-05-29 | Sun Microsystems, Inc. | Method and apparatus for specification and application of a user-specified filter in a data space profiler |
US20080134209A1 (en) * | 2006-12-01 | 2008-06-05 | Computer Associates Think, Inc. | Automated grouping of messages provided to an application using string similarity analysis |
US20080134205A1 (en) * | 2006-12-01 | 2008-06-05 | Computer Associates Think, Inc. | Automated grouping of messages provided to an application using execution path similarity analysis |
US7386522B1 (en) | 1997-03-21 | 2008-06-10 | International Business Machines Corporation | Optimizing the performance of computer tasks using intelligent agent with multiple program modules having varied degrees of domain knowledge |
US20080148242A1 (en) * | 2006-12-18 | 2008-06-19 | Computer Associates Think, Inc. | Optimizing an interaction model for an application |
US20080148039A1 (en) * | 2006-11-30 | 2008-06-19 | Computer Associates Think, Inc. | Selecting instrumentation points for an application |
US20080163177A1 (en) * | 2006-12-29 | 2008-07-03 | Sap Ag | System and method for displaying trace information |
US20080163178A1 (en) * | 2006-12-29 | 2008-07-03 | Ivanova Gorka J | System and method for displaying component information of a trace |
US20080177525A1 (en) * | 2007-01-23 | 2008-07-24 | Microsoft Corporation | Integrated debugger simulator |
US20080263522A1 (en) * | 2005-09-09 | 2008-10-23 | International Business Machines Corporation | Common Debug Adaptor |
US20080270837A1 (en) * | 2007-04-24 | 2008-10-30 | Kiefer Scott K | System diagnostic utility |
US20080271042A1 (en) * | 2007-04-24 | 2008-10-30 | Microsoft Corporation | Testing multi-thread software using prioritized context switch limits |
US7454666B1 (en) * | 2005-04-07 | 2008-11-18 | Sun Microsystems, Inc. | Real-time address trace generation |
US20080295078A1 (en) * | 2007-05-25 | 2008-11-27 | Microsoft Corporation | In-process debugging using external debugging infrastructure |
US20080295114A1 (en) * | 2007-05-07 | 2008-11-27 | Pramod Vasant Argade | Method and apparatus for execution control of computer programs |
US20080320442A1 (en) * | 2007-06-21 | 2008-12-25 | Microsoft Corporation | Execution-centric source code view |
US7478403B1 (en) | 2000-04-21 | 2009-01-13 | Sun Microsystems, Inc. | Secure access to managed network objects using a configurable platform-independent gateway providing individual object-level access control |
US7480825B2 (en) * | 2001-09-03 | 2009-01-20 | Pact Xpp Technologies Ag | Method for debugging reconfigurable architectures |
US7500152B2 (en) * | 2003-12-05 | 2009-03-03 | Freescale Semiconductor, Inc. | Apparatus and method for time ordering events in a system having multiple time domains |
US20090083409A1 (en) * | 2007-09-26 | 2009-03-26 | Microsoft Corporation | Remote monitoring of local behavior of network applications |
US20090083698A1 (en) * | 2004-09-30 | 2009-03-26 | Rockwell Automation Technologies, Inc. | Systems and methods that facilitate management of add-on instruction generation, selection, and/or monitoring during execution |
US20090083714A1 (en) * | 2007-09-26 | 2009-03-26 | Microsoft Corporation | Remote monitoring of local behavior of network applications |
US20090132860A1 (en) * | 2007-11-21 | 2009-05-21 | Inventec Corporation | System and method for rapidly diagnosing bugs of system software |
US7555549B1 (en) * | 2004-11-07 | 2009-06-30 | Qlogic, Corporation | Clustered computing model and display |
US20090178030A1 (en) * | 2008-01-09 | 2009-07-09 | International Business Machines Corporation | System, method and program for executing a debugger |
US20090187968A1 (en) * | 2003-07-29 | 2009-07-23 | Enterasys Networks, Inc. | System and method for dynamic network policy management |
US20090204949A1 (en) * | 2008-02-07 | 2009-08-13 | International Business Machines Corporation | System, method and program product for dynamically adjusting trace buffer capacity based on execution history |
US7584390B2 (en) | 1997-12-22 | 2009-09-01 | Pact Xpp Technologies Ag | Method and system for alternating between programs for execution by cells of an integrated circuit |
US20090222646A1 (en) * | 2008-02-28 | 2009-09-03 | International Business Machines Corporation | Method and apparatus for detecting processor behavior using instruction trace data |
US20090222793A1 (en) * | 2008-02-29 | 2009-09-03 | International Business Machines Corporation | Virtual Machine and Programming Language for Event Processing |
US20090222789A1 (en) * | 2008-02-29 | 2009-09-03 | International Business Machines Corporation | Compiler for a Declarative Event-Driven Programming Model |
US20090222796A1 (en) * | 2008-02-29 | 2009-09-03 | International Business Machines Corporation | Viral trace |
US20090222795A1 (en) * | 2008-02-29 | 2009-09-03 | International Business Machines Corporation | Debugger for a Declarative Event-Driven Programming Model |
US20090228875A1 (en) * | 2008-03-04 | 2009-09-10 | Devries Alex | Method and System for Reducing Disk Allocation by Profiling Symbol Usage |
US7627785B1 (en) * | 2004-07-12 | 2009-12-01 | Sun Microsystems, Inc. | Capturing machine state of unstable Java program |
US20100011345A1 (en) * | 2008-07-09 | 2010-01-14 | International Business Machines Corporation | Efficient and Self-Balancing Verification of Multi-Threaded Microprocessors |
US7650448B2 (en) | 1996-12-20 | 2010-01-19 | Pact Xpp Technologies Ag | I/O and memory bus system for DFPS and units with two- or multi-dimensional programmable cell architectures |
US7657861B2 (en) | 2002-08-07 | 2010-02-02 | Pact Xpp Technologies Ag | Method and device for processing data |
US7657877B2 (en) | 2001-06-20 | 2010-02-02 | Pact Xpp Technologies Ag | Method for processing data |
US7685575B1 (en) * | 2004-06-08 | 2010-03-23 | Sun Microsystems, Inc. | Method and apparatus for analyzing an application |
US20100088683A1 (en) * | 2000-03-03 | 2010-04-08 | Identify Software, Ltd. | System and method for software diagnostics using a combination of visual and dynamic tracing |
US20100107014A1 (en) * | 2008-10-29 | 2010-04-29 | Aternity Inc. | Real time monitoring of computer for determining speed of various processes |
US20100153926A1 (en) * | 2008-12-15 | 2010-06-17 | International Business Machines Corporation | Operating system aided code coverage |
US7779390B1 (en) * | 2000-04-21 | 2010-08-17 | Oracle America, Inc. | Thread-safe remote debugger |
US7783720B1 (en) | 2000-04-21 | 2010-08-24 | Oracle America, Inc. | CORBA metadata gateway to telecommunications management network |
US7782087B2 (en) | 2002-09-06 | 2010-08-24 | Martin Vorbach | Reconfigurable sequencer structure |
US7822881B2 (en) | 1996-12-27 | 2010-10-26 | Martin Vorbach | Process for automatic dynamic reloading of data flow processors (DFPs) and units with two- or three-dimensional programmable cell architectures (FPGAs, DPGAs, and the like) |
US7822968B2 (en) | 1996-12-09 | 2010-10-26 | Martin Vorbach | Circuit having a multidimensional structure of configurable cells that include multi-bit-wide inputs and outputs |
US7827539B1 (en) | 2004-06-25 | 2010-11-02 | Identify Software Ltd. | System and method for automated tuning of program execution tracing |
US20100287417A1 (en) * | 2009-05-05 | 2010-11-11 | Freescale Semiconductor, Inc. | Address translation trace message generation for debug |
US7844796B2 (en) | 2001-03-05 | 2010-11-30 | Martin Vorbach | Data processing device and method |
US7861178B2 (en) | 1999-05-07 | 2010-12-28 | Knoa Software, Inc. | System and method for dynamic assistance in software applications using behavior and host application models |
US7870504B1 (en) | 2003-10-01 | 2011-01-11 | TestPlant Inc. | Method for monitoring a graphical user interface on a second computer display from a first computer |
US20110016357A1 (en) * | 2009-07-17 | 2011-01-20 | Krum Georgiev Tsvetkov | Call-stacks representation for easier analysis of thread dump |
US7895651B2 (en) | 2005-07-29 | 2011-02-22 | Bit 9, Inc. | Content tracking in a network security system |
US7908225B1 (en) | 1997-03-21 | 2011-03-15 | International Business Machines Corporation | Intelligent agent with negotiation capability and method of negotiation therewith |
US20110067007A1 (en) * | 2009-09-14 | 2011-03-17 | Red Hat, Inc. | Automatic thread dumping |
US20110099539A1 (en) * | 2009-10-27 | 2011-04-28 | Microsoft Corporation | Analysis and timeline visualization of thread activity |
US20110119533A1 (en) * | 2009-05-05 | 2011-05-19 | Freescale Semiconductor, Inc. | Program trace message generation for page crossing events for debug |
US20110154300A1 (en) * | 2009-12-18 | 2011-06-23 | Microsoft Corporation | Debugging From A Call Graph |
US20110161938A1 (en) * | 2009-12-30 | 2011-06-30 | International Business Machines Corporation | Including defect content in source code and producing quality reports from the same |
US7996827B2 (en) * | 2001-08-16 | 2011-08-09 | Martin Vorbach | Method for the translation of programs for reconfigurable architectures |
US20110214108A1 (en) * | 2010-02-26 | 2011-09-01 | Roland Grunberg | Architecture, system and method for generating visualizations from running executable code |
US20110239194A1 (en) * | 2010-03-29 | 2011-09-29 | Microsoft Corporation | Automatically redirecting method calls for unit testing |
US8032866B1 (en) | 2003-03-27 | 2011-10-04 | Identify Software Ltd. | System and method for troubleshooting runtime software problems using application learning |
EP2375337A1 (en) * | 2010-04-09 | 2011-10-12 | AppFirst, Inc. | System and method for information extraction from within an active application during execution |
US8058899B2 (en) | 2000-10-06 | 2011-11-15 | Martin Vorbach | Logic cell array and bus system |
US8099618B2 (en) | 2001-03-05 | 2012-01-17 | Martin Vorbach | Methods and devices for treating and processing data |
US20120030667A1 (en) * | 2010-07-29 | 2012-02-02 | International Business Machines Corporation | Packaging an application |
US8127061B2 (en) | 2002-02-18 | 2012-02-28 | Martin Vorbach | Bus systems and reconfiguration methods |
US8156284B2 (en) | 2002-08-07 | 2012-04-10 | Martin Vorbach | Data processing method and device |
US8176551B1 (en) * | 2000-01-27 | 2012-05-08 | Trapware Corporation | Detection of observer programs and countermeasures against observer programs |
US8209653B2 (en) | 2001-09-03 | 2012-06-26 | Martin Vorbach | Router |
US20120167057A1 (en) * | 2010-12-22 | 2012-06-28 | Microsoft Corporation | Dynamic instrumentation of software code |
US8225397B1 (en) | 2000-01-27 | 2012-07-17 | Trapware Corporation | Detection of observers and countermeasures against observers |
US8230411B1 (en) | 1999-06-10 | 2012-07-24 | Martin Vorbach | Method for interleaving a program over a plurality of cells |
US20120191636A1 (en) * | 2011-01-24 | 2012-07-26 | International Business Machines Corporation | Smarter Business Intelligence Systems |
US8250503B2 (en) | 2006-01-18 | 2012-08-21 | Martin Vorbach | Hardware definition method including determining whether to implement a function as hardware or software |
US8272058B2 (en) | 2005-07-29 | 2012-09-18 | Bit 9, Inc. | Centralized timed analysis in a network security system |
US8281108B2 (en) | 2002-01-19 | 2012-10-02 | Martin Vorbach | Reconfigurable general purpose processor having time restricted configurations |
EP2508997A1 (en) * | 2011-04-08 | 2012-10-10 | Computer Associates Think, Inc. | Visualization of JVM and cross-JVM call stacks |
US8301872B2 (en) | 2000-06-13 | 2012-10-30 | Martin Vorbach | Pipeline configuration protocol and configuration unit communication |
US20120297254A1 (en) * | 2011-05-19 | 2012-11-22 | International Business Machines Corporation | On demand tracing of application code execution |
US20120304160A1 (en) * | 2011-05-27 | 2012-11-29 | Ridgeway Internet Security, Llc | Systems and Methods for Run-Time Interception of Software Methods |
US20130024731A1 (en) * | 2008-10-29 | 2013-01-24 | Aternity Information Systems Ltd. | Real time monitoring of computer for determining speed and energy consumption of various processes |
US8438427B2 (en) | 2011-04-08 | 2013-05-07 | Ca, Inc. | Visualizing relationships between a transaction trace graph and a map of logical subsystems |
US20130145108A1 (en) * | 2007-11-21 | 2013-06-06 | Jonathan Lindo | Advancing and rewinding a replayed program execution |
USRE44365E1 (en) | 1997-02-08 | 2013-07-09 | Martin Vorbach | Method of self-synchronization of configurable elements of a programmable module |
US8490055B2 (en) | 2010-09-17 | 2013-07-16 | Ca, Inc. | Generating dependency maps from dependency data |
US20130185600A1 (en) * | 2012-01-12 | 2013-07-18 | International Business Machines Corporation | Thread based dynamic data collection |
US8516301B2 (en) | 2011-04-08 | 2013-08-20 | Ca, Inc. | Visualizing transaction traces as flows through a map of logical subsystems |
US20130290936A1 (en) * | 2012-04-30 | 2013-10-31 | Nec Laboratories America, Inc. | Method and System for Correlated Tracing with Automated Multi-Layer Function Instrumentation Localization |
US20140068569A1 (en) * | 2012-08-31 | 2014-03-06 | Microsoft Corporation | User directed profiling |
US8686475B2 (en) | 2001-09-19 | 2014-04-01 | Pact Xpp Technologies Ag | Reconfigurable elements |
US8686549B2 (en) | 2001-09-03 | 2014-04-01 | Martin Vorbach | Reconfigurable elements |
US20140096114A1 (en) * | 2012-09-28 | 2014-04-03 | Identify Software Ltd. (IL) | Efficient method data recording |
CN103761089A (en) * | 2014-01-14 | 2014-04-30 | 清华大学 | Method for determining dynamic function call relation based on register transfer languages |
US20140130018A1 (en) * | 2012-11-05 | 2014-05-08 | Realworld Holding B.V. | Method and arrangement for collecting timing data related to a computer application |
US8745598B2 (en) | 2010-12-14 | 2014-06-03 | Bmc Software, Inc. | Running injected code prior to execution of an application |
US20140173569A1 (en) * | 2012-12-18 | 2014-06-19 | International Business Machines Corporation | Managing window focus while debugging a graphical user interface program |
US20140173568A1 (en) * | 2012-12-18 | 2014-06-19 | International Business Machines Corporation | Debugging a graphical user interface code script with non-intrusive overlays |
US8762958B2 (en) | 2002-11-06 | 2014-06-24 | Identify Software, Ltd. | System and method for troubleshooting software configuration problems using application tracing |
US8762952B2 (en) | 2010-12-14 | 2014-06-24 | Bmc Software, Inc. | Recording method calls that led to an unforeseen problem |
US8762951B1 (en) | 2007-03-21 | 2014-06-24 | Oracle America, Inc. | Apparatus and method for profiling system events in a fine grain multi-threaded multi-core processor |
US8769335B2 (en) | 2010-06-24 | 2014-07-01 | International Business Machines Corporation | Homogeneous recovery in a redundant memory system |
US8775858B2 (en) * | 2010-06-24 | 2014-07-08 | International Business Machines Corporation | Heterogeneous recovery in a redundant memory system |
US8812820B2 (en) | 2003-08-28 | 2014-08-19 | Pact Xpp Technologies Ag | Data processing device and method |
CN104077184A (en) * | 2013-03-25 | 2014-10-01 | 腾讯科技(深圳)有限公司 | Progress control method of application program and computer system |
US8856764B2 (en) | 2011-01-25 | 2014-10-07 | International Business Machines Corporation | Distributed static analysis of computer software applications |
US20140344556A1 (en) * | 2013-05-15 | 2014-11-20 | Nvidia Corporation | Interleaved instruction debugger |
US20140359583A1 (en) * | 2009-11-23 | 2014-12-04 | International Business Machines Corporation | Thread serialization and disablement tool |
US8914590B2 (en) | 2002-08-07 | 2014-12-16 | Pact Xpp Technologies Ag | Data processing method and device |
US20150066869A1 (en) * | 2013-09-04 | 2015-03-05 | Concurix Corporation | Module Database with Tracing Options |
US20150067652A1 (en) * | 2013-09-04 | 2015-03-05 | Concurix Corporation | Module Specific Tracing in a Shared Module Environment |
US20150067654A1 (en) * | 2013-09-04 | 2015-03-05 | Concurix Corporation | Tracing System for Application and Module Tracing |
US8984636B2 (en) | 2005-07-29 | 2015-03-17 | Bit9, Inc. | Content extractor and analysis system |
US9037807B2 (en) | 2001-03-05 | 2015-05-19 | Pact Xpp Technologies Ag | Processor arrangement on a chip including data processing, memory, and interface elements |
US9043381B2 (en) | 2011-12-22 | 2015-05-26 | International Business Machines Corporation | Predictive operator graph element processing |
US9047411B1 (en) * | 2013-10-22 | 2015-06-02 | The Mathworks, Inc. | Programming environment for executing program code despite errors and for providing error indicators |
US9053235B1 (en) * | 2013-10-22 | 2015-06-09 | The Mathworks, Inc. | Program code interface for providing program code and corresponding results of evaluating the program code |
US9053228B1 (en) | 2013-10-22 | 2015-06-09 | The Mathworks, Inc. | Determining when to evaluate program code and provide results in a live evaluation programming environment |
US9064052B1 (en) | 2013-10-22 | 2015-06-23 | The Mathworks, Inc. | Providing intermediate results of evaluating program code that includes a compound statement |
US20150180911A1 (en) * | 2013-12-19 | 2015-06-25 | Prasanna Bhat Mavinakuli | Feedback channel for feedback from software |
US9075916B1 (en) * | 2013-10-22 | 2015-07-07 | The Mathworks, Inc. | Undoing/redoing program code execution |
US20150222548A1 (en) * | 2013-01-25 | 2015-08-06 | Concurix Corporation | Tracing with a Workload Distributor |
US20150254161A1 (en) * | 2014-03-05 | 2015-09-10 | Concurix Corporation | Regression Evaluation Using Behavior Models of Software Applications |
US9141356B2 (en) | 2011-12-14 | 2015-09-22 | Microsoft Technology Licensing, Llc | Process for generating dynamic type |
US9202185B2 (en) | 2011-04-08 | 2015-12-01 | Ca, Inc. | Transaction model with structural and behavioral description of complex transactions |
US9225772B2 (en) | 2011-09-26 | 2015-12-29 | Knoa Software, Inc. | Method, system and program product for allocation and/or prioritization of electronic resources |
US9317257B2 (en) | 2012-06-22 | 2016-04-19 | Microsoft Technology Licensing, Llc | Folded views in development environment |
US9329980B2 (en) | 2014-03-05 | 2016-05-03 | Microsoft Technology Licensing, Llc | Security alerting using n-gram analysis of program execution data |
US9355016B2 (en) | 2014-03-05 | 2016-05-31 | Microsoft Technology Licensing, Llc | Automated regression testing for software applications |
US20160188441A1 (en) * | 2013-08-28 | 2016-06-30 | Bo Chen | Testing multi-threaded applications |
US9424026B2 (en) * | 2014-09-29 | 2016-08-23 | Sap Se | Visualizations of inter-entity calls |
US9436499B2 (en) | 2009-11-23 | 2016-09-06 | International Business Machines Corporation | User interface to display status of threads based on runtime analysis and control of folded thread |
CN106201745A (en) * | 2016-07-08 | 2016-12-07 | 深圳中兴网信科技有限公司 | The remote debugging method of application program, remote debugging system and terminal |
US9519568B2 (en) | 2012-12-31 | 2016-12-13 | Nvidia Corporation | System and method for debugging an executing general-purpose computing on graphics processing units (GPGPU) application |
US9575874B2 (en) | 2013-04-20 | 2017-02-21 | Microsoft Technology Licensing, Llc | Error list and bug report analysis for configuring an application tracer |
US9645915B2 (en) | 2006-12-27 | 2017-05-09 | The Mathworks, Inc. | Continuous evaluation of program code and saving state information associated with program code |
US9658936B2 (en) | 2013-02-12 | 2017-05-23 | Microsoft Technology Licensing, Llc | Optimization analysis using similar frequencies |
US9658943B2 (en) | 2013-05-21 | 2017-05-23 | Microsoft Technology Licensing, Llc | Interactive graph for navigating application code |
US9665474B2 (en) | 2013-03-15 | 2017-05-30 | Microsoft Technology Licensing, Llc | Relationships derived from trace data |
US9684557B2 (en) | 2006-04-04 | 2017-06-20 | Adobe Systems Incorporated | System and method for facilitating recovery from a document creation error |
US9697104B2 (en) * | 2015-12-07 | 2017-07-04 | Sap Se | End-to end tracing and logging |
US9734040B2 (en) | 2013-05-21 | 2017-08-15 | Microsoft Technology Licensing, Llc | Animated highlights in a graph representing an application |
US9754396B2 (en) | 2013-07-24 | 2017-09-05 | Microsoft Technology Licensing, Llc | Event chain visualization of performance data |
US9767006B2 (en) | 2013-02-12 | 2017-09-19 | Microsoft Technology Licensing, Llc | Deploying trace objectives using cost analyses |
US9772927B2 (en) | 2013-11-13 | 2017-09-26 | Microsoft Technology Licensing, Llc | User interface for selecting tracing origins for aggregating classes of trace data |
US9804949B2 (en) | 2013-02-12 | 2017-10-31 | Microsoft Technology Licensing, Llc | Periodicity optimization in an automated tracing system |
US9880915B2 (en) | 2014-03-05 | 2018-01-30 | Microsoft Technology Licensing, Llc | N-gram analysis of inputs to a software application |
US9940579B2 (en) | 2014-10-24 | 2018-04-10 | Google Llc | Methods and systems for automated tagging based on software execution traces |
WO2018085455A1 (en) * | 2016-11-01 | 2018-05-11 | App Onboard, Inc. | Dynamic graphic visualizer for application metrics |
US20180157552A1 (en) * | 2015-05-27 | 2018-06-07 | Hewlett Packard Enterprise Development Lp | Data validation |
WO2018136460A1 (en) * | 2017-01-18 | 2018-07-26 | Pivotal Software, Inc. | Trace management |
US10073753B2 (en) * | 2016-02-14 | 2018-09-11 | Dell Products, Lp | System and method to assess information handling system health and resource utilization |
US10180872B2 (en) * | 2016-04-14 | 2019-01-15 | Vmware, Inc. | Methods and systems that identify problems in applications |
US10289411B2 (en) * | 2013-11-18 | 2019-05-14 | Microsoft Technology Licensing, Llc | Diagnosing production applications |
US10324823B2 (en) | 2012-08-04 | 2019-06-18 | Microsoft Technology Licensing, Llc | Historical software diagnostics using lightweight process snapshots |
US10346292B2 (en) | 2013-11-13 | 2019-07-09 | Microsoft Technology Licensing, Llc | Software component recommendation based on multiple trace runs |
US10380003B2 (en) | 2014-10-29 | 2019-08-13 | Microsoft Technology Licensing, Llc | Diagnostic workflow for production debugging |
US20190294484A1 (en) * | 2018-03-21 | 2019-09-26 | International Business Machines Corporation | Root cause analysis for correlated development and operations data |
CN110287053A (en) * | 2019-06-27 | 2019-09-27 | 四川新网银行股份有限公司 | The method that distributed system is uniformly processed extremely |
US20190310930A1 (en) * | 2018-04-04 | 2019-10-10 | International Business Machines Corporation | Testing and reproduction of concurrency issues |
US10761965B2 (en) * | 2018-09-28 | 2020-09-01 | Atlassian Pty Ltd. | Detecting method calls based on stack trace data |
US10915426B2 (en) | 2019-06-06 | 2021-02-09 | International Business Machines Corporation | Intercepting and recording calls to a module in real-time |
US10929126B2 (en) | 2019-06-06 | 2021-02-23 | International Business Machines Corporation | Intercepting and replaying interactions with transactional and database environments |
US11016762B2 (en) | 2019-06-06 | 2021-05-25 | International Business Machines Corporation | Determining caller of a module in real-time |
US11036619B2 (en) | 2019-06-06 | 2021-06-15 | International Business Machines Corporation | Bypassing execution of a module in real-time |
US11074069B2 (en) | 2019-06-06 | 2021-07-27 | International Business Machines Corporation | Replaying interactions with transactional and database environments with re-arrangement |
US11102094B2 (en) | 2015-08-25 | 2021-08-24 | Google Llc | Systems and methods for configuring a resource for network traffic analysis |
US11252040B2 (en) * | 2018-07-31 | 2022-02-15 | Cisco Technology, Inc. | Advanced network tracing in the data plane |
US11256535B2 (en) | 2016-02-18 | 2022-02-22 | Micro Focus Llc | Visualizations of computer program transactions |
US11507496B2 (en) | 2016-02-10 | 2022-11-22 | Eggplant Limited | Method of, and apparatus for, testing computer hardware and software |
US11507494B2 (en) | 2016-02-10 | 2022-11-22 | Eggplant Limited | Method of, and apparatus for, testing computer hardware and software |
US11582238B2 (en) * | 2019-08-13 | 2023-02-14 | Dell Products L.P. | Securing a server from untrusted client applications |
US20230244782A1 (en) * | 2020-08-28 | 2023-08-03 | Siemens Aktiengesellschaft | Methods and systems for controlling access to at least one computer program |
Citations (40)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4503495A (en) | 1982-01-15 | 1985-03-05 | Honeywell Information Systems Inc. | Data processing system common bus utilization detection logic |
US4511960A (en) | 1982-01-15 | 1985-04-16 | Honeywell Information Systems Inc. | Data processing system auto address development logic for multiword fetch |
US4598364A (en) | 1983-06-29 | 1986-07-01 | International Business Machines Corporation | Efficient trace method adaptable to multiprocessors |
US4782461A (en) | 1984-06-21 | 1988-11-01 | Step Engineering | Logical grouping of facilities within a computer development system |
US5121489A (en) | 1988-08-02 | 1992-06-09 | International Business Machines Corporation | Tracing method for identifying program execution paths using a trace points bit map with one-to-one correspondence with embedded trace points |
US5193180A (en) * | 1991-06-21 | 1993-03-09 | Pure Software Inc. | System for modifying relocatable object code files to monitor accesses to dynamically allocated memory |
US5265254A (en) | 1991-08-14 | 1993-11-23 | Hewlett-Packard Company | System of debugging software through use of code markers inserted into spaces in the source code during and after compilation |
US5297274A (en) * | 1991-04-15 | 1994-03-22 | International Business Machines Corporation | Performance analysis of program in multithread OS by creating concurrently running thread generating breakpoint interrupts to active tracing monitor |
US5347649A (en) * | 1989-05-12 | 1994-09-13 | International Business Machines Corp. | System for dynamically generating, correlating and reading multiprocessing trace data in a shared memory |
US5386565A (en) | 1990-01-23 | 1995-01-31 | Hitachi, Ltd. | Method and system for controlling/monitoring computer system having plural operating systems to run thereon |
US5386522A (en) | 1991-12-30 | 1995-01-31 | International Business Machines, Corp. | Dynamic physical address aliasing during program debugging |
US5394544A (en) | 1989-08-07 | 1995-02-28 | Ricoh Co., Ltd. | Software system debugger with distinct interrupt vector maps for debugging and application programs |
US5408650A (en) | 1993-06-29 | 1995-04-18 | Digital Equipment Corporation | Memory analysis system for dynamically displaying memory allocation and de-allocation events associated with an application program |
US5410685A (en) | 1990-06-12 | 1995-04-25 | Regents Of The University Of Michigan | Non-intrinsive method and system for recovering the state of a computer system and non-intrusive debugging method and system utilizing same |
US5421009A (en) | 1993-12-22 | 1995-05-30 | Hewlett-Packard Company | Method of remotely installing software directly from a central computer |
US5446876A (en) | 1994-04-15 | 1995-08-29 | International Business Machines Corporation | Hardware mechanism for instruction/data address tracing |
US5450586A (en) | 1991-08-14 | 1995-09-12 | Hewlett-Packard Company | System for analyzing and debugging embedded software through dynamic and interactive use of code markers |
US5465258A (en) * | 1989-11-13 | 1995-11-07 | Integrity Systems, Inc. | Binary image performance evaluation tool |
US5481740A (en) | 1986-04-14 | 1996-01-02 | National Instruments Corporation | Method and apparatus for providing autoprobe features in a graphical data flow diagram |
WO1996005556A1 (en) | 1994-08-10 | 1996-02-22 | Intrinsa Corporation | Computer process resource modelling method and apparatus |
US5526485A (en) | 1994-10-13 | 1996-06-11 | Microsoft Corporation | Just-in-time debugging system and methods under the windows 3.0 and windows 3.1 operating systems |
US5533192A (en) | 1994-04-21 | 1996-07-02 | Apple Computer, Inc. | Computer program debugging system and method |
US5551037A (en) * | 1993-11-19 | 1996-08-27 | Lucent Technologies Inc. | Apparatus and methods for visualizing operation of a system of processes |
US5581697A (en) | 1994-01-28 | 1996-12-03 | Sun Microsystems, Inc. | Method and apparatus for run-time error checking using dynamic patching |
US5590354A (en) | 1993-07-28 | 1996-12-31 | U.S. Philips Corporation | Microcontroller provided with hardware for supporting debugging as based on boundary scan standard-type extensions |
US5612898A (en) | 1995-02-09 | 1997-03-18 | Intel Corporation | Communication protocol event logging system for use with various protocols |
US5615331A (en) | 1994-06-23 | 1997-03-25 | Phoenix Technologies Ltd. | System and method for debugging a computing system |
US5632032A (en) | 1994-02-07 | 1997-05-20 | International Business Machines Corporation | Cross address space thread control in a multithreaded environment |
US5642478A (en) | 1994-12-29 | 1997-06-24 | International Business Machines Corporation | Distributed trace data acquisition system |
US5657438A (en) * | 1990-11-27 | 1997-08-12 | Mercury Interactive (Israel) Ltd. | Interactive system for developing tests of system under test allowing independent positioning of execution start and stop markers to execute subportion of test script |
US5740355A (en) | 1995-10-27 | 1998-04-14 | Fujitsu Ltd. | Transaction tracing apparatus |
US5771385A (en) * | 1996-03-29 | 1998-06-23 | Sun Microsystems, Inc. | Setting and getting system debug flags by name at runtime |
US5867643A (en) * | 1995-11-06 | 1999-02-02 | Apple Computer, Inc. | Run-time data type description mechanism for performance information in an extensible computer system |
US5903718A (en) | 1996-09-16 | 1999-05-11 | International Business Machines Corporation | Remote program monitor method and system using a system-under-test microcontroller for self-debug |
US5928369A (en) | 1996-06-28 | 1999-07-27 | Synopsys, Inc. | Automatic support system and method based on user submitted stack trace |
US5940618A (en) * | 1997-09-22 | 1999-08-17 | International Business Machines Corporation | Code instrumentation system with non intrusive means and cache memory optimization for dynamic monitoring of code segments |
US5938778A (en) * | 1997-11-10 | 1999-08-17 | International Business Machines Corporation | System and method for tracing instructions in an information handling system without changing the system source code |
US5983366A (en) * | 1997-03-19 | 1999-11-09 | Optimay Corporation | Data processing system having monitoring of software activity |
US6003143A (en) * | 1994-06-30 | 1999-12-14 | Compaq Computer Corporation | Tool and method for diagnosing and correcting errors in a computer program |
US6202199B1 (en) * | 1997-07-31 | 2001-03-13 | Mutek Solutions, Ltd. | System and method for remotely analyzing the execution of computer programs |
-
1998
- 1998-07-30 US US09/126,126 patent/US6282701B1/en not_active Expired - Lifetime
Patent Citations (41)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4511960A (en) | 1982-01-15 | 1985-04-16 | Honeywell Information Systems Inc. | Data processing system auto address development logic for multiword fetch |
US4503495A (en) | 1982-01-15 | 1985-03-05 | Honeywell Information Systems Inc. | Data processing system common bus utilization detection logic |
US4598364A (en) | 1983-06-29 | 1986-07-01 | International Business Machines Corporation | Efficient trace method adaptable to multiprocessors |
US4782461A (en) | 1984-06-21 | 1988-11-01 | Step Engineering | Logical grouping of facilities within a computer development system |
US5481740A (en) | 1986-04-14 | 1996-01-02 | National Instruments Corporation | Method and apparatus for providing autoprobe features in a graphical data flow diagram |
US5121489A (en) | 1988-08-02 | 1992-06-09 | International Business Machines Corporation | Tracing method for identifying program execution paths using a trace points bit map with one-to-one correspondence with embedded trace points |
US5347649A (en) * | 1989-05-12 | 1994-09-13 | International Business Machines Corp. | System for dynamically generating, correlating and reading multiprocessing trace data in a shared memory |
US5394544A (en) | 1989-08-07 | 1995-02-28 | Ricoh Co., Ltd. | Software system debugger with distinct interrupt vector maps for debugging and application programs |
US5465258A (en) * | 1989-11-13 | 1995-11-07 | Integrity Systems, Inc. | Binary image performance evaluation tool |
US5386565A (en) | 1990-01-23 | 1995-01-31 | Hitachi, Ltd. | Method and system for controlling/monitoring computer system having plural operating systems to run thereon |
US5410685A (en) | 1990-06-12 | 1995-04-25 | Regents Of The University Of Michigan | Non-intrinsive method and system for recovering the state of a computer system and non-intrusive debugging method and system utilizing same |
US5657438A (en) * | 1990-11-27 | 1997-08-12 | Mercury Interactive (Israel) Ltd. | Interactive system for developing tests of system under test allowing independent positioning of execution start and stop markers to execute subportion of test script |
US5297274A (en) * | 1991-04-15 | 1994-03-22 | International Business Machines Corporation | Performance analysis of program in multithread OS by creating concurrently running thread generating breakpoint interrupts to active tracing monitor |
US5335344A (en) | 1991-06-21 | 1994-08-02 | Pure Software Inc. | Method for inserting new machine instructions into preexisting machine code to monitor preexisting machine access to memory |
US5193180A (en) * | 1991-06-21 | 1993-03-09 | Pure Software Inc. | System for modifying relocatable object code files to monitor accesses to dynamically allocated memory |
US5450586A (en) | 1991-08-14 | 1995-09-12 | Hewlett-Packard Company | System for analyzing and debugging embedded software through dynamic and interactive use of code markers |
US5265254A (en) | 1991-08-14 | 1993-11-23 | Hewlett-Packard Company | System of debugging software through use of code markers inserted into spaces in the source code during and after compilation |
US5386522A (en) | 1991-12-30 | 1995-01-31 | International Business Machines, Corp. | Dynamic physical address aliasing during program debugging |
US5408650A (en) | 1993-06-29 | 1995-04-18 | Digital Equipment Corporation | Memory analysis system for dynamically displaying memory allocation and de-allocation events associated with an application program |
US5590354A (en) | 1993-07-28 | 1996-12-31 | U.S. Philips Corporation | Microcontroller provided with hardware for supporting debugging as based on boundary scan standard-type extensions |
US5551037A (en) * | 1993-11-19 | 1996-08-27 | Lucent Technologies Inc. | Apparatus and methods for visualizing operation of a system of processes |
US5421009A (en) | 1993-12-22 | 1995-05-30 | Hewlett-Packard Company | Method of remotely installing software directly from a central computer |
US5581697A (en) | 1994-01-28 | 1996-12-03 | Sun Microsystems, Inc. | Method and apparatus for run-time error checking using dynamic patching |
US5632032A (en) | 1994-02-07 | 1997-05-20 | International Business Machines Corporation | Cross address space thread control in a multithreaded environment |
US5446876A (en) | 1994-04-15 | 1995-08-29 | International Business Machines Corporation | Hardware mechanism for instruction/data address tracing |
US5533192A (en) | 1994-04-21 | 1996-07-02 | Apple Computer, Inc. | Computer program debugging system and method |
US5615331A (en) | 1994-06-23 | 1997-03-25 | Phoenix Technologies Ltd. | System and method for debugging a computing system |
US6003143A (en) * | 1994-06-30 | 1999-12-14 | Compaq Computer Corporation | Tool and method for diagnosing and correcting errors in a computer program |
WO1996005556A1 (en) | 1994-08-10 | 1996-02-22 | Intrinsa Corporation | Computer process resource modelling method and apparatus |
US5526485A (en) | 1994-10-13 | 1996-06-11 | Microsoft Corporation | Just-in-time debugging system and methods under the windows 3.0 and windows 3.1 operating systems |
US5642478A (en) | 1994-12-29 | 1997-06-24 | International Business Machines Corporation | Distributed trace data acquisition system |
US5612898A (en) | 1995-02-09 | 1997-03-18 | Intel Corporation | Communication protocol event logging system for use with various protocols |
US5740355A (en) | 1995-10-27 | 1998-04-14 | Fujitsu Ltd. | Transaction tracing apparatus |
US5867643A (en) * | 1995-11-06 | 1999-02-02 | Apple Computer, Inc. | Run-time data type description mechanism for performance information in an extensible computer system |
US5771385A (en) * | 1996-03-29 | 1998-06-23 | Sun Microsystems, Inc. | Setting and getting system debug flags by name at runtime |
US5928369A (en) | 1996-06-28 | 1999-07-27 | Synopsys, Inc. | Automatic support system and method based on user submitted stack trace |
US5903718A (en) | 1996-09-16 | 1999-05-11 | International Business Machines Corporation | Remote program monitor method and system using a system-under-test microcontroller for self-debug |
US5983366A (en) * | 1997-03-19 | 1999-11-09 | Optimay Corporation | Data processing system having monitoring of software activity |
US6202199B1 (en) * | 1997-07-31 | 2001-03-13 | Mutek Solutions, Ltd. | System and method for remotely analyzing the execution of computer programs |
US5940618A (en) * | 1997-09-22 | 1999-08-17 | International Business Machines Corporation | Code instrumentation system with non intrusive means and cache memory optimization for dynamic monitoring of code segments |
US5938778A (en) * | 1997-11-10 | 1999-08-17 | International Business Machines Corporation | System and method for tracing instructions in an information handling system without changing the system source code |
Non-Patent Citations (22)
Title |
---|
Bates, P.C., "Debugging Heterogeneous Distributed Systems Using Event-Based Models of Behavior", ACM Transactions on Computer Systems, vol. 13, No. 1, Feb. 1995, pp. 1-31. |
Bruegge, B., Gottschalk, T., and Luo B., "A Framework for Dynamic Program Analyzers", OOPSLA, 1993, pp. 62-85. |
Geer, C. P. et al., IBM Technical Disclosure Bulletin: Instruction Stream Trace, vol. 26, No. 11, Apr. 1984, pp. 6217-6220. |
Harward, Jr., L.D., IBM Technical Disclosure Bulletin: PL/1 Trace Program, vol. 13, No. 4. Sep. 1970, pp. 855-857. |
Hunt, T. A., IBM Technical Disclosure Bulletin: General Trace Facility, vol. 15, No. 8, Jan. 1973, pp. 2446-2448. |
Larus, James R., "Efficient Program Tracing," IEEE Software magazine, May 1993, pp. 52-61. |
Malony, Allen D. et al., "Traceview: A Trace Visualization Tool," IEEE Software magazine, Sep. 1991, pp. 19-28. |
Martonosi, Margaret et al., "Effectiveness of Trace Sampling for Performance Debugging Tools" article, 1993, pp. 248-259. |
Meier, M.S., Miller, K.L. and Pazel, D.P., "Experiences with Building Distributed Debuggers", SPDT, 1996, pp. 70-79. |
Mukherjea, S. and Stasko J.T., "Applying Algorithm Animation Techniques for Program Tracing, Debugging, and Understanding", IEEE, 1993 pp. 456-465. |
Netzer, R.H.B., and Miller, B.P., "Optimal Tracing and Replay for Debugging Message-Passing Parallel Programs", IEEE, 1992, pp. 502-511. |
Netzer, Robert H. B. et al., "Optimal Tracing and Incremental Reexecution for Debugging Long-Running Programs," ACM SIGPLAN '94 Conference on Programming Language Design and Implementation (PLDI), Jun. 20-24, 1994, Orlando Florida, pp. 313-325. |
Netzer, Robert H. B., "Optial Tracing and Replay for Debugging Shared-Memory Parallel Programs," ACM/ONR Workshop on Parallel and Distributed Debugging, May 17-18, 1993, San Diego, California, pp. 1-12. |
Plattner, Bernhard et al., "Monitoring Program Execution: A Survey" article, IEEE Software magazine, Nov. 1981, pp. 76-93. |
Reiss, Steven P., "Trace-Based Debugging," Automated and Algorithmic Debugging Workshop, May 3-5, 1993, Linköping, Sweden, pp. 305-314. |
Rosenberg, Jonathan B., How Debuggers Work: Algorithms, Data Structures, and Architecture, John Wiley & Sons, Inc., 1996. |
Schieber, Colleen D. et al., "Ratchet: Real-time Address Trace Compression Hardware for Extended Traces," Performance Evaluation Review, vol. 21, #3 and 4, Apr. 1994, pp. 22-32. |
Soule, K., IBM Technical Disclosure Bulletin: Algorithm For Tracing Execution Paths to a Given Location in a Program, vol. 14, No. 4, Sep. 1971, pp. 1016-1019. |
Spinellis, Diomidis, "Trace: A Tool for Logging Operating System Call Transaction," Operating Systems Review publication, vol. 28, No. 4, Oct. 1994, pp. 56-63. |
Timmerman, M. et al., "High Level Tools for the Debugging of Real-Time Multiprocessor Systems," ACM/ONR Workshop on Parallel and Distributed Debugging, May 17-18, 1993, San Diego, California, pp. 151-158. |
Tsai, Jeffrey J. P. et al., "A Noninvasive Architecture to Monitor Real-Time Distributed Systems," IEEE Software magazine, Mar. 1990, pp. 11-23. |
Wilner, David, "WindView: A Tool for Understanding Real-time Embedded Software Through System Vizualization," ACM SIGPLAN Notices, vol. 30, No. 11, Nov. 1995, pp. 117-123. |
Cited By (654)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6721941B1 (en) * | 1996-08-27 | 2004-04-13 | Compuware Corporation | Collection of timing and coverage data through a debugging interface |
US8156312B2 (en) | 1996-12-09 | 2012-04-10 | Martin Vorbach | Processor chip for reconfigurable data processing, for processing numeric and logic operations and including function and interconnection control units |
US7822968B2 (en) | 1996-12-09 | 2010-10-26 | Martin Vorbach | Circuit having a multidimensional structure of configurable cells that include multi-bit-wide inputs and outputs |
US8195856B2 (en) | 1996-12-20 | 2012-06-05 | Martin Vorbach | I/O and memory bus system for DFPS and units with two- or multi-dimensional programmable cell architectures |
US7650448B2 (en) | 1996-12-20 | 2010-01-19 | Pact Xpp Technologies Ag | I/O and memory bus system for DFPS and units with two- or multi-dimensional programmable cell architectures |
US7899962B2 (en) | 1996-12-20 | 2011-03-01 | Martin Vorbach | I/O and memory bus system for DFPs and units with two- or multi-dimensional programmable cell architectures |
US7822881B2 (en) | 1996-12-27 | 2010-10-26 | Martin Vorbach | Process for automatic dynamic reloading of data flow processors (DFPs) and units with two- or three-dimensional programmable cell architectures (FPGAs, DPGAs, and the like) |
USRE45223E1 (en) | 1997-02-08 | 2014-10-28 | Pact Xpp Technologies Ag | Method of self-synchronization of configurable elements of a programmable module |
USRE44365E1 (en) | 1997-02-08 | 2013-07-09 | Martin Vorbach | Method of self-synchronization of configurable elements of a programmable module |
USRE45109E1 (en) | 1997-02-08 | 2014-09-02 | Pact Xpp Technologies Ag | Method of self-synchronization of configurable elements of a programmable module |
US7386522B1 (en) | 1997-03-21 | 2008-06-10 | International Business Machines Corporation | Optimizing the performance of computer tasks using intelligent agent with multiple program modules having varied degrees of domain knowledge |
US7908225B1 (en) | 1997-03-21 | 2011-03-15 | International Business Machines Corporation | Intelligent agent with negotiation capability and method of negotiation therewith |
US20050015775A1 (en) * | 1997-10-28 | 2005-01-20 | Microsoft Corporation | Software component execution management using context objects for tracking externally-defined intrinsic properties of executing software components within an execution environment |
US6553564B1 (en) * | 1997-12-12 | 2003-04-22 | International Business Machines Corporation | Process and system for merging trace data for primarily interpreted methods |
US6513155B1 (en) * | 1997-12-12 | 2003-01-28 | International Business Machines Corporation | Method and system for merging event-based data and sampled data into postprocessed trace output |
US6662358B1 (en) * | 1997-12-12 | 2003-12-09 | International Business Machines Corporation | Minimizing profiling-related perturbation using periodic contextual information |
US7584390B2 (en) | 1997-12-22 | 2009-09-01 | Pact Xpp Technologies Ag | Method and system for alternating between programs for execution by cells of an integrated circuit |
US8819505B2 (en) | 1997-12-22 | 2014-08-26 | Pact Xpp Technologies Ag | Data processor having disabled cores |
US20020023260A1 (en) * | 1997-12-23 | 2002-02-21 | Ab Initio Software Corporation | Method for analyzing capacity of parallel processing systems |
US6665862B2 (en) * | 1997-12-23 | 2003-12-16 | Ab Initio Software Corporation | Method for analyzing capacity of parallel processing systems |
US6996516B1 (en) * | 1998-02-05 | 2006-02-07 | Ns Solutions Corporation | Apparatus for analyzing software and method of the same |
US6499048B1 (en) | 1998-06-30 | 2002-12-24 | Sun Microsystems, Inc. | Control of multiple computer processes using a mutual exclusion primitive ordering mechanism |
US6754891B1 (en) * | 1998-08-31 | 2004-06-22 | Red Hat, Inc. | Debugger system using tracepoints for computer software |
US7103883B2 (en) * | 1998-10-29 | 2006-09-05 | Texas Instruments Incorporated | System and method for translating include files |
US20050034024A1 (en) * | 1998-11-13 | 2005-02-10 | Alverson Gail A. | Debugging techniques in a multithreaded environment |
US6848097B1 (en) * | 1998-11-13 | 2005-01-25 | Cray Inc. | Debugging techniques in a multithreaded environment |
US7428727B2 (en) | 1998-11-13 | 2008-09-23 | Cray Inc. | Debugging techniques in a multithreaded environment |
US6964010B1 (en) * | 1998-12-14 | 2005-11-08 | International Business Machines Corporation | Formatted-item list control |
US6658622B1 (en) * | 1998-12-14 | 2003-12-02 | International Business Machines Corporation | Self-diagnosing and self-correcting data entry components with dependency behavior |
US7739667B2 (en) | 1998-12-23 | 2010-06-15 | Cray Inc. | Parallelism performance analysis based on execution trace information |
US20020129339A1 (en) * | 1998-12-23 | 2002-09-12 | Callahan Charles David | Parallelism performance analysis based on execution trace information |
US6961925B2 (en) * | 1998-12-23 | 2005-11-01 | Cray Inc. | Parallelism performance analysis based on execution trace information |
US20060101416A1 (en) * | 1998-12-23 | 2006-05-11 | Callahan Charles D Ii | Parallelism performance analysis based on execution trace information |
US6593940B1 (en) * | 1998-12-23 | 2003-07-15 | Intel Corporation | Method for finding errors in multithreaded applications |
US6785883B1 (en) * | 1999-01-19 | 2004-08-31 | Siemens Aktiengesellschaft | Software system for tracing data |
US6587967B1 (en) * | 1999-02-22 | 2003-07-01 | International Business Machines Corporation | Debugger thread monitor |
US6378124B1 (en) | 1999-02-22 | 2002-04-23 | International Business Machines Corporation | Debugger thread synchronization control points |
US8468329B2 (en) | 1999-02-25 | 2013-06-18 | Martin Vorbach | Pipeline configuration protocol and configuration unit communication |
US6526567B1 (en) * | 1999-03-24 | 2003-02-25 | International Business Machines Corporation | System and method for optimizing a device driver by incorporating debugging and tracing |
US20050216915A1 (en) * | 1999-04-05 | 2005-09-29 | Microsoft Corporation | Method of ranking messages generated in a computer system |
US6434738B1 (en) * | 1999-04-22 | 2002-08-13 | David Arnow | System and method for testing computer software |
US7861178B2 (en) | 1999-05-07 | 2010-12-28 | Knoa Software, Inc. | System and method for dynamic assistance in software applications using behavior and host application models |
US6934947B1 (en) * | 1999-05-10 | 2005-08-23 | Robert Zeidman | Visual tool for developing real time task management code |
US20020138753A1 (en) * | 1999-05-11 | 2002-09-26 | Munson John C. | Method and system for simplifying the structure of dynamic execution profiles |
US20040143756A1 (en) * | 1999-05-11 | 2004-07-22 | Munson John C. | Method of and system for detecting an anomalous operation of a computer system |
US6963983B2 (en) | 1999-05-11 | 2005-11-08 | Cylant, Inc. | Method of and system for detecting an anomalous operation of a computer system |
US7185367B2 (en) | 1999-05-11 | 2007-02-27 | Cylant, Inc. | Method and system for establishing normal software system behavior and departures from normal behavior |
US7096499B2 (en) | 1999-05-11 | 2006-08-22 | Cylant, Inc. | Method and system for simplifying the structure of dynamic execution profiles |
US6681331B1 (en) | 1999-05-11 | 2004-01-20 | Cylant, Inc. | Dynamic software system intrusion detection |
US8726250B2 (en) | 1999-06-10 | 2014-05-13 | Pact Xpp Technologies Ag | Configurable logic integrated circuit having a multidimensional structure of configurable elements |
US8312200B2 (en) | 1999-06-10 | 2012-11-13 | Martin Vorbach | Processor chip including a plurality of cache elements connected to a plurality of processor cores |
US8230411B1 (en) | 1999-06-10 | 2012-07-24 | Martin Vorbach | Method for interleaving a program over a plurality of cells |
US6412106B1 (en) | 1999-06-16 | 2002-06-25 | Intervoice Limited Partnership | Graphical system and method for debugging computer programs |
US6772106B1 (en) * | 1999-08-20 | 2004-08-03 | Hewlett-Packard Development Company, L.P. | Retargetable computer design system |
US6493834B1 (en) * | 1999-08-24 | 2002-12-10 | International Business Machines Corporation | Apparatus and method for dynamically defining exception handlers in a debugger |
US7343563B2 (en) | 1999-08-31 | 2008-03-11 | Intel Corporation | Graphical user interface |
US20040095398A1 (en) * | 1999-08-31 | 2004-05-20 | Intel Corporation, A Santa Clara Corporation | Graphical user interface |
US6611276B1 (en) * | 1999-08-31 | 2003-08-26 | Intel Corporation | Graphical user interface that displays operation of processor threads over time |
US20040225923A1 (en) * | 1999-09-09 | 2004-11-11 | Microsoft Corporation | Object-based software management |
US7240244B2 (en) | 1999-09-09 | 2007-07-03 | Microsoft Corporation | Object-based software management |
US20040225668A1 (en) * | 1999-09-09 | 2004-11-11 | Microsoft Corporation | Object-based software management |
US7243271B2 (en) | 1999-09-09 | 2007-07-10 | Microsoft Corporation | Wrapped object for observing object events |
US6871348B1 (en) * | 1999-09-15 | 2005-03-22 | Intel Corporation | Method and apparatus for integrating the user interfaces of multiple applications into one application |
US6859898B1 (en) * | 1999-09-30 | 2005-02-22 | Toyoda Koki Kabushiki Kaisha | Monitor apparatus for sequential-function-chart-type programmable controller |
US6918065B1 (en) | 1999-10-01 | 2005-07-12 | Hitachi, Ltd. | Method for compressing and decompressing trace information |
US6684348B1 (en) * | 1999-10-01 | 2004-01-27 | Hitachi, Ltd. | Circuit for processing trace information |
US6615370B1 (en) * | 1999-10-01 | 2003-09-02 | Hitachi, Ltd. | Circuit for storing trace information |
US6732307B1 (en) | 1999-10-01 | 2004-05-04 | Hitachi, Ltd. | Apparatus and method for storing trace information |
US6701460B1 (en) * | 1999-10-21 | 2004-03-02 | Sun Microsystems, Inc. | Method and apparatus for testing a computer system through software fault injection |
US6978303B1 (en) * | 1999-10-26 | 2005-12-20 | Iontal Limited | Monitoring of computer usage |
US6539500B1 (en) * | 1999-10-28 | 2003-03-25 | International Business Machines Corporation | System and method for tracing |
US6715140B1 (en) * | 1999-11-18 | 2004-03-30 | Fujitsu Limited | Program trace method and apparatus, and storage medium |
US6944614B1 (en) * | 1999-11-24 | 2005-09-13 | Ncr Corporation | Query monitor playback mechanism for post-mortem performance analysis |
US6883120B1 (en) | 1999-12-03 | 2005-04-19 | Network Appliance, Inc. | Computer assisted automatic error detection and diagnosis of file servers |
US6427233B1 (en) * | 1999-12-17 | 2002-07-30 | Inventec Corporation | Method for addressing the dynamic windows |
US6681384B1 (en) * | 1999-12-23 | 2004-01-20 | International Business Machines Corporation | Multi-threaded break-point |
US7058928B2 (en) | 1999-12-23 | 2006-06-06 | Identify Software Ltd. | System and method for conditional tracing of computer programs |
US20040205704A1 (en) * | 1999-12-27 | 2004-10-14 | Miller Donald W. | Transparent monitoring system and method for examining an executing program in real time |
US20040220774A1 (en) * | 1999-12-29 | 2004-11-04 | Anant Agarwal | Early warning mechanism for enhancing enterprise availability |
US20040221270A1 (en) * | 1999-12-29 | 2004-11-04 | Emmett Witchel | Method for determining the degree to which changed code has been exercised |
US7823134B2 (en) | 1999-12-29 | 2010-10-26 | Symantec Operating Corporation | Early warning mechanism for enhancing enterprise availability |
US7296261B2 (en) | 1999-12-29 | 2007-11-13 | Veritas Operating Corporation | Method for determining the degree to which changed code has been exercised |
US6748584B1 (en) * | 1999-12-29 | 2004-06-08 | Veritas Operating Corporation | Method for determining the degree to which changed code has been exercised |
US6745383B1 (en) | 1999-12-29 | 2004-06-01 | Veritas Operating Corporation | Early warning mechanism for enhancing enterprise availability |
US20040216092A1 (en) * | 1999-12-29 | 2004-10-28 | Ayers Andrew E | Method for simulating back program execution from a traceback sequence |
US6804814B1 (en) | 1999-12-29 | 2004-10-12 | Veritas Operating Corporation | Method for simulating back program execution from a traceback sequence |
US7543279B2 (en) * | 1999-12-29 | 2009-06-02 | Symantec Operating Corporation | Method for simulating back program execution from a traceback sequence |
US6598180B1 (en) * | 1999-12-30 | 2003-07-22 | International Business Machines Corporation | Method, system and program products for selectively debugging program versions executing with in a computing environment |
US8225397B1 (en) | 2000-01-27 | 2012-07-17 | Trapware Corporation | Detection of observers and countermeasures against observers |
US8176551B1 (en) * | 2000-01-27 | 2012-05-08 | Trapware Corporation | Detection of observer programs and countermeasures against observer programs |
US7076400B2 (en) | 2000-02-14 | 2006-07-11 | Nextnine Ltd. | Support network |
US7409318B2 (en) | 2000-02-14 | 2008-08-05 | Nextnine Ltd. | Support network |
US20060161394A1 (en) * | 2000-02-14 | 2006-07-20 | Nextnine, Inc. | Support network |
US20030005107A1 (en) * | 2000-02-14 | 2003-01-02 | Adi Dulberg | Support network |
US20070100585A1 (en) * | 2000-02-14 | 2007-05-03 | Nextnine Ltd. | Support Network |
US6701363B1 (en) * | 2000-02-29 | 2004-03-02 | International Business Machines Corporation | Method, computer program product, and system for deriving web transaction performance metrics |
US7055136B2 (en) * | 2000-03-02 | 2006-05-30 | Texas Instruments Incorporated | Configurable debug system with dynamic menus |
US20010034880A1 (en) * | 2000-03-02 | 2001-10-25 | Jonathan Dzoba | Configurable debug system using source and data objects |
US7593841B2 (en) * | 2000-03-02 | 2009-09-22 | Texas Instruments Incorporated | Emulation export sequence with distributed control |
US20070150255A1 (en) * | 2000-03-02 | 2007-06-28 | Texas Instruments Incorporated | Emulation export sequence with distributed control |
US20020004933A1 (en) * | 2000-03-02 | 2002-01-10 | Jonathan Dzoba | Configurable debug system with dynamic menus |
US8504994B2 (en) | 2000-03-03 | 2013-08-06 | Identify Software, Ltd. | System and method for software diagnostics using a combination of visual and dynamic tracing |
US20100088683A1 (en) * | 2000-03-03 | 2010-04-08 | Identify Software, Ltd. | System and method for software diagnostics using a combination of visual and dynamic tracing |
US7133820B2 (en) * | 2000-03-15 | 2006-11-07 | Arc International | Method and apparatus for debugging programs in a distributed environment |
US7779390B1 (en) * | 2000-04-21 | 2010-08-17 | Oracle America, Inc. | Thread-safe remote debugger |
US7228346B1 (en) | 2000-04-21 | 2007-06-05 | Sun Microsystems, Inc. | IDL event and request formatting for corba gateway |
US7478403B1 (en) | 2000-04-21 | 2009-01-13 | Sun Microsystems, Inc. | Secure access to managed network objects using a configurable platform-independent gateway providing individual object-level access control |
US6839748B1 (en) | 2000-04-21 | 2005-01-04 | Sun Microsystems, Inc. | Synchronous task scheduler for corba gateway |
US7783720B1 (en) | 2000-04-21 | 2010-08-24 | Oracle America, Inc. | CORBA metadata gateway to telecommunications management network |
US7206843B1 (en) | 2000-04-21 | 2007-04-17 | Sun Microsystems, Inc. | Thread-safe portable management interface |
US6950935B1 (en) | 2000-04-21 | 2005-09-27 | Sun Microsystems, Inc. | Pluggable authentication modules for telecommunications management network |
US7010586B1 (en) | 2000-04-21 | 2006-03-07 | Sun Microsystems, Inc. | System and method for event subscriptions for CORBA gateway |
US6813770B1 (en) | 2000-04-21 | 2004-11-02 | Sun Microsystems, Inc. | Abstract syntax notation to interface definition language converter framework for network management |
US6915324B1 (en) | 2000-04-21 | 2005-07-05 | Sun Microsystems, Inc. | Generic and dynamic mapping of abstract syntax notation (ASN1) to and from interface definition language for network management |
US7251810B1 (en) * | 2000-04-26 | 2007-07-31 | Microsoft Corporation | Minimal instrumentation for lossless call profiling |
US6836881B2 (en) * | 2000-05-19 | 2004-12-28 | International Business Machines Corporation | Remote tracing of data processing nodes in an asynchronous messaging network |
US20020049801A1 (en) * | 2000-05-19 | 2002-04-25 | International Business Machines Corporation | Remote tracing of data processing nodes in an asynchronous messaging network |
US8612925B1 (en) | 2000-06-13 | 2013-12-17 | Microsoft Corporation | Zero-footprint telephone application development |
US7140004B1 (en) * | 2000-06-13 | 2006-11-21 | Tellme Networks, Inc. | Method and apparatus for zero-footprint phone application development |
US8301872B2 (en) | 2000-06-13 | 2012-10-30 | Martin Vorbach | Pipeline configuration protocol and configuration unit communication |
US6754612B1 (en) * | 2000-06-29 | 2004-06-22 | Microsoft Corporation | Performance markers to measure benchmark timing of a plurality of standard features in an application program |
US7032214B1 (en) | 2000-06-29 | 2006-04-18 | Microsoft Corporation | Performance markers to measure performance of features in a program |
US7240334B1 (en) * | 2000-06-29 | 2007-07-03 | International Business Machines Corporation | Methods, systems, and computer program products for deferred computer program tracing |
US6873934B1 (en) * | 2000-06-29 | 2005-03-29 | Microsoft Corporation | Performance markers to measure benchmark timing of features in a program |
US6678883B1 (en) * | 2000-07-10 | 2004-01-13 | International Business Machines Corporation | Apparatus and method for creating a trace file for a trace of a computer program based on loaded module information |
US6658416B1 (en) * | 2000-07-10 | 2003-12-02 | International Business Machines Corporation | Apparatus and method for creating an indexed database of symbolic data for use with trace data of a computer program |
US6988263B1 (en) | 2000-07-10 | 2006-01-17 | International Business Machines Corporation | Apparatus and method for cataloging symbolic data for use in performance analysis of computer programs |
US20020073400A1 (en) * | 2000-07-26 | 2002-06-13 | Michael Beuten | Method for monitoring a program execution using a debug logic |
US7712084B2 (en) * | 2000-07-26 | 2010-05-04 | Robert Bosch Gmbh | Method for monitoring a program execution using a debug logic |
US6978444B1 (en) * | 2000-08-01 | 2005-12-20 | International Business Machines Corporation | Computer-implemented method and system for automatically invoking a predetermined debugger command at a desired location of a single thread of a program |
US20050144507A1 (en) * | 2000-09-19 | 2005-06-30 | Kuo-Chun Lee | Method and apparatus for remotely debugging an application program over the internet |
US6820253B1 (en) * | 2000-09-27 | 2004-11-16 | Intel Corporation | Method and system for interprocedural analysis with separate compilation |
US8058899B2 (en) | 2000-10-06 | 2011-11-15 | Martin Vorbach | Logic cell array and bus system |
US9047440B2 (en) | 2000-10-06 | 2015-06-02 | Pact Xpp Technologies Ag | Logical cell array and bus system |
US8471593B2 (en) | 2000-10-06 | 2013-06-25 | Martin Vorbach | Logic cell array and bus system |
US20020049962A1 (en) * | 2000-10-23 | 2002-04-25 | Michael Kelbaugh | Product testing and bug tracking system |
US7657872B2 (en) * | 2000-10-23 | 2010-02-02 | Nintendo Of America Inc. | Product testing and bug tracking system |
US7234139B1 (en) | 2000-11-24 | 2007-06-19 | Catharon Productions, Inc. | Computer multi-tasking via virtual threading using an interpreter |
WO2003007105A3 (en) * | 2000-11-24 | 2003-09-12 | Catharon Productions Inc | Computer multi-tasking via virtual threading |
WO2003007105A2 (en) * | 2000-11-24 | 2003-01-23 | Catharon Productions, Inc. | Computer multi-tasking via virtual threading |
US6961923B2 (en) * | 2000-12-07 | 2005-11-01 | International Business Machines Corporation | Method of detecting zombie breakpoints |
US20020073401A1 (en) * | 2000-12-07 | 2002-06-13 | International Business Machines Corporation | Method of detecting zombie breakpoints |
US20020091974A1 (en) * | 2000-12-18 | 2002-07-11 | Szydlowski Craig P. | Method and apparatus for interfacing application system via the internet |
US6856978B2 (en) * | 2000-12-18 | 2005-02-15 | Intel Corporation | Method and apparatus for interfacing application systems via the internet |
US6738083B2 (en) * | 2000-12-20 | 2004-05-18 | Siemens Information And Communication Networks, Inc. | Method and system of displaying telecommunication trace diagnostic information |
US20060242627A1 (en) * | 2000-12-26 | 2006-10-26 | Shlomo Wygodny | System and method for conditional tracing of computer programs |
US8312435B2 (en) * | 2000-12-26 | 2012-11-13 | Identify Software Ltd. (IL) | System and method for conditional tracing of computer programs |
US6817010B2 (en) * | 2000-12-27 | 2004-11-09 | International Business Machines Corporation | Monitoring messages during execution of a message flow |
US20020120918A1 (en) * | 2000-12-27 | 2002-08-29 | International Business Machines Corporation | Monitoring messages during execution of a message flow |
US20020120919A1 (en) * | 2000-12-27 | 2002-08-29 | International Business Machines Corporation | Monitoring execution of an hierarchical visual program such as for debugging a message flow |
US6748583B2 (en) * | 2000-12-27 | 2004-06-08 | International Business Machines Corporation | Monitoring execution of an hierarchical visual program such as for debugging a message flow |
US7698533B2 (en) | 2000-12-29 | 2010-04-13 | Mips Technologies, Inc. | Configurable co-processor interface |
US20050038975A1 (en) * | 2000-12-29 | 2005-02-17 | Mips Technologies, Inc. | Configurable co-processor interface |
US7237090B1 (en) | 2000-12-29 | 2007-06-26 | Mips Technologies, Inc. | Configurable out-of-order data transfer in a coprocessor interface |
US7886129B2 (en) | 2000-12-29 | 2011-02-08 | Mips Technologies, Inc. | Configurable co-processor interface |
US7287147B1 (en) | 2000-12-29 | 2007-10-23 | Mips Technologies, Inc. | Configurable co-processor interface |
US7194599B2 (en) | 2000-12-29 | 2007-03-20 | Mips Technologies, Inc. | Configurable co-processor interface |
US8099618B2 (en) | 2001-03-05 | 2012-01-17 | Martin Vorbach | Methods and devices for treating and processing data |
US8312301B2 (en) | 2001-03-05 | 2012-11-13 | Martin Vorbach | Methods and devices for treating and processing data |
US9037807B2 (en) | 2001-03-05 | 2015-05-19 | Pact Xpp Technologies Ag | Processor arrangement on a chip including data processing, memory, and interface elements |
US9075605B2 (en) | 2001-03-05 | 2015-07-07 | Pact Xpp Technologies Ag | Methods and devices for treating and processing data |
US8145881B2 (en) | 2001-03-05 | 2012-03-27 | Martin Vorbach | Data processing device and method |
US7844796B2 (en) | 2001-03-05 | 2010-11-30 | Martin Vorbach | Data processing device and method |
US7539950B2 (en) * | 2001-04-20 | 2009-05-26 | Microsoft Corporation | Method and system for displaying categorized information on a user interface |
US7689937B2 (en) * | 2001-04-20 | 2010-03-30 | Microsoft Corporation | Method and system for displaying categorized information on a user interface |
US20060005149A1 (en) * | 2001-04-20 | 2006-01-05 | Microsoft Corporation | Method and system for displaying categorized information on a user interface |
US20060005150A1 (en) * | 2001-04-20 | 2006-01-05 | Microsoft Corporation | Method and system for displaying categorized information on a user interface |
US7644319B2 (en) | 2001-04-30 | 2010-01-05 | Mips Technologies, Inc. | Trace control from hardware and software |
US7124072B1 (en) | 2001-04-30 | 2006-10-17 | Mips Technologies, Inc. | Program counter and data tracing from a multi-issue processor |
US7069544B1 (en) | 2001-04-30 | 2006-06-27 | Mips Technologies, Inc. | Dynamic selection of a compression algorithm for trace data |
US20090037704A1 (en) * | 2001-04-30 | 2009-02-05 | Mips Technologies, Inc. | Trace control from hardware and software |
US7181728B1 (en) | 2001-04-30 | 2007-02-20 | Mips Technologies, Inc. | User controlled trace records |
US7168066B1 (en) | 2001-04-30 | 2007-01-23 | Mips Technologies, Inc. | Tracing out-of order load data |
US8185879B2 (en) | 2001-04-30 | 2012-05-22 | Mips Technologies, Inc. | External trace synchronization via periodic sampling |
US7770156B2 (en) | 2001-04-30 | 2010-08-03 | Mips Technologies, Inc. | Dynamic selection of a compression algorithm for trace data |
US20060225050A1 (en) * | 2001-04-30 | 2006-10-05 | Mips Technologies, Inc. | Dynamic selection of a compression algorithm for trace data |
US7185234B1 (en) * | 2001-04-30 | 2007-02-27 | Mips Technologies, Inc. | Trace control from hardware and software |
US7055070B1 (en) * | 2001-04-30 | 2006-05-30 | Mips Technologies, Inc. | Trace control block implementation and method |
US7178133B1 (en) | 2001-04-30 | 2007-02-13 | Mips Technologies, Inc. | Trace control based on a characteristic of a processor's operating state |
US20070180327A1 (en) * | 2001-04-30 | 2007-08-02 | Mips Technologies, Inc. | Trace control from hardware and software |
US7412630B2 (en) | 2001-04-30 | 2008-08-12 | Mips Technologies, Inc. | Trace control from hardware and software |
US7134116B1 (en) | 2001-04-30 | 2006-11-07 | Mips Technologies, Inc. | External trace synchronization via periodic sampling |
US7065675B1 (en) | 2001-05-08 | 2006-06-20 | Mips Technologies, Inc. | System and method for speeding up EJTAG block data transfers |
US20020174416A1 (en) * | 2001-05-15 | 2002-11-21 | International Business Machines Corporation | Storing and restoring snapshots of a computer process |
US20080216054A1 (en) * | 2001-05-15 | 2008-09-04 | International Business Machines Corporation | Storing and Restoring Snapshots of a Computer Process |
US8032868B2 (en) * | 2001-05-15 | 2011-10-04 | International Business Machines Corporation | Storing and restoring snapshots of a computer process |
US7383538B2 (en) * | 2001-05-15 | 2008-06-03 | International Business Machines Corporation | Storing and restoring snapshots of a computer process |
US7325234B2 (en) | 2001-05-25 | 2008-01-29 | Siemens Medical Solutions Health Services Corporation | System and method for monitoring computer application and resource utilization |
US20020178206A1 (en) * | 2001-05-25 | 2002-11-28 | Siemens Medical Solutions Health Services Corporation | System and method for monitoring computer application and resource utilization |
US7376937B1 (en) | 2001-05-31 | 2008-05-20 | Oracle International Corporation | Method and mechanism for using a meta-language to define and analyze traces |
US7380239B1 (en) * | 2001-05-31 | 2008-05-27 | Oracle International Corporation | Method and mechanism for diagnosing computer applications using traces |
US7516441B2 (en) * | 2001-06-04 | 2009-04-07 | Microsoft Corporation | Method and system for program editing and debugging in a common language runtime environment |
US20050034109A1 (en) * | 2001-06-04 | 2005-02-10 | Microsoft Corporation | Method and system for program editing |
US20100095094A1 (en) * | 2001-06-20 | 2010-04-15 | Martin Vorbach | Method for processing data |
US7657877B2 (en) | 2001-06-20 | 2010-02-02 | Pact Xpp Technologies Ag | Method for processing data |
US7043668B1 (en) | 2001-06-29 | 2006-05-09 | Mips Technologies, Inc. | Optimized external trace formats |
US7231551B1 (en) | 2001-06-29 | 2007-06-12 | Mips Technologies, Inc. | Distributed tap controller |
US20030014694A1 (en) * | 2001-07-03 | 2003-01-16 | Francois Draperi | Process monitor module |
US8869121B2 (en) | 2001-08-16 | 2014-10-21 | Pact Xpp Technologies Ag | Method for the translation of programs for reconfigurable architectures |
US7996827B2 (en) * | 2001-08-16 | 2011-08-09 | Martin Vorbach | Method for the translation of programs for reconfigurable architectures |
US20050091644A1 (en) * | 2001-08-24 | 2005-04-28 | Microsoft Corporation | System and method for using data address sequences of a program in a software development tool |
US7657876B2 (en) * | 2001-08-24 | 2010-02-02 | Microsoft Corporation | System and method for using data address sequences of a program in a software development tool |
US20030046667A1 (en) * | 2001-08-30 | 2003-03-06 | International Business Machines Corporation | Method and system for obtaining performance data from software compiled with or without trace hooks |
US6983453B2 (en) * | 2001-08-30 | 2006-01-03 | International Business Machines Corporation | Method and system for obtaining performance data from software compiled with or without trace hooks |
US7480825B2 (en) * | 2001-09-03 | 2009-01-20 | Pact Xpp Technologies Ag | Method for debugging reconfigurable architectures |
US8209653B2 (en) | 2001-09-03 | 2012-06-26 | Martin Vorbach | Router |
US8069373B2 (en) | 2001-09-03 | 2011-11-29 | Martin Vorbach | Method for debugging reconfigurable architectures |
US7840842B2 (en) | 2001-09-03 | 2010-11-23 | Martin Vorbach | Method for debugging reconfigurable architectures |
US8407525B2 (en) | 2001-09-03 | 2013-03-26 | Pact Xpp Technologies Ag | Method for debugging reconfigurable architectures |
US8686549B2 (en) | 2001-09-03 | 2014-04-01 | Martin Vorbach | Reconfigurable elements |
US8429385B2 (en) | 2001-09-03 | 2013-04-23 | Martin Vorbach | Device including a field having function cells and information providing cells controlled by the function cells |
US20030046664A1 (en) * | 2001-09-04 | 2003-03-06 | James Pangburn | Flexible horizontal stack display and editor |
US20070168986A1 (en) * | 2001-09-04 | 2007-07-19 | James Pangburn | Flexible horizontal stack display and editor |
US8250537B2 (en) | 2001-09-04 | 2012-08-21 | Mentor Graphics Corporation | Flexible horizontal stack display and editor |
US7152226B2 (en) | 2001-09-04 | 2006-12-19 | James Pangburn | Flexible horizontal stack display and editor |
US20030051194A1 (en) * | 2001-09-13 | 2003-03-13 | International Business Machines Corporation | Portable SCSI bus analyzer |
US8686475B2 (en) | 2001-09-19 | 2014-04-01 | Pact Xpp Technologies Ag | Reconfigurable elements |
US8473922B2 (en) * | 2001-09-19 | 2013-06-25 | Hewlett-Packard Development Company, L.P. | Runtime monitoring in component-based systems |
US20030056200A1 (en) * | 2001-09-19 | 2003-03-20 | Jun Li | Runtime monitoring in component-based systems |
US7660886B2 (en) * | 2001-09-27 | 2010-02-09 | International Business Machines Corporation | Apparatus and method of representing real-time distributed command execution status across distributed systems |
US20030061342A1 (en) * | 2001-09-27 | 2003-03-27 | International Business Machines Corporation | Apparatus and method of representing real-time distributed command execution status across distributed systems |
US7246267B2 (en) * | 2001-10-01 | 2007-07-17 | Tektronix, Inc. | Logic analyzer having a disassembler employing symbol table information for identifying op-codes |
US20030065976A1 (en) * | 2001-10-01 | 2003-04-03 | Bennett David L. | Logic analyzer having a disassembler employing symbol table information for identifying op-codes |
US20030079206A1 (en) * | 2001-10-18 | 2003-04-24 | International Business Machines Corporation | Debugger capable of providing warnings for unreachable breakpoints |
US6839893B2 (en) * | 2001-10-18 | 2005-01-04 | International Business Machines Corporation | Debugger capable of providing warnings for unreachable breakpoints |
US6832302B1 (en) * | 2001-10-24 | 2004-12-14 | At&T Corp. | Methods and apparatus for detecting heap smashing |
US7275048B2 (en) * | 2001-10-30 | 2007-09-25 | International Business Machines Corporation | Product support of computer-related products using intelligent agents |
US20030084009A1 (en) * | 2001-10-30 | 2003-05-01 | International Business Machines Corporation | Product support of computer-related products using intelligent agents |
US20050061221A1 (en) * | 2001-11-02 | 2005-03-24 | Mariusz Paszkowski | Superhydrophobic coating |
US20030131284A1 (en) * | 2002-01-07 | 2003-07-10 | Flanagan Cormac Andrias | Method and apparatus for organizing warning messages |
US6978443B2 (en) * | 2002-01-07 | 2005-12-20 | Hewlett-Packard Development Company, L.P. | Method and apparatus for organizing warning messages |
US20030131337A1 (en) * | 2002-01-07 | 2003-07-10 | Perumainar Asok K. | Educational method and tool for isolating and teaching programming language concepts |
US7168008B2 (en) * | 2002-01-18 | 2007-01-23 | Mobitv, Inc. | Method and system for isolating and protecting software components |
US20030145253A1 (en) * | 2002-01-18 | 2003-07-31 | De Bonet Jeremy S. | Method and system for isolating and protecting software components |
US8281108B2 (en) | 2002-01-19 | 2012-10-02 | Martin Vorbach | Reconfigurable general purpose processor having time restricted configurations |
US8127061B2 (en) | 2002-02-18 | 2012-02-28 | Martin Vorbach | Bus systems and reconfiguration methods |
US20030167421A1 (en) * | 2002-03-01 | 2003-09-04 | Klemm Reinhard P. | Automatic failure detection and recovery of applications |
US7243267B2 (en) * | 2002-03-01 | 2007-07-10 | Avaya Technology Llc | Automatic failure detection and recovery of applications |
US20040078734A1 (en) * | 2002-03-07 | 2004-04-22 | Andreas Deuter | Method for displaying error messages in software applications |
DE10210145A1 (en) * | 2002-03-07 | 2003-09-25 | Phoenix Contact Gmbh & Co | Procedures for displaying error messages in software applications |
US20030182655A1 (en) * | 2002-03-25 | 2003-09-25 | Hewlett Packard Company | Unwinding instrumented program code |
US7131115B2 (en) * | 2002-03-25 | 2006-10-31 | Hewlett-Packard Development Company, L.P. | Unwinding instrumented program code |
US20080059625A1 (en) * | 2002-03-29 | 2008-03-06 | Barnett Paul T | Method of semi-automatic data collection, data analysis, and model generation for the performance analysis of enterprise applications |
US7734775B2 (en) * | 2002-03-29 | 2010-06-08 | Hyperformix, Inc | Method of semi-automatic data collection, data analysis, and model generation for the performance analysis of enterprise applications |
US6981248B2 (en) * | 2002-05-02 | 2005-12-27 | International Business Machines Corporation | Conditional breakpoint encountered indication |
US20030208746A1 (en) * | 2002-05-02 | 2003-11-06 | International Business Machines Corporation | Conditional breakpoint encountered indication |
KR100433549B1 (en) * | 2002-05-11 | 2004-05-31 | 삼성전자주식회사 | Method and apparatus for analyzing software |
US7228175B2 (en) | 2002-05-15 | 2007-06-05 | Cardiac Pacemakers, Inc. | Cardiac rhythm management systems and methods using acoustic contractility indicator |
US20030217155A1 (en) * | 2002-05-20 | 2003-11-20 | Siemens Information And Communication Networks, Inc. | Send of software tracer messages via IP from several sources to be stored by a remote server |
US7451206B2 (en) * | 2002-05-20 | 2008-11-11 | Siemens Communications, Inc. | Send of software tracer messages via IP from several sources to be stored by a remote server |
EP1376365A2 (en) * | 2002-06-28 | 2004-01-02 | Canon Kabushiki Kaisha | Method for acquiring logs for program debugging |
EP1376366A2 (en) * | 2002-06-28 | 2004-01-02 | Canon Kabushiki Kaisha | Method for acquiring logs for program debugging |
US20050160431A1 (en) * | 2002-07-29 | 2005-07-21 | Oracle Corporation | Method and mechanism for debugging a series of related events within a computer system |
US7165190B1 (en) | 2002-07-29 | 2007-01-16 | Oracle International Corporation | Method and mechanism for managing traces within a computer system |
US7200588B1 (en) | 2002-07-29 | 2007-04-03 | Oracle International Corporation | Method and mechanism for analyzing trace data using a database management system |
US7512954B2 (en) | 2002-07-29 | 2009-03-31 | Oracle International Corporation | Method and mechanism for debugging a series of related events within a computer system |
US8914590B2 (en) | 2002-08-07 | 2014-12-16 | Pact Xpp Technologies Ag | Data processing method and device |
US8281265B2 (en) | 2002-08-07 | 2012-10-02 | Martin Vorbach | Method and device for processing data |
US7657861B2 (en) | 2002-08-07 | 2010-02-02 | Pact Xpp Technologies Ag | Method and device for processing data |
US8156284B2 (en) | 2002-08-07 | 2012-04-10 | Martin Vorbach | Data processing method and device |
US8310274B2 (en) | 2002-09-06 | 2012-11-13 | Martin Vorbach | Reconfigurable sequencer structure |
US7928763B2 (en) | 2002-09-06 | 2011-04-19 | Martin Vorbach | Multi-core processing system |
US8803552B2 (en) | 2002-09-06 | 2014-08-12 | Pact Xpp Technologies Ag | Reconfigurable sequencer structure |
US7782087B2 (en) | 2002-09-06 | 2010-08-24 | Martin Vorbach | Reconfigurable sequencer structure |
US20040054991A1 (en) * | 2002-09-17 | 2004-03-18 | Harres John M. | Debugging tool and method for tracking code execution paths |
US8020148B2 (en) * | 2002-09-23 | 2011-09-13 | Telefonaktiebolaget L M Ericsson (Publ) | Bi-directional probing and testing of software |
US20040059962A1 (en) * | 2002-09-23 | 2004-03-25 | Per-Ola Robertsson | Bi-directional probing of software |
US20040075690A1 (en) * | 2002-10-18 | 2004-04-22 | Cirne Lewis K. | User interface for viewing performance information about transactions |
US20040078688A1 (en) * | 2002-10-18 | 2004-04-22 | Xavier Pouyollon | File path resolving debugger |
US20040078691A1 (en) * | 2002-10-18 | 2004-04-22 | Cirne Lewis K. | Transaction tracer |
US7073096B2 (en) * | 2002-10-18 | 2006-07-04 | Wind River Systems, Inc. | File path resolving debugger |
US7310777B2 (en) * | 2002-10-18 | 2007-12-18 | Computer Associates Think, Inc. | User interface for viewing performance information about transactions |
US7870431B2 (en) * | 2002-10-18 | 2011-01-11 | Computer Associates Think, Inc. | Transaction tracer |
US20040078785A1 (en) * | 2002-10-22 | 2004-04-22 | Bala Dutt | System and method for marking software code |
US7603664B2 (en) * | 2002-10-22 | 2009-10-13 | Sun Microsystems, Inc. | System and method for marking software code |
US8762958B2 (en) | 2002-11-06 | 2014-06-24 | Identify Software, Ltd. | System and method for troubleshooting software configuration problems using application tracing |
US10073760B2 (en) | 2002-11-06 | 2018-09-11 | Indentify Software Ltd. (IL) | System and method for troubleshooting software configuration problems using application tracing |
US20040117690A1 (en) * | 2002-12-13 | 2004-06-17 | Andersson Anders J. | Method and apparatus for using a hardware disk controller for storing processor execution trace information on a storage device |
US20070006168A1 (en) * | 2003-02-13 | 2007-01-04 | Dimpsey Robert T | Apparatus and method for dynamic instrumenting of code to minimize system perturbation |
US7823129B2 (en) * | 2003-02-13 | 2010-10-26 | International Business Machines Corporation | Apparatus and method for dynamic instrumenting of code to minimize system perturbation |
US20040168157A1 (en) * | 2003-02-18 | 2004-08-26 | Robert Hundt | System and method for creating a process invocation tree |
US7757209B2 (en) * | 2003-03-14 | 2010-07-13 | Omron Corporation | Display and edit device, display method and program product |
US20040220684A1 (en) * | 2003-03-14 | 2004-11-04 | Shinji Fukui | Display and edit device, display method and program product |
US8032866B1 (en) | 2003-03-27 | 2011-10-04 | Identify Software Ltd. | System and method for troubleshooting runtime software problems using application learning |
US20040199828A1 (en) * | 2003-04-01 | 2004-10-07 | International Business Machines Corporation | Method and apparatus for tracing troubleshooting events for aiding technical assistance |
US20040221269A1 (en) * | 2003-05-02 | 2004-11-04 | Ray Kenneth D | User debugger for use on processes running in a high assurance kernel in an operating system |
US7197745B2 (en) * | 2003-05-02 | 2007-03-27 | Microsoft Corporation | User debugger for use on processes running in a high assurance kernel in an operating system |
US7159101B1 (en) | 2003-05-28 | 2007-01-02 | Mips Technologies, Inc. | System and method to trace high performance multi-issue processors |
US20040255273A1 (en) * | 2003-06-16 | 2004-12-16 | Microsoft Corporation | Reformulating resources with nodes reachable from defined entry points |
US20040268213A1 (en) * | 2003-06-16 | 2004-12-30 | Microsoft Corporation | Classifying software and reformulating resources according to classifications |
US7308684B2 (en) | 2003-06-16 | 2007-12-11 | Microsoft Corporation | Classifying software and reformulating resources according to classifications |
US7210124B2 (en) * | 2003-06-16 | 2007-04-24 | Microsoft Corporation | Reformulating resources with nodes reachable from defined entry points |
US7496904B2 (en) | 2003-06-26 | 2009-02-24 | Microsoft Corporation | Mining dependencies for testing and risk management |
US20040268308A1 (en) * | 2003-06-26 | 2004-12-30 | Microsoft Corporation | Mining dependencies for testing and risk management |
US20040268302A1 (en) * | 2003-06-26 | 2004-12-30 | Microsoft Corporation | Framework for determining and exposing binary dependencies |
US7739372B2 (en) * | 2003-07-29 | 2010-06-15 | Enterasys Networks, Inc. | System and method for dynamic network policy management |
US20090187968A1 (en) * | 2003-07-29 | 2009-07-23 | Enterasys Networks, Inc. | System and method for dynamic network policy management |
US8812820B2 (en) | 2003-08-28 | 2014-08-19 | Pact Xpp Technologies Ag | Data processing device and method |
US7207038B2 (en) * | 2003-08-29 | 2007-04-17 | Nokia Corporation | Constructing control flows graphs of binary executable programs at post-link time |
US20050060696A1 (en) * | 2003-08-29 | 2005-03-17 | Nokia Corporation | Method and a system for constructing control flows graphs of binary executable programs at post-link time |
US7305660B2 (en) | 2003-08-29 | 2007-12-04 | International Business Machines Corporation | Method to generate a formatted trace for an embedded device |
US20050066311A1 (en) * | 2003-09-22 | 2005-03-24 | International Business Machines Corporation | Autonomic execution tracking and correction of functions |
US7870504B1 (en) | 2003-10-01 | 2011-01-11 | TestPlant Inc. | Method for monitoring a graphical user interface on a second computer display from a first computer |
US9658931B2 (en) | 2003-10-01 | 2017-05-23 | TestPlant Inc. | Method for monitoring a graphical user interface on a second computer display from a first computer |
US9477567B2 (en) | 2003-10-01 | 2016-10-25 | Testplant, Inc. | Method for monitoring a graphical user interface on a second computer display from a first computer |
US7308681B2 (en) * | 2003-10-28 | 2007-12-11 | International Business Machines Corporation | Control flow based compression of execution traces |
US20050091643A1 (en) * | 2003-10-28 | 2005-04-28 | International Business Machines Corporation | Control flow based compression of execution traces |
US7328429B2 (en) * | 2003-11-13 | 2008-02-05 | Intel Corporation | Instruction operand tracing for software debug |
US20050138536A1 (en) * | 2003-11-13 | 2005-06-23 | Smith Zachary S. | Systems and methods for identifying similar bugs |
US20050108689A1 (en) * | 2003-11-13 | 2005-05-19 | Hooper Donald F. | Instruction operand tracing for software debug |
US7146473B1 (en) * | 2003-11-14 | 2006-12-05 | Sun Microsystems, Inc. | Mechanism for ring buffering in an arbitrary-action tracing framework |
US7500152B2 (en) * | 2003-12-05 | 2009-03-03 | Freescale Semiconductor, Inc. | Apparatus and method for time ordering events in a system having multiple time domains |
US20050144599A1 (en) * | 2003-12-26 | 2005-06-30 | Microsoft Corporation | Source server |
US7730451B2 (en) * | 2003-12-26 | 2010-06-01 | Microsoft Corporation | Source server |
US20050183067A1 (en) * | 2004-02-12 | 2005-08-18 | International Business Machines Corporation | Method and apparatus for automatic detection of build regressions |
US8843898B2 (en) | 2004-02-12 | 2014-09-23 | International Business Machines Corporation | Removal of asynchronous events in complex application performance analysis |
US20050183075A1 (en) * | 2004-02-12 | 2005-08-18 | International Business Machines Corporation | Method and apparatus for removal of asynchronous events in complex application performance analysis |
US7496900B2 (en) * | 2004-02-12 | 2009-02-24 | International Business Machines Corporation | Method for automatic detection of build regressions |
US20050183070A1 (en) * | 2004-02-12 | 2005-08-18 | International Business Machines Corporation | Method and apparatus for averaging out variations in run-to-run path data of a computer program |
US20080270995A1 (en) * | 2004-02-12 | 2008-10-30 | International Business Machines Corporation | Method for Automatic Detection of Build Regressions |
US8266595B2 (en) | 2004-02-12 | 2012-09-11 | International Business Machines Corporation | Removal of asynchronous events in complex application performance analysis |
US8196115B2 (en) * | 2004-02-12 | 2012-06-05 | International Business Machines Corporation | Method for automatic detection of build regressions |
US7519961B2 (en) | 2004-02-12 | 2009-04-14 | International Business Machines Corporation | Method and apparatus for averaging out variations in run-to-run path data of a computer program |
US9049036B2 (en) * | 2004-03-05 | 2015-06-02 | Kabushiki Kaisha Toshiba | Computer system analyzing apparatus and computer system analyzing method |
US20050222992A1 (en) * | 2004-03-05 | 2005-10-06 | Takashi Kondo | Computer system analyzing apparatus and computer system analyzing method |
US7343529B1 (en) | 2004-04-30 | 2008-03-11 | Network Appliance, Inc. | Automatic error and corrective action reporting system for a network storage appliance |
US20050251792A1 (en) * | 2004-05-06 | 2005-11-10 | Smith David W | System for adaptively determining executable application operation characteristics |
US20050273757A1 (en) * | 2004-06-07 | 2005-12-08 | Anderson Craig D | Methods, systems, and computer program products for summarizing operational behavior of a computer program |
US7685575B1 (en) * | 2004-06-08 | 2010-03-23 | Sun Microsystems, Inc. | Method and apparatus for analyzing an application |
US7644397B2 (en) * | 2004-06-19 | 2010-01-05 | Apple Inc. | Software performance analysis using data mining |
US20050283765A1 (en) * | 2004-06-19 | 2005-12-22 | Apple Computer, Inc. | Software performance analysis using data mining |
US20050283676A1 (en) * | 2004-06-22 | 2005-12-22 | International Business Machines Corporation | System and method for boundary trace with reproduction facility |
US7496901B2 (en) * | 2004-06-22 | 2009-02-24 | International Business Machines Corporation | Method for boundary trace with reproduction facility |
US7900195B2 (en) | 2004-06-22 | 2011-03-01 | International Business Machines Corporation | System for boundary trace with reproduction facility |
US20090119645A1 (en) * | 2004-06-22 | 2009-05-07 | International Business Machines Corporation | System for boundary trace with reproduction facility |
US20050289517A1 (en) * | 2004-06-24 | 2005-12-29 | International Business Machines Corporation | System and methods for client and template validation |
US7827539B1 (en) | 2004-06-25 | 2010-11-02 | Identify Software Ltd. | System and method for automated tuning of program execution tracing |
US7627785B1 (en) * | 2004-07-12 | 2009-12-01 | Sun Microsystems, Inc. | Capturing machine state of unstable Java program |
US7941703B2 (en) * | 2004-07-12 | 2011-05-10 | Oracle America, Inc. | Capturing machine state of unstable java program |
US20100042875A1 (en) * | 2004-07-12 | 2010-02-18 | Sun Microsystems, Inc. | Capturing machine state of unstable java program |
US8078596B2 (en) * | 2004-09-16 | 2011-12-13 | International Business Machines Corporation | Method and system for a non-hierarchical trace system using a hierarchical control interface |
US8271469B2 (en) * | 2004-09-16 | 2012-09-18 | International Business Machines Corporation | Method and system for a non-hierarchical trace system using a hierarchical control interface |
US20060075390A1 (en) * | 2004-09-16 | 2006-04-06 | International Business Machines Corporation | Method and system for tracing components of computer applications |
WO2006033932A3 (en) * | 2004-09-17 | 2007-01-18 | Sun Microsystems Inc | Method and system for simplifying the debugging of a program comprising user-written code and non-user written code |
WO2006033932A2 (en) * | 2004-09-17 | 2006-03-30 | Sun Microsystems, Inc. | Method and system for simplifying the debugging of a program comprising user-written code and non-user written code |
US7882492B2 (en) | 2004-09-17 | 2011-02-01 | Oracle America, Inc. | Intelligent computer program debugger, and system and method for implementing the same |
US7685574B2 (en) * | 2004-09-29 | 2010-03-23 | Microsoft Corporation | Constrained execution regions |
US20060070041A1 (en) * | 2004-09-29 | 2006-03-30 | Microsoft Corporation | Constrained execution regions |
US20060070077A1 (en) * | 2004-09-30 | 2006-03-30 | Microsoft Corporation | Providing custom product support for a software program |
US20090083698A1 (en) * | 2004-09-30 | 2009-03-26 | Rockwell Automation Technologies, Inc. | Systems and methods that facilitate management of add-on instruction generation, selection, and/or monitoring during execution |
US9250897B2 (en) | 2004-09-30 | 2016-02-02 | Rockwell Automation Technologies, Inc. | Systems and methods that facilitate management of add-on instruction generation, selection, and/or monitoring during execution |
US20090083525A1 (en) * | 2004-09-30 | 2009-03-26 | Rockwell Automation Technologies, Inc. | Systems and methods that facilitate management of add-on instruction generation, selection, and/or monitoring during execution |
US8365145B2 (en) | 2004-09-30 | 2013-01-29 | Rockwell Automation Technologies, Inc. | Systems and methods that facilitate management of add-on instruction generation, selection, and/or monitoring during execution |
US20060085691A1 (en) * | 2004-10-20 | 2006-04-20 | Rivera Jose G | Method and apparatus for logging the execution history of an operating system kernel |
US7484221B2 (en) * | 2004-10-20 | 2009-01-27 | Hewlett-Packard Development Company, L.P. | Method and apparatus for logging the execution history of an operating system kernel |
US7555549B1 (en) * | 2004-11-07 | 2009-06-30 | Qlogic, Corporation | Clustered computing model and display |
US20060167955A1 (en) * | 2005-01-21 | 2006-07-27 | Vertes Marc P | Non-intrusive method for logging of internal events within an application process, and system implementing this method |
US8904361B2 (en) * | 2005-01-21 | 2014-12-02 | International Business Machines Corporation | Non-intrusive method for logging of internal events within an application process, and system implementing this method |
US7343523B2 (en) * | 2005-02-14 | 2008-03-11 | Aristoga, Inc. | Web-based analysis of defective computer programs |
US20060184829A1 (en) * | 2005-02-14 | 2006-08-17 | Cheong Gerald I | Web-based analysis of defective computer programs |
US20060200701A1 (en) * | 2005-03-01 | 2006-09-07 | Microsoft Corporation | Kernel-mode in-flight recorder tracing mechanism |
US7849364B2 (en) * | 2005-03-01 | 2010-12-07 | Microsoft Corporation | Kernel-mode in-flight recorder tracing mechanism |
US7454666B1 (en) * | 2005-04-07 | 2008-11-18 | Sun Microsystems, Inc. | Real-time address trace generation |
US20060248512A1 (en) * | 2005-04-28 | 2006-11-02 | Microsoft Corporation | Active execution tracing visualization |
US7934202B2 (en) * | 2005-04-28 | 2011-04-26 | Microsoft Corporation | Active execution tracing |
US20060248514A1 (en) * | 2005-04-28 | 2006-11-02 | Microsoft Corporation | Active execution tracing |
US20060259823A1 (en) * | 2005-05-16 | 2006-11-16 | Texas Instruments Incorporated | Determining operating context of an executed instruction |
US7987393B2 (en) * | 2005-05-16 | 2011-07-26 | Texas Instruments Incorporated | Determining operating context of an executed instruction |
US7716643B2 (en) * | 2005-05-20 | 2010-05-11 | Microsoft Corporation | Methods and apparatus for software profiling |
US20060265693A1 (en) * | 2005-05-20 | 2006-11-23 | Microsoft Corporation | Methods and apparatus for software profiling |
US8694970B2 (en) * | 2005-06-02 | 2014-04-08 | Seagate Technology Llc | Unified debug system with multiple user-configurable trace volumes and trace buffers |
US20060277441A1 (en) * | 2005-06-02 | 2006-12-07 | Seagate Technology Llc | Unified debug system with multiple user-configurable trace volumes and trace buffers |
US7447947B2 (en) * | 2005-06-03 | 2008-11-04 | Microsoft Corporation | System and method for economizing trace operations |
US20070011497A1 (en) * | 2005-06-03 | 2007-01-11 | Microsoft Corporation | System and method for economizing trace operations |
US20070027999A1 (en) * | 2005-07-29 | 2007-02-01 | Allen James P | Method for coordinated error tracking and reporting in distributed storage systems |
US7895651B2 (en) | 2005-07-29 | 2011-02-22 | Bit 9, Inc. | Content tracking in a network security system |
US8984636B2 (en) | 2005-07-29 | 2015-03-17 | Bit9, Inc. | Content extractor and analysis system |
US8272058B2 (en) | 2005-07-29 | 2012-09-18 | Bit 9, Inc. | Centralized timed analysis in a network security system |
US20070044075A1 (en) * | 2005-08-17 | 2007-02-22 | Maarten Koning | Method for analysis of source code and display of corresponding output through a marking scheme |
US8201027B2 (en) | 2005-08-25 | 2012-06-12 | International Business Machines Corporation | Virtual flight recorder hosted by system tracing facility |
US20070050683A1 (en) * | 2005-08-25 | 2007-03-01 | International Business Machines Corporation | Virtual flight recorder hosted by system tracing facility |
US20070050764A1 (en) * | 2005-08-30 | 2007-03-01 | Microsoft Corporation | Hierarchical virtualization with a multi-level virtualization mechanism |
US8327353B2 (en) | 2005-08-30 | 2012-12-04 | Microsoft Corporation | Hierarchical virtualization with a multi-level virtualization mechanism |
US20080263522A1 (en) * | 2005-09-09 | 2008-10-23 | International Business Machines Corporation | Common Debug Adaptor |
US8196109B2 (en) * | 2005-09-09 | 2012-06-05 | International Business Machines Corporation | Common debug adaptor in a multiple computer programming language environment |
US20070061739A1 (en) * | 2005-09-12 | 2007-03-15 | Vitaliy Stulski | Object reference monitoring |
US7886278B2 (en) * | 2005-09-12 | 2011-02-08 | Sap Ag | Object reference monitoring |
US8468502B2 (en) | 2005-10-11 | 2013-06-18 | Knoa Software, Inc. | Generic, multi-instance method and GUI detection system for tracking and monitoring computer applications |
US8079037B2 (en) | 2005-10-11 | 2011-12-13 | Knoa Software, Inc. | Generic, multi-instance method and GUI detection system for tracking and monitoring computer applications |
US20070083813A1 (en) * | 2005-10-11 | 2007-04-12 | Knoa Software, Inc | Generic, multi-instance method and GUI detection system for tracking and monitoring computer applications |
WO2007044875A3 (en) * | 2005-10-11 | 2009-04-30 | Knoa Software Inc | System and method for tracking and monitoring computer applications |
US7996822B2 (en) | 2005-12-01 | 2011-08-09 | International Business Machines Corporation | User/process runtime system trace |
US20070130119A1 (en) * | 2005-12-01 | 2007-06-07 | Phillips Brent R | User/process runtime system trace |
US20070130320A1 (en) * | 2005-12-01 | 2007-06-07 | Morgan Fabian F | Efficient, centralized management of application log configuration settings |
US8326966B2 (en) | 2005-12-01 | 2012-12-04 | International Business Machines Corporation | Efficient, centralized management of application log configuration settings |
US7949673B2 (en) | 2005-12-15 | 2011-05-24 | Computer Associates Think, Inc. | Correlating cross process and cross thread execution flows in an application manager |
US8316354B2 (en) | 2005-12-15 | 2012-11-20 | Ca, Inc. | Execution flow shape compression for aggregate data reporting in an application manager |
US20070169052A1 (en) * | 2005-12-15 | 2007-07-19 | Wily Technology, Inc. | Execution flow shape compression for aggregate data reporting in an application manager |
US20070143743A1 (en) * | 2005-12-15 | 2007-06-21 | Wily Technology, Inc. | Use of execution flow shape to allow aggregate data reporting with full context in an application manager |
US8762957B2 (en) | 2005-12-15 | 2014-06-24 | Ca, Inc. | Use of execution flow shape to allow aggregate data reporting with full context in an application manager |
US8341605B2 (en) | 2005-12-15 | 2012-12-25 | Ca, Inc. | Use of execution flow shape to allow aggregate data reporting with full context in an application manager |
US20070143323A1 (en) * | 2005-12-15 | 2007-06-21 | Wily Technology, Inc. | Correlating cross process and cross thread execution flows in an application manager |
US8250503B2 (en) | 2006-01-18 | 2012-08-21 | Martin Vorbach | Hardware definition method including determining whether to implement a function as hardware or software |
US20070226773A1 (en) * | 2006-03-21 | 2007-09-27 | Novell, Inc. | System and method for using sandboxes in a managed shell |
US7725922B2 (en) | 2006-03-21 | 2010-05-25 | Novell, Inc. | System and method for using sandboxes in a managed shell |
US9684557B2 (en) | 2006-04-04 | 2017-06-20 | Adobe Systems Incorporated | System and method for facilitating recovery from a document creation error |
US8402131B2 (en) | 2006-05-11 | 2013-03-19 | Ca, Inc. | Hierarchy for characterizing interactions with an application |
US8656006B2 (en) | 2006-05-11 | 2014-02-18 | Ca, Inc. | Integrating traffic monitoring data and application runtime data |
US7805510B2 (en) | 2006-05-11 | 2010-09-28 | Computer Associates Think, Inc. | Hierarchy for characterizing interactions with an application |
US20070266045A1 (en) * | 2006-05-11 | 2007-11-15 | Computer Associates Think, Inc. | Hierarchy for characterizing interactions with an application |
US20070266149A1 (en) * | 2006-05-11 | 2007-11-15 | Computer Associates Think, Inc. | Integrating traffic monitoring data and application runtime data |
US20110022707A1 (en) * | 2006-05-11 | 2011-01-27 | Computer Associates Think, Inc. | Hierarchy for characterizing interactions with an application |
US20070277222A1 (en) * | 2006-05-26 | 2007-11-29 | Novell, Inc | System and method for executing a permissions recorder analyzer |
US7743414B2 (en) | 2006-05-26 | 2010-06-22 | Novell, Inc. | System and method for executing a permissions recorder analyzer |
US9122601B2 (en) | 2006-06-07 | 2015-09-01 | Ca, Inc. | Advancing and rewinding a replayed program execution |
US7693257B2 (en) | 2006-06-29 | 2010-04-06 | Accuray Incorporated | Treatment delivery optimization |
US20080002811A1 (en) * | 2006-06-29 | 2008-01-03 | Allison John W | Treatment delivery optimization |
US8413121B2 (en) * | 2006-07-17 | 2013-04-02 | Ca, Inc. | Method and system for storing trace events in a database table |
US20080016500A1 (en) * | 2006-07-17 | 2008-01-17 | Computer Associates Think,Inc. | Method and System for Storing Trace Events in a Database Table |
US20080066063A1 (en) * | 2006-07-21 | 2008-03-13 | Novell, Inc. | System and method for preparing runtime checks |
US7805707B2 (en) * | 2006-07-21 | 2010-09-28 | Novell, Inc. | System and method for preparing runtime checks |
US7739735B2 (en) | 2006-07-26 | 2010-06-15 | Novell, Inc. | System and method for dynamic optimizations using security assertions |
US20080028461A1 (en) * | 2006-07-26 | 2008-01-31 | Novell, Inc. | System and method for dynamic optimizations using security assertions |
US20080022843A1 (en) * | 2006-07-28 | 2008-01-31 | Apple Computer, Inc. | Execution difference identification tool |
US8255876B2 (en) * | 2006-07-28 | 2012-08-28 | Apple Inc. | Execution difference identification tool |
US8930911B2 (en) | 2006-07-28 | 2015-01-06 | Maxwell O. Drukman | Execution difference identification tool |
US20080046961A1 (en) * | 2006-08-11 | 2008-02-21 | Novell, Inc. | System and method for network permissions evaluation |
US7856654B2 (en) | 2006-08-11 | 2010-12-21 | Novell, Inc. | System and method for network permissions evaluation |
US20080072276A1 (en) * | 2006-08-24 | 2008-03-20 | Novell, Inc. | System and method for applying security policies on multiple assembly caches |
US7823186B2 (en) | 2006-08-24 | 2010-10-26 | Novell, Inc. | System and method for applying security policies on multiple assembly caches |
US20080127107A1 (en) * | 2006-09-07 | 2008-05-29 | Sun Microsystems, Inc. | Method and apparatus for specification and application of a user-specified filter in a data space profiler |
US8640114B2 (en) | 2006-09-07 | 2014-01-28 | Oracle America, Inc. | Method and apparatus for specification and application of a user-specified filter in a data space profiler |
US8381187B2 (en) | 2006-09-21 | 2013-02-19 | International Business Machines Corporation | Graphical user interface for job output retrieval based on errors |
US20080079983A1 (en) * | 2006-09-21 | 2008-04-03 | Fowler Ii Melvin Eugene | Graphical user interface for job output retrieval |
US20080109796A1 (en) * | 2006-11-08 | 2008-05-08 | Nicolai Kosche | Method and Apparatus for Associating User-Specified Data with Events in a Data Space Profiler |
US8813055B2 (en) * | 2006-11-08 | 2014-08-19 | Oracle America, Inc. | Method and apparatus for associating user-specified data with events in a data space profiler |
US9009680B2 (en) | 2006-11-30 | 2015-04-14 | Ca, Inc. | Selecting instrumentation points for an application |
US20080148039A1 (en) * | 2006-11-30 | 2008-06-19 | Computer Associates Think, Inc. | Selecting instrumentation points for an application |
US20100169285A1 (en) * | 2006-12-01 | 2010-07-01 | Computer Associates Think, Inc. | Automated grouping of messages provided to an application using string similarity analysis |
US7917911B2 (en) | 2006-12-01 | 2011-03-29 | Computer Associates Think, Inc. | Automated grouping of messages provided to an application using execution path similarity analysis |
US7689610B2 (en) | 2006-12-01 | 2010-03-30 | Computer Associates Think, Inc. | Automated grouping of messages provided to an application using string similarity analysis |
US8078619B2 (en) | 2006-12-01 | 2011-12-13 | Computer Associates Think, Inc. | Automated grouping of messages provided to an application using string similarity analysis |
US20080134209A1 (en) * | 2006-12-01 | 2008-06-05 | Computer Associates Think, Inc. | Automated grouping of messages provided to an application using string similarity analysis |
US20080134205A1 (en) * | 2006-12-01 | 2008-06-05 | Computer Associates Think, Inc. | Automated grouping of messages provided to an application using execution path similarity analysis |
US20080148242A1 (en) * | 2006-12-18 | 2008-06-19 | Computer Associates Think, Inc. | Optimizing an interaction model for an application |
US9645915B2 (en) | 2006-12-27 | 2017-05-09 | The Mathworks, Inc. | Continuous evaluation of program code and saving state information associated with program code |
US20080163178A1 (en) * | 2006-12-29 | 2008-07-03 | Ivanova Gorka J | System and method for displaying component information of a trace |
US20080163177A1 (en) * | 2006-12-29 | 2008-07-03 | Sap Ag | System and method for displaying trace information |
US8910119B2 (en) | 2006-12-29 | 2014-12-09 | Sap Ag | System and method for displaying component information of a trace |
US8135572B2 (en) | 2007-01-23 | 2012-03-13 | Microsoft Corporation | Integrated debugger simulator |
US20080177525A1 (en) * | 2007-01-23 | 2008-07-24 | Microsoft Corporation | Integrated debugger simulator |
US8762951B1 (en) | 2007-03-21 | 2014-06-24 | Oracle America, Inc. | Apparatus and method for profiling system events in a fine grain multi-threaded multi-core processor |
US7926035B2 (en) * | 2007-04-24 | 2011-04-12 | Microsoft Corporation | Testing multi-thread software using prioritized context switch limits |
US7921335B2 (en) * | 2007-04-24 | 2011-04-05 | The Boeing Company | System diagnostic utility |
US20080270837A1 (en) * | 2007-04-24 | 2008-10-30 | Kiefer Scott K | System diagnostic utility |
US20080271042A1 (en) * | 2007-04-24 | 2008-10-30 | Microsoft Corporation | Testing multi-thread software using prioritized context switch limits |
US20080295114A1 (en) * | 2007-05-07 | 2008-11-27 | Pramod Vasant Argade | Method and apparatus for execution control of computer programs |
US20080295078A1 (en) * | 2007-05-25 | 2008-11-27 | Microsoft Corporation | In-process debugging using external debugging infrastructure |
US8239832B2 (en) * | 2007-05-25 | 2012-08-07 | Microsoft Corporation | In-process debugging using external debugging infrastructure |
US8091074B2 (en) * | 2007-06-21 | 2012-01-03 | Microsoft Corporation | Execution-centric source code view |
US20080320442A1 (en) * | 2007-06-21 | 2008-12-25 | Microsoft Corporation | Execution-centric source code view |
US8543683B2 (en) | 2007-09-26 | 2013-09-24 | Microsoft Corporation | Remote monitoring of local behavior of network applications |
US8108513B2 (en) * | 2007-09-26 | 2012-01-31 | Microsoft Corporation | Remote monitoring of local behavior of network applications |
US20090083409A1 (en) * | 2007-09-26 | 2009-03-26 | Microsoft Corporation | Remote monitoring of local behavior of network applications |
US20090083714A1 (en) * | 2007-09-26 | 2009-03-26 | Microsoft Corporation | Remote monitoring of local behavior of network applications |
US20090132860A1 (en) * | 2007-11-21 | 2009-05-21 | Inventec Corporation | System and method for rapidly diagnosing bugs of system software |
US20130145108A1 (en) * | 2007-11-21 | 2013-06-06 | Jonathan Lindo | Advancing and rewinding a replayed program execution |
US8832660B2 (en) * | 2007-11-21 | 2014-09-09 | Ca, Inc. | Advancing and rewinding a replayed program execution |
US20090178030A1 (en) * | 2008-01-09 | 2009-07-09 | International Business Machines Corporation | System, method and program for executing a debugger |
US8752023B2 (en) | 2008-01-09 | 2014-06-10 | International Business Machines Corporation | System, method and program product for executing a debugger |
US8291388B2 (en) * | 2008-01-09 | 2012-10-16 | International Business Machines Corporation | System, method and program for executing a debugger |
US8271956B2 (en) * | 2008-02-07 | 2012-09-18 | International Business Machines Corporation | System, method and program product for dynamically adjusting trace buffer capacity based on execution history |
US20090204949A1 (en) * | 2008-02-07 | 2009-08-13 | International Business Machines Corporation | System, method and program product for dynamically adjusting trace buffer capacity based on execution history |
US20090222646A1 (en) * | 2008-02-28 | 2009-09-03 | International Business Machines Corporation | Method and apparatus for detecting processor behavior using instruction trace data |
US20090222796A1 (en) * | 2008-02-29 | 2009-09-03 | International Business Machines Corporation | Viral trace |
US8677333B2 (en) | 2008-02-29 | 2014-03-18 | International Business Machines Corporation | Virtual machine and programming language for event processing |
US20090222795A1 (en) * | 2008-02-29 | 2009-09-03 | International Business Machines Corporation | Debugger for a Declarative Event-Driven Programming Model |
US8365149B2 (en) * | 2008-02-29 | 2013-01-29 | International Business Machines Corporation | Debugger for a declarative event-driven programming model |
US9098625B2 (en) | 2008-02-29 | 2015-08-04 | International Business Machines Corporation | Viral trace |
US8627299B2 (en) | 2008-02-29 | 2014-01-07 | International Business Machines Corporation | Virtual machine and programming language for event processing |
US20090222789A1 (en) * | 2008-02-29 | 2009-09-03 | International Business Machines Corporation | Compiler for a Declarative Event-Driven Programming Model |
US8397216B2 (en) | 2008-02-29 | 2013-03-12 | International Business Machines Corporation | Compiler for a declarative event-driven programming model |
US20090222793A1 (en) * | 2008-02-29 | 2009-09-03 | International Business Machines Corporation | Virtual Machine and Programming Language for Event Processing |
US20090228875A1 (en) * | 2008-03-04 | 2009-09-10 | Devries Alex | Method and System for Reducing Disk Allocation by Profiling Symbol Usage |
US20100011345A1 (en) * | 2008-07-09 | 2010-01-14 | International Business Machines Corporation | Efficient and Self-Balancing Verification of Multi-Threaded Microprocessors |
US8307246B2 (en) * | 2008-10-29 | 2012-11-06 | Aternity Information Systems Ltd. | Real time monitoring of computer for determining speed of various processes |
US20100107014A1 (en) * | 2008-10-29 | 2010-04-29 | Aternity Inc. | Real time monitoring of computer for determining speed of various processes |
US20130024731A1 (en) * | 2008-10-29 | 2013-01-24 | Aternity Information Systems Ltd. | Real time monitoring of computer for determining speed and energy consumption of various processes |
US9032254B2 (en) * | 2008-10-29 | 2015-05-12 | Aternity Information Systems Ltd. | Real time monitoring of computer for determining speed and energy consumption of various processes |
US8312433B2 (en) | 2008-12-15 | 2012-11-13 | International Business Machines Corporation | Operating system aided code coverage |
US20100153926A1 (en) * | 2008-12-15 | 2010-06-17 | International Business Machines Corporation | Operating system aided code coverage |
US20100287417A1 (en) * | 2009-05-05 | 2010-11-11 | Freescale Semiconductor, Inc. | Address translation trace message generation for debug |
US8438547B2 (en) * | 2009-05-05 | 2013-05-07 | Freescale Semiconductor, Inc. | Address translation trace message generation for debug |
US8589738B2 (en) | 2009-05-05 | 2013-11-19 | Freescale Semiconductor, Inc. | Program trace message generation for page crossing events for debug |
US20110119533A1 (en) * | 2009-05-05 | 2011-05-19 | Freescale Semiconductor, Inc. | Program trace message generation for page crossing events for debug |
US20110016357A1 (en) * | 2009-07-17 | 2011-01-20 | Krum Georgiev Tsvetkov | Call-stacks representation for easier analysis of thread dump |
US8099631B2 (en) * | 2009-07-17 | 2012-01-17 | Sap Ag | Call-stacks representation for easier analysis of thread dump |
US20110067007A1 (en) * | 2009-09-14 | 2011-03-17 | Red Hat, Inc. | Automatic thread dumping |
US8601444B2 (en) * | 2009-10-27 | 2013-12-03 | Microsoft Corporation | Analysis and timeline visualization of thread activity |
US20110099539A1 (en) * | 2009-10-27 | 2011-04-28 | Microsoft Corporation | Analysis and timeline visualization of thread activity |
US8839205B2 (en) | 2009-10-27 | 2014-09-16 | Microsoft Corporation | Analysis and timeline visualization of thread activity |
US9436498B2 (en) | 2009-11-23 | 2016-09-06 | International Business Machines Corporation | Runtime analysis and control to monitor the status of the threads during execution of folded thread |
US9058417B2 (en) * | 2009-11-23 | 2015-06-16 | International Business Machines Corporation | Thread serialization and disablement tool |
US9886305B2 (en) | 2009-11-23 | 2018-02-06 | International Business Machines Corporation | Determining the status of plurality of threads by monitoring the execution of folded thread |
US20140359583A1 (en) * | 2009-11-23 | 2014-12-04 | International Business Machines Corporation | Thread serialization and disablement tool |
US9436499B2 (en) | 2009-11-23 | 2016-09-06 | International Business Machines Corporation | User interface to display status of threads based on runtime analysis and control of folded thread |
US8359584B2 (en) * | 2009-12-18 | 2013-01-22 | Microsoft Corporation | Debugging from a call graph |
US20110154300A1 (en) * | 2009-12-18 | 2011-06-23 | Microsoft Corporation | Debugging From A Call Graph |
US20110161938A1 (en) * | 2009-12-30 | 2011-06-30 | International Business Machines Corporation | Including defect content in source code and producing quality reports from the same |
US9047399B2 (en) * | 2010-02-26 | 2015-06-02 | Red Hat, Inc. | Generating visualization from running executable code |
US20110214108A1 (en) * | 2010-02-26 | 2011-09-01 | Roland Grunberg | Architecture, system and method for generating visualizations from running executable code |
CN102207903A (en) * | 2010-03-29 | 2011-10-05 | 微软公司 | Automatically redirecting method calls for unit testing |
US8954929B2 (en) * | 2010-03-29 | 2015-02-10 | Microsoft Corporation | Automatically redirecting method calls for unit testing |
US20110239194A1 (en) * | 2010-03-29 | 2011-09-29 | Microsoft Corporation | Automatically redirecting method calls for unit testing |
CN102207903B (en) * | 2010-03-29 | 2016-03-23 | 微软技术许可有限责任公司 | Based on being automatically redirected the unit test method and system that call |
US20110252407A1 (en) * | 2010-04-09 | 2011-10-13 | AppFirst, Inc. | System and method for information extraction from within an active application during execution |
EP2375337A1 (en) * | 2010-04-09 | 2011-10-12 | AppFirst, Inc. | System and method for information extraction from within an active application during execution |
US8707274B2 (en) * | 2010-04-09 | 2014-04-22 | AppFirst, Inc. | System and method for information extraction from within an active application during execution |
US8898511B2 (en) | 2010-06-24 | 2014-11-25 | International Business Machines Corporation | Homogeneous recovery in a redundant memory system |
US8775858B2 (en) * | 2010-06-24 | 2014-07-08 | International Business Machines Corporation | Heterogeneous recovery in a redundant memory system |
US8769335B2 (en) | 2010-06-24 | 2014-07-01 | International Business Machines Corporation | Homogeneous recovery in a redundant memory system |
US20120030667A1 (en) * | 2010-07-29 | 2012-02-02 | International Business Machines Corporation | Packaging an application |
US8910148B2 (en) * | 2010-07-29 | 2014-12-09 | International Business Machines Corporation | Packaging an application with plurality of libraries |
US8490055B2 (en) | 2010-09-17 | 2013-07-16 | Ca, Inc. | Generating dependency maps from dependency data |
US8762952B2 (en) | 2010-12-14 | 2014-06-24 | Bmc Software, Inc. | Recording method calls that led to an unforeseen problem |
US8745598B2 (en) | 2010-12-14 | 2014-06-03 | Bmc Software, Inc. | Running injected code prior to execution of an application |
US20120167057A1 (en) * | 2010-12-22 | 2012-06-28 | Microsoft Corporation | Dynamic instrumentation of software code |
US8688606B2 (en) * | 2011-01-24 | 2014-04-01 | International Business Machines Corporation | Smarter business intelligence systems |
US20120191636A1 (en) * | 2011-01-24 | 2012-07-26 | International Business Machines Corporation | Smarter Business Intelligence Systems |
US20120290345A1 (en) * | 2011-01-24 | 2012-11-15 | International Business Machines Corporation | Smarter Business Intelligence Systems |
US8682825B2 (en) * | 2011-01-24 | 2014-03-25 | International Business Machines Corporation | Smarter business intelligence systems |
US8984493B2 (en) | 2011-01-25 | 2015-03-17 | International Business Machines Corporation | Distributed static analysis of computer software applications |
US8856764B2 (en) | 2011-01-25 | 2014-10-07 | International Business Machines Corporation | Distributed static analysis of computer software applications |
US8782614B2 (en) | 2011-04-08 | 2014-07-15 | Ca, Inc. | Visualization of JVM and cross-JVM call stacks |
US9202185B2 (en) | 2011-04-08 | 2015-12-01 | Ca, Inc. | Transaction model with structural and behavioral description of complex transactions |
US8516301B2 (en) | 2011-04-08 | 2013-08-20 | Ca, Inc. | Visualizing transaction traces as flows through a map of logical subsystems |
EP2508997A1 (en) * | 2011-04-08 | 2012-10-10 | Computer Associates Think, Inc. | Visualization of JVM and cross-JVM call stacks |
US8438427B2 (en) | 2011-04-08 | 2013-05-07 | Ca, Inc. | Visualizing relationships between a transaction trace graph and a map of logical subsystems |
US8832504B2 (en) | 2011-05-19 | 2014-09-09 | International Business Machines Corporation | On demand tracing of application code execution |
US20120297254A1 (en) * | 2011-05-19 | 2012-11-22 | International Business Machines Corporation | On demand tracing of application code execution |
US8799719B2 (en) * | 2011-05-19 | 2014-08-05 | International Business Machines Corporation | On demand tracing of application code execution |
US9116717B2 (en) * | 2011-05-27 | 2015-08-25 | Cylance Inc. | Run-time interception of software methods |
US20120304160A1 (en) * | 2011-05-27 | 2012-11-29 | Ridgeway Internet Security, Llc | Systems and Methods for Run-Time Interception of Software Methods |
US9225772B2 (en) | 2011-09-26 | 2015-12-29 | Knoa Software, Inc. | Method, system and program product for allocation and/or prioritization of electronic resources |
US10389592B2 (en) | 2011-09-26 | 2019-08-20 | Knoa Software, Inc. | Method, system and program product for allocation and/or prioritization of electronic resources |
US9705817B2 (en) | 2011-09-26 | 2017-07-11 | Knoa Software, Inc. | Method, system and program product for allocation and/or prioritization of electronic resources |
US9141356B2 (en) | 2011-12-14 | 2015-09-22 | Microsoft Technology Licensing, Llc | Process for generating dynamic type |
US9069543B2 (en) | 2011-12-22 | 2015-06-30 | International Business Machines Corporation | Predictive operator graph element processing |
US9043381B2 (en) | 2011-12-22 | 2015-05-26 | International Business Machines Corporation | Predictive operator graph element processing |
US9916192B2 (en) * | 2012-01-12 | 2018-03-13 | International Business Machines Corporation | Thread based dynamic data collection |
US20130297977A1 (en) * | 2012-01-12 | 2013-11-07 | International Business Machines Corporation | Thread based dynamic data collection |
US10740166B2 (en) * | 2012-01-12 | 2020-08-11 | International Business Machines Corporation | Thread based dynamic data collection |
US20130185600A1 (en) * | 2012-01-12 | 2013-07-18 | International Business Machines Corporation | Thread based dynamic data collection |
US20130290936A1 (en) * | 2012-04-30 | 2013-10-31 | Nec Laboratories America, Inc. | Method and System for Correlated Tracing with Automated Multi-Layer Function Instrumentation Localization |
US9092568B2 (en) * | 2012-04-30 | 2015-07-28 | Nec Laboratories America, Inc. | Method and system for correlated tracing with automated multi-layer function instrumentation localization |
US9317257B2 (en) | 2012-06-22 | 2016-04-19 | Microsoft Technology Licensing, Llc | Folded views in development environment |
US10324823B2 (en) | 2012-08-04 | 2019-06-18 | Microsoft Technology Licensing, Llc | Historical software diagnostics using lightweight process snapshots |
US20140068569A1 (en) * | 2012-08-31 | 2014-03-06 | Microsoft Corporation | User directed profiling |
US9436588B2 (en) * | 2012-09-28 | 2016-09-06 | Identify Software Ltd. (IL) | Efficient method data recording |
US9767007B2 (en) | 2012-09-28 | 2017-09-19 | Identify Software Ltd. (IL) | Efficient method data recording |
US9483391B2 (en) | 2012-09-28 | 2016-11-01 | Identify Software Ltd. | Efficient method data recording |
US20140096114A1 (en) * | 2012-09-28 | 2014-04-03 | Identify Software Ltd. (IL) | Efficient method data recording |
US10339031B2 (en) | 2012-09-28 | 2019-07-02 | Bmc Software Israel Ltd. | Efficient method data recording |
US20140130018A1 (en) * | 2012-11-05 | 2014-05-08 | Realworld Holding B.V. | Method and arrangement for collecting timing data related to a computer application |
US8943477B2 (en) * | 2012-12-18 | 2015-01-27 | International Business Machines Corporation | Debugging a graphical user interface code script with non-intrusive overlays |
US20140173569A1 (en) * | 2012-12-18 | 2014-06-19 | International Business Machines Corporation | Managing window focus while debugging a graphical user interface program |
US9075915B2 (en) * | 2012-12-18 | 2015-07-07 | International Business Machines Corporation | Managing window focus while debugging a graphical user interface program |
US20140173568A1 (en) * | 2012-12-18 | 2014-06-19 | International Business Machines Corporation | Debugging a graphical user interface code script with non-intrusive overlays |
US20140173567A1 (en) * | 2012-12-18 | 2014-06-19 | International Business Machines Corporation | Managing window focus while debugging a graphical user interface program |
US8938718B2 (en) * | 2012-12-18 | 2015-01-20 | International Business Machines Corporation | Managing window focus while debugging a graphical user interface program |
US9104799B2 (en) | 2012-12-18 | 2015-08-11 | International Business Machines Corporation | Debugging a graphical user interface code script with non-intrusive overlays |
US9519568B2 (en) | 2012-12-31 | 2016-12-13 | Nvidia Corporation | System and method for debugging an executing general-purpose computing on graphics processing units (GPGPU) application |
US10178031B2 (en) * | 2013-01-25 | 2019-01-08 | Microsoft Technology Licensing, Llc | Tracing with a workload distributor |
US20150222548A1 (en) * | 2013-01-25 | 2015-08-06 | Concurix Corporation | Tracing with a Workload Distributor |
US9804949B2 (en) | 2013-02-12 | 2017-10-31 | Microsoft Technology Licensing, Llc | Periodicity optimization in an automated tracing system |
US9658936B2 (en) | 2013-02-12 | 2017-05-23 | Microsoft Technology Licensing, Llc | Optimization analysis using similar frequencies |
US9767006B2 (en) | 2013-02-12 | 2017-09-19 | Microsoft Technology Licensing, Llc | Deploying trace objectives using cost analyses |
US9665474B2 (en) | 2013-03-15 | 2017-05-30 | Microsoft Technology Licensing, Llc | Relationships derived from trace data |
CN104077184A (en) * | 2013-03-25 | 2014-10-01 | 腾讯科技(深圳)有限公司 | Progress control method of application program and computer system |
US20150113544A1 (en) * | 2013-03-25 | 2015-04-23 | Tencent Technology (Shenzhen) Company Limited | Method for controlling process of application and computer system |
US9575874B2 (en) | 2013-04-20 | 2017-02-21 | Microsoft Technology Licensing, Llc | Error list and bug report analysis for configuring an application tracer |
US9471456B2 (en) * | 2013-05-15 | 2016-10-18 | Nvidia Corporation | Interleaved instruction debugger |
US20140344556A1 (en) * | 2013-05-15 | 2014-11-20 | Nvidia Corporation | Interleaved instruction debugger |
US9658943B2 (en) | 2013-05-21 | 2017-05-23 | Microsoft Technology Licensing, Llc | Interactive graph for navigating application code |
US9734040B2 (en) | 2013-05-21 | 2017-08-15 | Microsoft Technology Licensing, Llc | Animated highlights in a graph representing an application |
US9754396B2 (en) | 2013-07-24 | 2017-09-05 | Microsoft Technology Licensing, Llc | Event chain visualization of performance data |
US20160188441A1 (en) * | 2013-08-28 | 2016-06-30 | Bo Chen | Testing multi-threaded applications |
US10725889B2 (en) * | 2013-08-28 | 2020-07-28 | Micro Focus Llc | Testing multi-threaded applications |
US20150067654A1 (en) * | 2013-09-04 | 2015-03-05 | Concurix Corporation | Tracing System for Application and Module Tracing |
US9298588B2 (en) * | 2013-09-04 | 2016-03-29 | Microsoft Technology Licensing, Llc | Tracing system for application and module tracing |
US9292415B2 (en) * | 2013-09-04 | 2016-03-22 | Microsoft Technology Licensing, Llc | Module specific tracing in a shared module environment |
US9311213B2 (en) * | 2013-09-04 | 2016-04-12 | Microsoft Technology Licensing, Llc | Module database with tracing options |
US9864672B2 (en) | 2013-09-04 | 2018-01-09 | Microsoft Technology Licensing, Llc | Module specific tracing in a shared module environment |
US20150067652A1 (en) * | 2013-09-04 | 2015-03-05 | Concurix Corporation | Module Specific Tracing in a Shared Module Environment |
US20150066869A1 (en) * | 2013-09-04 | 2015-03-05 | Concurix Corporation | Module Database with Tracing Options |
US9547580B1 (en) | 2013-10-22 | 2017-01-17 | The Mathworks, Inc. | Providing intermediate results of evaluating program code that includes a compound statement |
US9047411B1 (en) * | 2013-10-22 | 2015-06-02 | The Mathworks, Inc. | Programming environment for executing program code despite errors and for providing error indicators |
US9665471B1 (en) * | 2013-10-22 | 2017-05-30 | The Mathworks, Inc. | Program code interface for providing program code and corresponding results of evaluating the program code |
US9582400B1 (en) * | 2013-10-22 | 2017-02-28 | The Mathworks, Inc. | Determining when to evaluate program code and provide results in a live evaluation programming environment |
US9053235B1 (en) * | 2013-10-22 | 2015-06-09 | The Mathworks, Inc. | Program code interface for providing program code and corresponding results of evaluating the program code |
US9075916B1 (en) * | 2013-10-22 | 2015-07-07 | The Mathworks, Inc. | Undoing/redoing program code execution |
US9053228B1 (en) | 2013-10-22 | 2015-06-09 | The Mathworks, Inc. | Determining when to evaluate program code and provide results in a live evaluation programming environment |
US9064052B1 (en) | 2013-10-22 | 2015-06-23 | The Mathworks, Inc. | Providing intermediate results of evaluating program code that includes a compound statement |
US9772927B2 (en) | 2013-11-13 | 2017-09-26 | Microsoft Technology Licensing, Llc | User interface for selecting tracing origins for aggregating classes of trace data |
US10346292B2 (en) | 2013-11-13 | 2019-07-09 | Microsoft Technology Licensing, Llc | Software component recommendation based on multiple trace runs |
US10289411B2 (en) * | 2013-11-18 | 2019-05-14 | Microsoft Technology Licensing, Llc | Diagnosing production applications |
US20150180911A1 (en) * | 2013-12-19 | 2015-06-25 | Prasanna Bhat Mavinakuli | Feedback channel for feedback from software |
CN103761089B (en) * | 2014-01-14 | 2017-09-15 | 清华大学 | The method that kinematic function call relation is determined based on register transfer language |
CN103761089A (en) * | 2014-01-14 | 2014-04-30 | 清华大学 | Method for determining dynamic function call relation based on register transfer languages |
US9880915B2 (en) | 2014-03-05 | 2018-01-30 | Microsoft Technology Licensing, Llc | N-gram analysis of inputs to a software application |
US9355016B2 (en) | 2014-03-05 | 2016-05-31 | Microsoft Technology Licensing, Llc | Automated regression testing for software applications |
US9594665B2 (en) * | 2014-03-05 | 2017-03-14 | Microsoft Technology Licensing, Llc | Regression evaluation using behavior models of software applications |
US9329980B2 (en) | 2014-03-05 | 2016-05-03 | Microsoft Technology Licensing, Llc | Security alerting using n-gram analysis of program execution data |
US20150254161A1 (en) * | 2014-03-05 | 2015-09-10 | Concurix Corporation | Regression Evaluation Using Behavior Models of Software Applications |
US9424026B2 (en) * | 2014-09-29 | 2016-08-23 | Sap Se | Visualizations of inter-entity calls |
US9940579B2 (en) | 2014-10-24 | 2018-04-10 | Google Llc | Methods and systems for automated tagging based on software execution traces |
US10977561B2 (en) | 2014-10-24 | 2021-04-13 | Google Llc | Methods and systems for processing software traces |
US11379734B2 (en) | 2014-10-24 | 2022-07-05 | Google Llc | Methods and systems for processing software traces |
US10380003B2 (en) | 2014-10-29 | 2019-08-13 | Microsoft Technology Licensing, Llc | Diagnostic workflow for production debugging |
US10540225B2 (en) * | 2015-05-27 | 2020-01-21 | Hewlett Packard Enterprise Development Lp | Data validation |
US20180157552A1 (en) * | 2015-05-27 | 2018-06-07 | Hewlett Packard Enterprise Development Lp | Data validation |
US11102094B2 (en) | 2015-08-25 | 2021-08-24 | Google Llc | Systems and methods for configuring a resource for network traffic analysis |
US11444856B2 (en) | 2015-08-25 | 2022-09-13 | Google Llc | Systems and methods for configuring a resource for network traffic analysis |
US9697104B2 (en) * | 2015-12-07 | 2017-07-04 | Sap Se | End-to end tracing and logging |
US11507494B2 (en) | 2016-02-10 | 2022-11-22 | Eggplant Limited | Method of, and apparatus for, testing computer hardware and software |
US11507496B2 (en) | 2016-02-10 | 2022-11-22 | Eggplant Limited | Method of, and apparatus for, testing computer hardware and software |
US20190057006A1 (en) * | 2016-02-14 | 2019-02-21 | Dell Products, Lp | System and method to assess information handling system health and resource utilization |
US10073753B2 (en) * | 2016-02-14 | 2018-09-11 | Dell Products, Lp | System and method to assess information handling system health and resource utilization |
US11269750B2 (en) * | 2016-02-14 | 2022-03-08 | Dell Products, Lp | System and method to assess information handling system health and resource utilization |
US11256535B2 (en) | 2016-02-18 | 2022-02-22 | Micro Focus Llc | Visualizations of computer program transactions |
US10180872B2 (en) * | 2016-04-14 | 2019-01-15 | Vmware, Inc. | Methods and systems that identify problems in applications |
CN106201745A (en) * | 2016-07-08 | 2016-12-07 | 深圳中兴网信科技有限公司 | The remote debugging method of application program, remote debugging system and terminal |
WO2018085455A1 (en) * | 2016-11-01 | 2018-05-11 | App Onboard, Inc. | Dynamic graphic visualizer for application metrics |
WO2018136460A1 (en) * | 2017-01-18 | 2018-07-26 | Pivotal Software, Inc. | Trace management |
US10489285B2 (en) | 2017-01-18 | 2019-11-26 | Pivotal Software, Inc. | Trace management |
US10831649B2 (en) | 2017-01-18 | 2020-11-10 | Pivotal Software, Inc. | Trace management |
US10073767B2 (en) | 2017-01-18 | 2018-09-11 | Pivotal Software, Inc. | Trace Management |
US10769009B2 (en) * | 2018-03-21 | 2020-09-08 | International Business Machines Corporation | Root cause analysis for correlated development and operations data |
US20190294484A1 (en) * | 2018-03-21 | 2019-09-26 | International Business Machines Corporation | Root cause analysis for correlated development and operations data |
US11144432B2 (en) | 2018-04-04 | 2021-10-12 | International Business Machines Corporation | Testing and reproduction of concurrency issues |
US10579501B2 (en) * | 2018-04-04 | 2020-03-03 | International Business Machines Corporation | Testing and reproduction of concurrency issues |
US20190310930A1 (en) * | 2018-04-04 | 2019-10-10 | International Business Machines Corporation | Testing and reproduction of concurrency issues |
US11252040B2 (en) * | 2018-07-31 | 2022-02-15 | Cisco Technology, Inc. | Advanced network tracing in the data plane |
US11563643B2 (en) | 2018-07-31 | 2023-01-24 | Cisco Technology, Inc. | Advanced network tracing in the data plane |
US10761965B2 (en) * | 2018-09-28 | 2020-09-01 | Atlassian Pty Ltd. | Detecting method calls based on stack trace data |
US11036619B2 (en) | 2019-06-06 | 2021-06-15 | International Business Machines Corporation | Bypassing execution of a module in real-time |
US10915426B2 (en) | 2019-06-06 | 2021-02-09 | International Business Machines Corporation | Intercepting and recording calls to a module in real-time |
US11074069B2 (en) | 2019-06-06 | 2021-07-27 | International Business Machines Corporation | Replaying interactions with transactional and database environments with re-arrangement |
US11016762B2 (en) | 2019-06-06 | 2021-05-25 | International Business Machines Corporation | Determining caller of a module in real-time |
US10929126B2 (en) | 2019-06-06 | 2021-02-23 | International Business Machines Corporation | Intercepting and replaying interactions with transactional and database environments |
CN110287053A (en) * | 2019-06-27 | 2019-09-27 | 四川新网银行股份有限公司 | The method that distributed system is uniformly processed extremely |
CN110287053B (en) * | 2019-06-27 | 2022-11-04 | 四川新网银行股份有限公司 | Method for uniformly processing distributed system abnormity |
US11582238B2 (en) * | 2019-08-13 | 2023-02-14 | Dell Products L.P. | Securing a server from untrusted client applications |
US20230244782A1 (en) * | 2020-08-28 | 2023-08-03 | Siemens Aktiengesellschaft | Methods and systems for controlling access to at least one computer program |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US6282701B1 (en) | System and method for monitoring and analyzing the execution of computer programs | |
US6202199B1 (en) | System and method for remotely analyzing the execution of computer programs | |
US8312435B2 (en) | System and method for conditional tracing of computer programs | |
US7058928B2 (en) | System and method for conditional tracing of computer programs | |
US8504994B2 (en) | System and method for software diagnostics using a combination of visual and dynamic tracing | |
WO2000007100A1 (en) | System and method for remotely analyzing the execution of computer programs | |
US6026362A (en) | Tool and method for diagnosing and correcting errors in a computer program | |
US10073760B2 (en) | System and method for troubleshooting software configuration problems using application tracing | |
Bhansali et al. | Framework for instruction-level tracing and analysis of program executions | |
US8468502B2 (en) | Generic, multi-instance method and GUI detection system for tracking and monitoring computer applications | |
KR101004543B1 (en) | Debugging breakpoints on pluggable components | |
US5778230A (en) | Goal directed object-oriented debugging system | |
US7120901B2 (en) | Method and system for tracing and displaying execution of nested functions | |
US6077312A (en) | Apparatus, program product and method of debugging utilizing a context sensitive breakpoint | |
US7415699B2 (en) | Method and apparatus for controlling execution of a child process generated by a modified parent process | |
US7451455B1 (en) | Apparatus and method for automatically manipulating software products | |
US20080034351A1 (en) | Process for making software diagnostics more efficient by leveraging existing content, human filtering and automated diagnostic tools | |
CA2211373C (en) | Learn mode script generation in a medical imaging system | |
Zellweger | An interactive high-level debugger for control-flow optimized programs | |
US6707469B1 (en) | Synchronous execution in a medical imaging system | |
US8078590B2 (en) | Data processing system | |
EP2587380B1 (en) | Runtime environment and method for non-invasive monitoring of software applications | |
Gilles et al. | A guided tour through a window oriented debugging environment for embedded real time Ada systems | |
Yaghmour et al. | System administration: The Linux trace toolkit | |
Buhr et al. | KDB: Concurrent Debugger Reference Manual |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: MUTEX SOLUTIONS, LTD., ISRAEL Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:WYGODNY, SHLOMO;BARBOY, DMITRY;PROUSS, GEORGI;AND OTHERS;REEL/FRAME:009698/0673;SIGNING DATES FROM 19981212 TO 19981228 |
|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
AS | Assignment |
Owner name: IDENTIFY SOFTWARE LTD., ISRAEL Free format text: CHANGE OF NAME;ASSIGNOR:MUTEK SOLUTIONS, LTD.;REEL/FRAME:013343/0239 Effective date: 20020411 |
|
FEPP | Fee payment procedure |
Free format text: PAYOR NUMBER ASSIGNED (ORIGINAL EVENT CODE: ASPN); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
AS | Assignment |
Owner name: PLENUS TECHNOLOGIES LTD. OF DELTA HOUSE, ISRAEL Free format text: SECURITY INTEREST;ASSIGNOR:IDENTIFY SOFTWARE LTD.;REEL/FRAME:015596/0382 Effective date: 20041230 |
|
FPAY | Fee payment |
Year of fee payment: 4 |
|
AS | Assignment |
Owner name: IDENTIFY SOFTWARE, LTD., ISRAEL Free format text: RELEASE OF SECURITY INTEREST;ASSIGNOR:PLENUS TECHNOLOGIES LTD.;REEL/FRAME:020960/0243 Effective date: 20080514 |
|
REFU | Refund |
Free format text: REFUND - PAYMENT OF MAINTENANCE FEE, 8TH YEAR, LARGE ENTITY (ORIGINAL EVENT CODE: R1552); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY Free format text: REFUND - 7.5 YR SURCHARGE - LATE PMT W/IN 6 MO, LARGE ENTITY (ORIGINAL EVENT CODE: R1555); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
REMI | Maintenance fee reminder mailed | ||
FPAY | Fee payment |
Year of fee payment: 8 |
|
SULP | Surcharge for late payment |
Year of fee payment: 7 |
|
FPAY | Fee payment |
Year of fee payment: 12 |
|
AS | Assignment |
Owner name: CREDIT SUISSE AG, CAYMAN ISLANDS BRANCH, AS COLLAT Free format text: SECURITY AGREEMENT;ASSIGNOR:IDENTIFY SOFTWARE, LTD;REEL/FRAME:031833/0950 Effective date: 20131212 |
|
AS | Assignment |
Owner name: IDENTIFY SOFTWARE LTD. (IL), ISRAEL Free format text: RELEASE BY SECURED PARTY;ASSIGNOR:CREDIT SUISSE AG, CAYMAN ISLANDS BRANCH, AS COLLATERAL AGENT;REEL/FRAME:043678/0636 Effective date: 20170727 |