Search Images Maps Play YouTube News Gmail Drive More »
Sign in
Screen reader users: click this link for accessible mode. Accessible mode has the same essential features but works better with your reader.

Patents

  1. Advanced Patent Search
Publication numberUS5528753 A
Publication typeGrant
Application numberUS 08/269,334
Publication date18 Jun 1996
Filing date30 Jun 1994
Priority date30 Jun 1994
Fee statusLapsed
Publication number08269334, 269334, US 5528753 A, US 5528753A, US-A-5528753, US5528753 A, US5528753A
InventorsMichael R. Fortin
Original AssigneeInternational Business Machines Corporation
Export CitationBiBTeX, EndNote, RefMan
External Links: USPTO, USPTO Assignment, Espacenet
System and method for enabling stripped object software monitoring in a computer system
US 5528753 A
Abstract
A method and system for enabling the monitoring of a target software routine in a stripped object executable on a computer system. The system enables monitor instrumentation of the target routine without access to or recompiling the source code of the object and without access to information required to link with the stripped object. A single demultiplexor entry for each target routine provides access to common instrumentation code and to user specified entry and exit routines for the particular target routine. Common instrumentation code is not replicated when used to monitor a number of software programs. User specified entry and exit routines are used to collect selected performance and system state data. Common instrumentation code is provided to link the target routines to the user specified entry and exit routines. The standard link interface allows the entry and exit routines to be written in high level languages.
Images(5)
Previous page
Next page
Claims(5)
I claim:
1. A method for monitoring a plurality of software programs executable on a computer system, said software programs each having a plurality of computer executable instructions, said software programs being stripped of linkable information, the computer system having memory and a processor, the method comprising the steps of:
storing a plurality of monitoring programs for monitoring software execution said plurality of monitoring programs include common monitoring programs common to all of said software programs and entry/exit monitoring programs for performing monitoring actions for selected one or more of said software programs;
selecting one or more of said plurality of software programs for monitoring;
expanding each of said selected software programs to include an addressable entry for each of said monitoring programs and a demultiplexor entry for each of said selected software programs associating said software program with an appropriate one or more of said monitoring routines the expanding including the steps of:
determining a common routine address for said common monitoring program;
receiving an instrument routine address for said entry/exit monitoring programs for each of said software programs;
storing said common routine address and said instrument routine address in said demultiplexor entry;
copying a first of said executable instructions to a first addressable location; and
replacing said first executable instruction with a branch to the demultiplexor entry for said software program.
2. The method of claim 1, wherein the common monitoring programs include entry monitoring programs and exit monitoring programs and wherein the determining step includes the steps of:
determining an entry common routine address for said common monitoring program;
determining an exit common routine address for said common monitoring program;
and wherein said receiving step receives an entry instrument routine address and an exit routine address; and
wherein the storing step stores the entry and exit common routine addresses and the entry and exit instrumentation routine addresses in said demultiplexor entry.
3. A system for monitoring execution of a plurality of stripped object software routines on a computer system, the system comprising:
means for storing a plurality of monitoring programs at addressable locations in a storage means;
means for modifying a first instruction of each of said stripped object software routines to address one or more of said plurality of monitoring programs upon entry to said software routine and upon exit from said software routines said means for modifying including:
means for adding table of contents entries for said monitoring programs to said stripped object software routines;
means for adding demultiplexor entries associating one or more of said monitoring programs with each of said plurality of software routines;
means for selecting one or more of said software routines for monitoring;
means for inserting a branch to said added demultiplexor entry as a first instruction in each of said selected software routines;
means for saving said first instruction of said selected software routines in said demultiplexor entry.
4. The system of claim 3, wherein said monitoring programs include common monitoring code common to all of said plurality of software routines and instrumentation monitoring code unique to certain ones of said software routines, and further comprising:
means for directing execution to said common monitoring code; and
means for directing execution to said instrumentation code associated with each of the selected software routines.
5. The system of claim 3, further comprising:
means for collecting data generated by said monitoring programs.
Description
RELATED APPLICATIONS

The present invention is related to application Ser. No. 08/161,966 filed Dec. 3, 1993 having the title "System and Method for Enabling Software Monitoring in a Computer System" and application Ser. No. 08/161,967 filed Dec. 3, 1993 having the title "System and Method for Enabling Shared Library Software Monitoring in a Computer System."

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates generally to measuring the performance of computer systems. More particularly, it relates to the introduction of system monitoring routines to stripped object code software operating on a computer system. Still more particularly, the present invention relates to computer implemented methods and computer apparatus for enabling a computer system to collect information during the execution of software on that computer system without recompiling that software.

2. Background and Related Art

Computer system performance, e.g. the speed of operation or the throughput of a system, is a function of the computer system hardware and the efficiency of the software used on the system. Performance can be enhanced by ensuring that the software is efficiently written to most effectively use the hardware or by modifying the hardware to enhance certain software function.

The identification of performance problems requires an ability to monitor the execution of software on a particular hardware system and to be able to identify those sections of the software that are consuming inordinate amounts of hardware resource. For example, the execution of a software program can be monitored to determine how much processing time is spent in each subroutine.

Tracing program execution and monitoring execution adds significant overhead to program execution. Thus, most software does not include monitoring function in its basic form. Software developers may add instructions to the software to monitor selected portions, but these instructions are typically removed before the final version is shipped to customers or placed in regular use.

Introduction of an existing program onto new hardware or perception of performance problems in new software may create a requirement to monitor software that does not contain any inherent monitoring capability. This creates a need to "instrument" the software to measure performance. Instrumentation of software refers to the process of enabling the software to be monitored at selected points to capture significant system state data at those points.

Historically, instrumentation of software was accomplished by modifying the source code for the software to include monitoring instructions, recompiling the source code, and then executing the modified software. The approach has the disadvantages of requiring access to source code (which may not be available for commercially purchased software), and being error prone if the person modifies the code incorrectly. In addition, this form of instrumentation may introduce performance problems itself causing the results to be misleading.

A second approach to instrumentation uses special purpose hardware to record access to certain computer system functions. A special monitor is connected to the computer to record changes in the physical state of the machine, e.g. when a signal is received on a certain line or when certain memory addresses are accessed. This approach has the disadvantage of requiring the special purpose hardware. It is also limited to those functions that cause a recognizable physical change to the hardware. The approach is costly and not generally applicable.

Yet another approach has been suggested in U.S. Pat. No. 5,193,180 to Hastings. Hastings seeks to monitor memory access by expanding the program code to include specific monitoring instructions. Hastings avoids the need for source code by expanding relocatable binary files. However, the files to be expanded must have a full symbol table available because of the movement of relative locations due to the expansion. The technique is also not applicable to situations where the symbol table has been stripped from an executable object to save storage space. Finally, Hastings cannot be applied to an object already loaded into memory for execution due to the need to recalculate relative addresses.

Still another approach is suggested in commonly assigned application Ser. No. 07/662,521, bearing Attorney Docket Number AT991-001 entitled "System and Method for Computer System Profiling." This method is non-invasive and does not require modifying the code being monitored. The system and method are implemented in a software program that samples instruction addresses to be executed by the system. Summarization of the number of times an address is referenced and correlation to the source code causing generation of that instruction provides statistics on the time the program spends in certain sections of code. This approach has the disadvantage of being limited to estimating time spent in code sections and not allowing collection of other system state information. It also requires the source code to be available to generate an assembly listing for address to code correlation.

Monitoring of commercially distributed products can be even more difficult when those products are distributed as "stripped objects." A stripped object is the executable form of a program or system from which all non-essential information has been removed. The symbol table and related information is eliminated. Stripping significantly reduces the size of the executable file thereby improving disk storage efficiency for those programs. However, stripping makes instrumentation of program code more complex because techniques dependent upon linking the instrumentation code with the monitored code cannot be used. Linked instrumentation code is discussed in the above referenced related cases.

A technical problem therefore exists to provide a means of instrumenting a stripped object program for user defined performance monitoring without access to the program source code and without requiring special purpose hardware monitors.

SUMMARY OF THE INVENTION

The present invention is directed to providing a system and method for enabling monitoring of stripped object program performance without requiring access to the program source code.

The present invention is directed to a method for monitoring a plurality of software programs executable on a computer system, the software programs each have a plurality of computer executable instructions, the software programs being stripped of linkable information, the computer system having memory and a processor, the method comprising the steps of:

storing a plurality of monitoring programs for monitoring software execution;

selecting one or more of the plurality of software programs for monitoring;

expanding each of the selected software programs to include an addressable entry for each of the monitoring programs and a demultiplexor entry for each of the selected software programs associating the software program with an appropriate one or more of the monitoring routines;

copying a first of the executable instructions to a first addressable location; and

replacing the first executable instruction with a branch to the demultiplexor entry for the software program.

It is therefore an object of the invention to provide a system and method for efficiently instrumenting stripped object routines executing on a computer system.

It is yet another objective to provide a system and method that enables instrumenting of stripped objects without requiring access to the source code for those objects and without recompilation.

It is yet another objective of the invention to provide a system and method for instrumenting stripped objects after those objects have been loaded for execution in a computer system.

The foregoing and other objects, features and advantages of the invention will be apparent from the following more particular description of a preferred embodiment of the invention, as illustrated in the accompanying drawing wherein like reference numbers represent like parts of the invention.

BRIEF DESCRIPTION OF THE DRAWING

FIG. 1 is a block diagram illustrating a computer system on which the preferred embodiment of the present invention operates.

FIG. 2 is a flow diagram illustrating the normal flow of control to and from a routine.

FIG. 3 is a flow diagram illustrating the flow of control in an instrumented routine according to the present invention.

FIG. 4 is a diagram illustrating the layout of a shared memory segment used for recording data in the present invention.

FIG. 5 is a flowchart depicting the steps of the instrumentation process according to the present invention.

FIG. 6 is an illustration of the demultiplexor entry layout according to the present invention.

FIG. 7 is a diagram illustrating the detailed flow of execution in a system according to the present invention.

DETAILED DESCRIPTION

The preferred embodiment of the present invention operates on a computer system having a processing unit, system memory and various input/output and other peripheral devices. The preferred embodiment operates on and IBM RISC System/6000 computer running the AIX operating system. (IBM, RISC System/6000, and AIX are trademarks of the IBM Corporation.) It will be understood, however, that the invention can be implemented on other hardware platforms and on other operating systems.

The preferred embodiment is implemented with a computer system having the components shown generally for the system 100 in FIG. 1. Processing is provided by central processing unit or CPU 102. CPU 102 acts on instruction and data stored in random access memory 104. Long term storage is provided on one or more disks 122 operated by disk controller 120. A variety of other storage media could be employed including tape, CD-ROM, or WORM drives. Removable storage media may also be provided to store data or computer process instructions. Operators communicate with the system through I/O devices controlled by I/O controller 112. Display 114 presents data to the operator while keyboard 114 and pointing device 118 allow the operator to direct the computer system. Communications adapter 106 controls communications between this processing unit and others on a network to which it connected by network interface 108.

Instrumentation of software leads to the monitoring of a "target routine", i.e. that portion of the software for which data is to be collected. The target routine can be a complete program, a subroutine of a program, or a routine from a routine library. Also of interest in the present invention are routines that form the basis of an operating system, the "kernel" routines. The kernel is often provided as stripped objects. Analysis of kernel routine performance is often crucial to tuning a computer system for optimum performance. The present invention applies, however, to any stripped objects, not just kernel objects.

Each target routine has one or more entry points and one or more exit points. A target routine is invoked or called by a previous routine. The processor will transfer control to the target routine entry point. Instructions from the target routine will be executed until an exit back to the calling routine is encountered. The target routine instructions may include an invocation of another subroutine. In some cases, control will transfer to another routine and will never be returned to the calling routine. The flow of control is illustrated in FIG. 2. In FIG. 2 the "Call to Target" transfers control to the instruction at address 202. Target routine instructions 204 are executed until control is returned to the calling program at 206.

Enabling routine monitoring allows system state information to be collected at entry to the target routine and at exit from the routine. Entry and Exit monitoring provide statistics on how much time is spent in any routine and an ability to determine what changes to the system are caused by that routine. The logical flow of control after instrumentation according to the present invention is shown in FIG. 3. The Call to Target still points to address 202. After 202, however, control is passed to Entry Routine 210. Entry Routine 210 collects the information desired by the monitor and returns control to the target routine. Upon Exit from the Target Routine, control is passed to an Exit Routine 212 that collects additional data.

The present invention permits the Entry and Exit Routines to be written in a high level language such as C thereby making monitoring easier for the average programmer. This flexibility allows the programmer to collect precisely the information needed without introducing a great deal of complexity into the monitoring process. Within the Entry and Exit routines, the programmer can direct the system to send data to a printer, to a file, to the console, or to a shared memory segment. The routines also allow the function of a target routine to be fully replaced such that newly provided code will be executed instead of the base code in the routine being monitored.

An example of a shared memory segment for collecting monitor events is shown in FIG. 4. The shared memory segment 400 is an allocated area in the system memory that is defined as accessible to multiple processes. The segment preferably includes a header area 402, a counter area 404 for recording counts of selected events, and a event area 406 for recording a number of monitor events. The size of the memory segment is alterable based on the user requirements. The size allocated determines the total number of monitor events that can be captured in event area 406. Although this shared segment structure is preferred, other structures can be used within the scope of the invention.

The system and method of the present invention enable software monitoring by instrumenting the target routines selected by the user. The system and method perform the necessary target routine modifications thereby eliminating potential errors caused by incorrect manual modifications.

Stripped executable modules cannot be linked with the instrumentation code and cannot use the approaches discussed in the above mentioned related applications.

Instrumentation of stripped objects will be described with reference to FIG. 5. The instrumenting process starts at 502 and immediately proceeds to the creation of an instrumentation library 504. The instrumentation library contains common instrumentation code and the user provided entry and exit routines. Once the library is created the stripped objects must be modified to allow access to the instrumentation library. The lack of a symbol table for the stripped objects means that the instrumentation library cannot simply be linked with the objects. Another approach is required.

The preferred embodiment of the present invention instruments programs written in the C programming language and stored in the XCOFF executable format. The process of the present invention is applicable, however, to other languages and to other executable formats such as ELF. The changes required to adapt the following process to such environments are known to those in the data processing art.

First, the loader section of the stripped object is expanded 506. The expansion enables the addition of the instrumentation library to the list of dependencies for the stripped object. The dependency is added by updating the loader section's symbol and string tables as well as the loader section's relocation and import regions. As a result the system loader will be forced to load the instrumentation library prior to executing the first instruction of the stripped object.

Next, the text section of the stripped object is expanded 508 to allow for the insertion of the demultiplexor entries 510. A demultiplexor entry (demux-entry) is provided for each target routine. The demultiplexor entry serves to direct an instrumentation call to the appropriate common and user specific entry and exit routines. The demultiplexor of the present invention is similar to an electrical multiplexor because is selects a single entry and a single exit routine from a number of available routines based on the signal input values. The demux-entry contain instructions and data that link the target routine to the associated entry and exit instrumentation routines. Each demux-entry consists of four sections:

1. a data section;

2. a "Return to Target Routine" section;

3. an Exit section; and

4. an Entry section.

An example demux-entry is shown in FIG. 6. The data section 602 contains the addresses at which the target routine and the target routine's symbolic name reside within the text segment of the stripped object.

The "Return to Target Routine" section 604 contains the "saved" first instruction of the target routine and a direct branch back to the address of the second instruction of the target routine. This section ensures that all target routine instructions are executed in the proper order.

The Entry section 608 loads register r0 with the address of the demux-entry; saves all registers; and calculates the address of the common Entry code and the user supplied Entry instrumentation routine. Both the common Entry code and the Entry instrumentation code reside in the shared library and their addresses can be ascertained only by reference to the stripped object Table of Contents (TOC). The Entry section concludes by branching to the common Entry code via the count register that has been loaded with the address of the common Entry code. Immediately before the branch, register r0 is loaded with the address of the user supplied Entry instrumentation routine. The common Entry code will use r0 to branch to the Entry instrumentation routine.

Exit section 606 is very similar in structure to the Entry section with the difference that the common Exit code and the Exit instrumentation code are executed.

The preferred embodiment of the demux-entry contains only thirty-four (34) instructions and two integer data items. In the preferred embodiment which requires four bytes of storage for each integer, the total spatial cost to instrument each routine is 144 bytes. The majority of instrumentation code is provided as common code in a single shared copy. Thus, a large number of routines can be instrumented with only a small incremental increase in storage requirements.

Next, the stripped object data section is expanded 512 to include additional table of contents (TOC) entries for the instrumentation library. The TOC entries will include addresses for the Entry and Exit instrumentation routines making them addressable by the demux-entries.

The first instruction of the target routine is copied 514 to a specified location in the demux-entry. The first instruction is replaced with a branch to the Entry section of the associated demux-entry. This copy and replace is the only modification required to the target routine.

Instrumentation is now complete. The process above has been described in the preferred order, however, the sequence of the process steps can be varied significantly without departing from the spirit of the present invention.

The operation of the instrumented system according to the present invention will be described with reference to FIG. 7. Processing begins with a call to the target routine 702. This call will encounter the branch first instruction and immediately branch to the Entry section 704. The Entry routine saves the link register on the stack, saves the registers on the stack and calls 706 the common Entry code that in turn calls 708 user supplied Entry routine. The Entry routine can examine the stack, print a message, call trace, or perform other tasks. After returning from the Entry instrumentation routine 710 and common Entry code 712, the registers are restored and the link register is set to point to a specific offset in the demux-entry. The stored target routine first instruction is executed in the "Return to Target" section and control branches to the second instruction of the target routine 714.

Upon completion of the target routine, control is returned 716 to the demux-entry rather than the original calling routine. The demux-entry code saves the registers and calls 718 the common Exit code and calls 720 the user supplied Exit instrumentation routine with the return value from the target routine as a parameter. When the exit routine returns 722, the registers are restored, the link register is restored, and a return 724 is made to the original caller of the target routine.

It will be understood from the foregoing description that various modifications and changes may be made in the preferred embodiment of the present invention without departing from its true spirit. It is intended that this description is for purposes of illustration only and should not be construed in a limiting sense. The scope of this invention should be limited only by the language of the following claims.

Patent Citations
Cited PatentFiling datePublication dateApplicantTitle
US4866665 *1 Apr 198712 Sep 1989Burr-Brown Ltd.Break points system in a software monitor where entry address of break point routing equals op code of call instruction
US5047919 *14 Jul 198910 Sep 1991Harris CorporationMethod and apparatus for monitoring software execution in a parallel multiprocessor computer system
US5193180 *21 Jun 19919 Mar 1993Pure Software Inc.System for modifying relocatable object code files to monitor accesses to dynamically allocated memory
US5313616 *18 Sep 199017 May 199488Open Consortium, Ltd.Method for analyzing calls of application program by inserting monitoring routines into the executable version and redirecting calls to the monitoring routines
US5335344 *2 Nov 19922 Aug 1994Pure Software Inc.Method for inserting new machine instructions into preexisting machine code to monitor preexisting machine access to memory
Non-Patent Citations
Reference
1 *Bishop, Profiling Under UNIX by Patching, Software Practice and Experience, Oct. 1987, at 729.
2 *Johnson, Profiling for Fun and Profit, USENIX Winter 90 Conference Proceedings, at 325.
3Johnson, Profiling for Fun and Profit, USENIX Winter '90 Conference Proceedings, at 325.
4 *Wall, Global Register Allocation at Link Time, Digital Equipment Corporation, WRL Research Report 86/3, Oct. 1986.
Referenced by
Citing PatentFiling datePublication dateApplicantTitle
US5590056 *21 Sep 199531 Dec 1996Isogon CorporationMethod and apparatus for computer program usage monitoring
US5710724 *20 Apr 199520 Jan 1998Digital Equipment Corp.Dynamic computer performance monitor
US5732272 *31 Jul 199524 Mar 1998Apple Computer, Inc.Subroutine execution time tracer
US5809450 *26 Nov 199715 Sep 1998Digital Equipment CorporationMethod for estimating statistics of properties of instructions processed by a processor pipeline
US5903758 *24 Feb 199711 May 1999Sun Microsystems, Inc.Method and apparatus for auditing dynamically linked procedure calls
US5923872 *26 Nov 199713 Jul 1999Digital Equipment CorporationApparatus for sampling instruction operand or result values in a processor pipeline
US5949972 *23 Aug 19967 Sep 1999Compuware CorporationSystem for memory error checking in an executable
US5964867 *26 Nov 199712 Oct 1999Digital Equipment CorporationMethod for inserting memory prefetch operations based on measured latencies in a program optimizer
US6000044 *26 Nov 19977 Dec 1999Digital Equipment CorporationApparatus for randomly sampling instructions in a processor pipeline
US6026235 *20 May 199715 Feb 2000Inprise CorporationSystem and methods for monitoring functions in natively compiled software programs
US6029145 *6 Jan 199722 Feb 2000Isogon CorporationSoftware license verification process and apparatus
US6070009 *26 Nov 199730 May 2000Digital Equipment CorporationMethod for estimating execution rates of program execution paths
US6092180 *26 Nov 199718 Jul 2000Digital Equipment CorporationMethod for measuring latencies by randomly selected sampling of the instructions while the instruction are executed
US6119075 *26 Nov 199712 Sep 2000Digital Equipment CorporationMethod for estimating statistics of properties of interactions processed by a processor pipeline
US6138252 *1 Jul 199624 Oct 2000Sun Microsystems, Inc.Graphical test progress monitor
US6148396 *26 Nov 199714 Nov 2000Compaq Computer CorporationApparatus for sampling path history in a processor pipeline
US6163840 *26 Nov 199719 Dec 2000Compaq Computer CorporationMethod and apparatus for sampling multiple potentially concurrent instructions in a processor pipeline
US618667723 Apr 199813 Feb 2001Compuware CorporationByte code instrumentation
US619574826 Nov 199727 Feb 2001Compaq Computer CorporationApparatus for sampling instruction execution information in a processor pipeline
US6206584 *31 May 199527 Mar 2001Rational Software CorporationMethod and apparatus for modifying relocatable object code files and monitoring programs
US623705926 Nov 199722 May 2001Compaq Computer CorporationMethod for estimating statistics of properties of memory system interactions among contexts in a computer system
US6308270 *13 Feb 199823 Oct 2001Schlumberger Technologies, Inc.Validating and certifying execution of a software program with a smart card
US631455816 Feb 19996 Nov 2001Compuware CorporationByte code instrumentation
US633217826 Nov 199718 Dec 2001Compaq Computer CorporationMethod for estimating statistics of properties of memory system transactions
US633221315 Sep 199918 Dec 2001Compuware CorporationIR code instrumentation
US637436726 Nov 199716 Apr 2002Compaq Computer CorporationApparatus and method for monitoring a computer system to guide optimization
US644258526 Nov 199727 Aug 2002Compaq Computer CorporationMethod for scheduling contexts based on statistics of memory system interactions in a computer system
US6457142 *29 Oct 199924 Sep 2002Lucent Technologies Inc.Method and apparatus for target application program supervision
US64907219 Jul 19993 Dec 2002Oc Systems IncorporatedSoftware debugging method and apparatus
US6526456 *1 Jul 199625 Feb 2003David Ian AllanDistribution and controlled use of software products
US65395028 Nov 199925 Mar 2003International Business Machines CorporationMethod and apparatus for identifying instructions for performance monitoring in a microprocessor
US654993026 Nov 199715 Apr 2003Compaq Computer CorporationMethod for scheduling threads in a multithreaded processor
US65500024 Nov 199915 Apr 2003International Business Machines CorporationMethod and system for detecting a flush of an instruction without a flush indicator
US65747274 Nov 19993 Jun 2003International Business Machines CorporationMethod and apparatus for instruction sampling for performance monitoring and debug
US66187369 Mar 20019 Sep 2003Ensim CorporationTemplate-based creation and archival of file systems
US66188244 Nov 19999 Sep 2003Rational Software CorporationMethod and apparatus for modifying relocatable object code files and monitoring programs
US66314638 Nov 19997 Oct 2003International Business Machines CorporationMethod and apparatus for patching problematic instructions in a microprocessor using software interrupts
US6643842 *12 Sep 20014 Nov 2003Compuware CorporationByte code instrumentation
US667537412 Oct 19996 Jan 2004Hewlett-Packard Development Company, L.P.Insertion of prefetch instructions into computer program code
US668133111 May 199920 Jan 2004Cylant, Inc.Dynamic software system intrusion detection
US67116074 Feb 200023 Mar 2004Ensim CorporationDynamic scheduling of task streams in a multiple-resource system to ensure task stream quality of service
US671496216 Mar 200030 Mar 2004Microsoft CorporationMulti-user server application architecture with single-user object tier
US672194122 Aug 200013 Apr 2004Compuware CorporationCollection of timing and coverage data through a debugging interface
US673221118 Sep 20004 May 2004Ensim CorporationIntercepting I/O multiplexing operations involving cross-domain file descriptor sets
US6748555 *9 Sep 19998 Jun 2004Microsoft CorporationObject-based software management
US675471611 Feb 200022 Jun 2004Ensim CorporationRestricting communication between network devices on a common network
US6760903 *22 Aug 20006 Jul 2004Compuware CorporationCoordinated application monitoring in a distributed computing environment
US6876996 *19 Mar 20025 Apr 2005Sun Microsystems, Inc.Method and apparatus for using a shared library mechanism to facilitate sharing of metadata
US690158223 Oct 200031 May 2005Quest Software, Inc.Monitoring system for monitoring the performance of an application
US690742116 May 200014 Jun 2005Ensim CorporationRegulating file access rates according to file type
US69096917 Aug 200021 Jun 2005Ensim CorporationFairly partitioning resources while limiting the maximum fair share
US694800315 Mar 200020 Sep 2005Ensim CorporationEnabling a service provider to provide intranet services
US696193031 Mar 20001 Nov 2005Hewlett-Packard Development Company, L.P.Efficient, transparent and flexible latency sampling
US696398313 Jan 20048 Nov 2005Cylant, Inc.Method of and system for detecting an anomalous operation of a computer system
US697625830 Nov 199913 Dec 2005Ensim CorporationProviding quality of service guarantees to virtual hosts
US698593711 May 200010 Jan 2006Ensim CorporationDynamically modifying the resources of a virtual server
US6996808 *12 Feb 20007 Feb 2006Microsoft CorporationFunction injector
US7047521 *7 Jun 200116 May 2006Lynoxworks, Inc.Dynamic instrumentation event trace system and methods
US707678422 Oct 199911 Jul 2006Microsoft CorporationSoftware component execution management using context objects for tracking externally-defined intrinsic properties of executing software components within an execution environment
US708603513 May 19991 Aug 2006International Business Machines CorporationMethod and system for counting non-speculative events in a speculative processor
US709649915 Mar 200222 Aug 2006Cylant, Inc.Method and system for simplifying the structure of dynamic execution profiles
US7137105 *21 Mar 200114 Nov 2006Wind River Systems, Inc.Dynamic software code instrumentation method and system
US71430247 Jul 200028 Nov 2006Ensim CorporationAssociating identifiers with virtual processes
US718536716 Jun 200327 Feb 2007Cylant, Inc.Method and system for establishing normal software system behavior and departures from normal behavior
US7197431 *20 Aug 200127 Mar 2007International Business Machines CorporationMethod and system for determining the use and non-use of software programs
US72101183 Jul 200324 Apr 2007International Business Machines CorporationMethod and apparatus for modifying relocatable object code filed and monitoring programs
US721935422 Dec 200015 May 2007Ensim CorporationVirtualizing super-user privileges for multiple virtual processes
US72402448 Jun 20043 Jul 2007Microsoft CorporationObject-based software management
US7240335 *8 Oct 20033 Jul 2007Compuware CorporationByte code instrumentation
US72432718 Jun 200410 Jul 2007Microsoft CorporationWrapped object for observing object events
US734342114 Feb 200011 Mar 2008Digital Asset Enterprises LlcRestricting communication of selected processes to a set of specific network addresses
US735350118 Nov 20021 Apr 2008Microsoft CorporationGeneric wrapper scheme
US738951426 May 200417 Jun 2008Microsoft CorporationSoftware component execution management using context objects for tracking externally-defined intrinsic properties of executing software components within an execution environment
US7607051 *23 Mar 200620 Oct 2009Oki Electric Industry Co., Ltd.Device and method for program correction by kernel-level hardware monitoring and correlating hardware trouble to a user program correction
US77394014 Feb 200815 Jun 2010Pawan GoyalRestricting communication of selected processes to a set of specific network addresses
US7779302 *10 Aug 200417 Aug 2010International Business Machines CorporationAutomated testing framework for event-driven systems
US7784027 *4 May 200524 Aug 2010Quest Software, Inc.Systems and methods for monitoring a computing environment
US797924516 May 200712 Jul 2011Quest Software, Inc.Model-based systems and methods for monitoring computing resource performance
US81758628 Jul 20118 May 2012Quest Software, Inc.Model-based systems and methods for monitoring resources
US817586312 Feb 20098 May 2012Quest Software, Inc.Systems and methods for analyzing performance of virtual environments
US818115420 Aug 201015 May 2012Quest Software, Inc.Systems and methods for monitoring a computing environment
US83644604 May 201229 Jan 2013Quest Software, Inc.Systems and methods for analyzing performance of virtual environments
US84897643 May 201016 Jul 2013Digital Asset Enterprises, L.L.C.Restricting communication of selected processes to a set of specific network addresses
US85552449 May 20128 Oct 2013Dell Software Inc.Systems and methods for monitoring a computing environment
US88924157 May 201218 Nov 2014Dell Software Inc.Model-based systems and methods for monitoring resources
US921514219 Apr 201215 Dec 2015Dell Software Inc.Community analysis of computing performance
US927475828 Jan 20151 Mar 2016Dell Software Inc.System and method for creating customized performance-monitoring applications
US927517218 Jan 20131 Mar 2016Dell Software Inc.Systems and methods for analyzing performance of virtual environments
US947941430 May 201425 Oct 2016Dell Software Inc.System and method for analyzing computing performance
US955787923 Oct 201231 Jan 2017Dell Software Inc.System for inferring dependencies among computing systems
US20020026631 *20 Aug 200128 Feb 2002Isogon CorporationMethod and system for determining the use and non-use of software programs
US20020138753 *15 Mar 200226 Sep 2002Munson John C.Method and system for simplifying the structure of dynamic execution profiles
US20020199172 *7 Jun 200126 Dec 2002Mitchell BunnellDynamic instrumentation event trace system and methods
US20030093401 *19 Mar 200215 May 2003Czajkowski Grzegorz J.Method and apparatus for using a shared library mechanism to facilitate sharing of metadata
US20030191865 *10 Apr 20039 Oct 2003International Business Machines CorporationMethod and apparatus for software technology injection for operating systems which assign separate process address spaces
US20030204374 *21 Mar 200130 Oct 2003Madsen Kenneth E.Dynamic software code instrumentation method and system
US20040098707 *18 Nov 200220 May 2004Microsoft CorporationGeneric wrapper scheme
US20040107217 *3 Jul 20033 Jun 2004Reed HastingsMethod and apparatus for modifying relocatable object code files and monitoring programs
US20040133882 *8 Oct 20038 Jul 2004Angel David J.Byte code instrumentation
US20040143756 *13 Jan 200422 Jul 2004Munson John C.Method of and system for detecting an anomalous operation of a computer system
US20040225668 *8 Jun 200411 Nov 2004Microsoft CorporationObject-based software management
US20040225923 *8 Jun 200411 Nov 2004Microsoft CorporationObject-based software management
US20040226001 *8 Jun 200411 Nov 2004Microsoft CorporationObject-based software management
US20050027838 *29 Jul 20033 Feb 2005Magid Robert MarkSystem and method for intercepting user exit interfaces in IMS programs
US20050193376 *4 May 20051 Sep 2005Guy HarrisonSystems and methods for monitoring a computing environment
US20060036910 *10 Aug 200416 Feb 2006International Business Machines CorporationAutomated testing framework for event-driven systems
US20060248531 *23 Mar 20062 Nov 2006Oki Electric Industry Co., Ltd.Information processing device, information processing method and computer-readable medium having information processing program
US20080162730 *4 Feb 20083 Jul 2008Digital Asset Enterprises, L.L.C.Restricting communication of selected processes to a set of specific network addresses
US20110047496 *20 Aug 201024 Feb 2011Quest Software, Inc.Systems and methods for monitoring a computing environment
US20110238832 *3 May 201029 Sep 2011Pawan GoyalRestricting communication of selected processes to a set of specific network addresses
USRE4221413 Dec 20078 Mar 2011Pawan GoyalProviding quality of service guarantees to virtual hosts
USRE427269 Jan 200820 Sep 2011Digital Asset Enterprises, L.L.C.Dynamically modifying the resources of a virtual server
USRE4305119 Sep 200727 Dec 2011Digital Asset Enterprises, L.L.C.Enabling a service provider to provide intranet services
USRE4421015 May 20097 May 2013Digital Asset Enterprises, L.L.C.Virtualizing super-user privileges for multiple virtual processes
USRE4468619 Sep 201131 Dec 2013Digital Asset Enterprises, L.L.C.Dynamically modifying the resources of a virtual server
USRE4472314 Jun 200721 Jan 2014Digital Asset Enterprises, L.L.C.Regulating file access rates according to file type
WO1998016882A1 *9 Oct 199723 Apr 1998Ericsson Australia Pty. Ltd.A method and system for continuous software monitoring
WO2000043886A1 *14 Jan 200027 Jul 2000Applied Microsystems CorporationInstrumentation of calls to routines for which source code is unavailable
WO2000049502A1 *15 Feb 200024 Aug 2000Compuware CorporationByte code instrumentation
Classifications
U.S. Classification714/35, 714/E11.2, 714/E11.209, 714/53, 714/38.1
International ClassificationG06F11/36, G06F11/34
Cooperative ClassificationG06F2201/865, G06F11/3612, G06F11/3466
European ClassificationG06F11/36A4, G06F11/34T
Legal Events
DateCodeEventDescription
30 Jun 1994ASAssignment
Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:FORTIN, MICHAEL R.;REEL/FRAME:007081/0459
Effective date: 19940630
8 Sep 1999FPAYFee payment
Year of fee payment: 4
25 Sep 2003FPAYFee payment
Year of fee payment: 8
24 Dec 2007REMIMaintenance fee reminder mailed
18 Jun 2008LAPSLapse for failure to pay maintenance fees
5 Aug 2008FPExpired due to failure to pay maintenance fee
Effective date: 20080618