text:
System and method for performing monitoring of resources in a data processing system in real time
A graphical system resource monitor is provided to depict, in real-time, a data processing system's internal resource utilization. A window or viewport of a data processing system displays user specified internal system resources, such as memory, CPU, or peripheral device availability/utilization. This graphical representation of the `state` of the data processing system's resources is maintained in real-time, while the impact on the system's performance in providing such information is kept to a minimum. This is accomplished through a combination of various techniques, including specialized device drivers for the respective devices coupled with a unique data reduction technique. The graphical results of these resource monitors are continually updated in real-time. This real-time support provides an immediate and accurate representation of the internal operations of the data processing system. Further, these resources can monitored at the process level of a multiprocessing system. These representations can be used by a user to identify, isolate, and fine-tune the data processing system's resources to improve the overall efficiency of the system being monitored.
Latest IBM Patents:
A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.CROSS REFERENCES TO RELATED PATENT APPLICATIONS
"Method and Apparatus For Software Monitoring and Development", Ser. No. 07/458,045 and filed Dec. 27, 1989, now U.S. Pat. No. 5,121,501 assigned to same assignee as this application and hereby incorporated by reference.
"Real Time System Resource Monitor for Data Processing System with Support for Dynamic Variable Update and Automatic Bounding", application Ser. No. 07/713,471 now abandoned filed Jun. 10, 1991 in the name of D. R. Gartner et al, hereby incorporated by reference.
"Real Time Internal Resource Monitor for Data Processing System", application Ser. No. 08/259,368, still pending, filed Jun. 10, 1991 in the name of D. A. Bishop et al, hereby incorporated by reference.
1. Technical Field
This invention relates to data processing systems and more particularly to a graphical monitor of a data processing system's resource utilization.
2. Background Art
In the quest for continued improvements in efficiency and utilization of data processing systems, various types of data monitors have been developed to aid a user in understanding what is happening `under the covers` of these systems. Data processing system resources of interest comprise such things as random access memory(RAM) usage, peripheral device usage, and central processing system (CPU) busy/idle time. These resources can give an operator of a data processing system key information on fine tuning the various system parameters to achieve a higher efficiency of the data processing system's overall throughput.
Users of operating systems need information on how much memory is being used. Information on memory utilization, especially memory Working Set, is useful for showing if the physical memory in the computer is sufficient for the currently active applications. Insufficient memory allocation can cause inefficient system operations due to excessive swapping or paging that can occur based on this insufficiency. Prior products analyzing system memory generally take on the order of 15-45 seconds to execute, depending on the actual amount of system memory exists in the system. The information presented is useful for determining the RAM consumed by an individual application, but only when intrusiveness of the tool, on the system being monitored, is not a factor. These prior products use a text screen. Other previously reported techniques and tools have relied on specialized hardware assistance for measuring or calculating RAM usage.
Other techniques have been used to measure other types of data processing system resources. Direct internal monitoring, by the system itself, is one technique known to exist. These techniques typically consume large percentages of the data processing system's own resources in capturing data, and write the captured data to some type of mass storage device. Then a subsequent procedure is used to read and analyze this data (i.e. analysis not in real time).
Device utilization for peripheral devices has historically been measured directly by precisely measuring the start-time and complete-time for each I/O (input/output). This allows a calculation of the individual I/O times. By summing these I/O times over a given period it was possible to calculate total busy time. Then, device utilization is calculated by dividing total busy time by total elapsed time. This approach creates two problems. First, it requires that the entity directly in control of the I/O (usually, either the device hardware and/or operating system) measure and record the I/O start/stop times. Next, it requires a hardware timer with sufficient resolution to accurately time these I/O events. On some systems, for example personal computers, neither of these criteria are met. In other words, the hardware or operating system does not measure I/O time. Further, the hardware timer is of such poor resolution (32 milliseconds) in many of today's personal computers that accurate I/O timings cannot be made. Thus, for existing personal computer systems, device utilization is not obtainable using these conventional methods.
CPU idle time in a data processing system is the amount of time the computer's Central Processing Unit (CPU) is not being utilized by any task. Previous methods for measuring CPU idle time used a thread to perform a series of tasks. The number of tasks the thread performed was then compared with a hypothetical number of tasks that could have been performed, if the thread was allowed all available CPU time. This procedure is lacking in that the hypothetical number of tasks is different on different data processing systems. A system specific calibration algorithm is required to determine the minimum time the task(s) required to execute. This calibration method can be unreliable and presents many practical problems when moving between systems.
In general, the above types of systems are further lacking in that as performance data is gathered, it is written by the gathering system to a relatively slow mass storage device for further analysis. This is because the methods for capturing the data operate much faster than the methods used to analyze the data. Thus, the mass storage device is used as a buffer to allow the methods to operate at different operational speeds. Furthermore, the data generated by the data gathering system is of such a voluminous nature that the analysis method is unable to manage or maintain the large quantity of data. This constraint additionally required storage to an intermediate mass storage device.
As a result of this intermediate buffering, the analysis cannot be performed in real time, but rather is delayed. As such, any reports or other types of feedback of system performance and operation are chronically out of date with the actual performance. As today's data processing systems are supporting more complex operating environments, including support for multi-tasking and multi-users, this delay in performance data may cause critical system bottlenecks to continue unreported as the cause of any problem may have come and gone before being detected.
Other methods used to analyze the data require a significant amount of the gathering system's resources, such as the CPU. As a result, the analysis cannot be done in real time, as the analysis consumes such a large percentage of the resources, as it would bias the data to not be meaningful of the underlying system operation.
Some systems have attempted to overcome the above limitations, but in doing so have failed to maintain or capture information at a process level of a multiprocessing system. Rather, overall system usage can be monitored, with no ability to focus on a particular process that may be causing the system to be performing poorly. This failure of process resolution results in showing that an overall system may be performing poorly, but no meaningful indication of which process in the system is the culprit.DISCLOSURE OF THE INVENTION
This invention solves the above mentioned problems and deficiencies by providing a graphical display of user specified internal system resources, such as memory, CPU, or peripheral device availability/utilization in real time. This graphical representation of the `state` of the data processing system's resources is maintained in real-time, while the impact on the system's performance in providing such information is kept to a minimum. This is accomplished through a combination of various techniques, including specialized device drivers coupled with unique data reduction techniques. This allows for information to be captured at a process granularity of a multiprocess system, and thus resources for a given process can be monitored. The graphical results of these resource monitors are conveniently presented to a user in a window or viewport of a data processing system display, and the data is updated in real-time. This real-time support provides an immediate and accurate representation of the operations of the data processing system. These representations can be used by a user to identify, isolate, and fine-tune the data processing system to improve the overall efficiency of the system being monitored.
For memory utilization, including RAM working set, an extremely efficient mechanism is used to compare Least Recently Used (LRU) timestamps by a device driver.
For peripheral device utilization measurements, such as disk drives or communication lines, the average amount of time that the peripheral device is busy is calculated. The methods utilized for this measurement do not require additional device firmware assistance, or precision timing hardware as were required by previous methods of obtaining device utilization information. Minimal operating system assistance is achieved by using hooks in the peripheral device drivers.
For CPU utilization, a process is assigned to the lowest priority, or idle, level of the processing system. The amount of time which this idle event is in operation represents the CPU idle time.
It is therefore an object of this invention to provide an improved resource monitor.
It is a further object of this invention to provide a resource monitor that operates in real time.
It is yet another object of this invention to provide a self-contained data processing system monitor that operates in real time.
It is yet another object of this invention to provide a self-contained data processing system process monitor that operates in real time.BRIEF DESCRIPTION OF THE DRAWINGS
The foregoing and other objects, aspects and advantages of the invention will be better understood from the following Best Mode for Carrying Out the Invention with reference to the figures listed below, in which:
FIG. 1 shows the conceptual model of the system performance monitor.
FIG. 2 shows the functional model of the system performance monitor.
FIG. 3 shows the categories of system memory being monitored.
FIG. 4 depicts the working set calculation timing.
FIG. 5 shows the system memory usage algorithmic flow.
FIG. 6 shows a graphical representation of system resources being measured.
FIG. 7a-7b shows the use of a viewport menus.
FIG. 8 shows the flow for accepting user input and updating parameters.
FIG. 9 shows how peripheral device utilization is measured.
FIG. 10 shows the construction of a high resolution system timer.
FIG. 11a-11b shows the format of a generalized record which is stored in the internal device driver buffer.
FIG. 12 the syntax structure for an application programming interface to a performance data gathering control program.
FIGS. 13a-13c details the trace pipe records.
FIG. 14 shows a data processing system.
Appendix A-1 thru A-16 is sample C source code for interfacing to the API.BEST MODE FOR CARRYING OUT THE INVENTION OVERVIEW
The following method and system discloses a unique way to monitor a data processing system's resources, including RAM utilization, CPU idle time, and peripheral device utilization. This monitoring can be performed either internal to the system, or on a remote device attached via conventional communications methods. Various monitoring and tracing techniques are used for each respective resource being monitored. Data can be captured and presented at a process level in a multiprocessing environment. Other types of data processing system resources could be similarly monitored, such as data cache, using similar techniques of this invention, without departing from the claimed scope of this invention. The overall scheme is integrally packaged in an easy to use system, with real-time graphical depiction of resource parameters and support for user-modification of monitored variables. For purposes of the following discussion, it should be noted that `real time` is defined by Webster's New Collegiate Dictionary to mean the actual time in which an event takes place with , the reporting on or recording of the event practically simultaneous with its occurrence.
Referring now to FIG. 1, the disclosed monitoring system 21 is conceptually divided into two distinct operations, a Data Collection Facility (DCF) 23 and a Resource Monitor (RM) 25. An application programming interface 27, or API, is used as the interface between these two operating models. A named pipe 29, as readily known to those of ordinary skill in the art and further described in "IBM OS/2 Programming Tools and Information, Version 1.2", and hereby incorporated by reference as background material, is used to establish the connection between the DCF 23 and RM 25. The DCF 23 collects key performance data for various resources 31 being tracked. The RM 25 provides a depiction of resource usage. In the preferred embodiment this depiction is displayed graphically on a conventional data processing system display 33. As a named pipe 29 is used, the system as shown can have the Data Collection Facility 23 running on a computer distinct from the computer running the Resource Monitor 25, when the systems are connected via conventional communications techniques. This is because using the named pipe allows for network transparent operation.
Referring now to FIG. 2, this system 21 is functionally divided into three sub-categories of operations, which are data collection techniques 35, data reduction techniques 37, and presentation techniques 39. The data collection techniques 35 include RAM working set utilization and sampling of peripheral devices. The data reduction techniques 37 include measuring an idle thread to determine CPU idle time, filtering of trace data and other reduction methods. Finally, the presentation techniques 39 include dynamic monitoring and multi-viewport windowing. FIG. 2 further illustrates this functional representation being overlayed over the conceptual model of FIG. 1. As can be seen by FIG. 2, the data collection techniques 35 are fully contained within the Data Collection Facility 23. The data presentation techniques 39 are fully contained within the Resource Monitor 25. The data reduction techniques 37 are coexistent in both the Data Collection Facility 23 and the Resource Monitor 25. As will be subsequently shown, the sharing in responsibility for the data reduction techniques 37 allows for efficiencies in both data capture and ultimate graphical depiction of the resource being monitored. The particular methodologies for each resource being monitored in the preferred embodiment will now be described.RAM UTILIZATION
One of the system resources 31 of FIG. 1 which can be monitored is RAM utilization. The disclosed monitoring method quickly (in milliseconds) calculates the memory utilization for an entire operating system. It displays the results graphically in real time. In the preferred embodiment, the operating system is the IBM OS/2.sup.1 operating system, but these concepts could be readily adapted by one of ordinary skill in the art to any other type of computer operating system.
.sup.1 Trademark of IBM Corp. called the "Working Set Period". The Working Set Period may be dynamically changed, as described in the Dynamic Monitoring section.
Referring now to FIG. 3, various categories of the total physical memory 41 are defined, with each respective category's utilization being graphically depicted. Fixed Memory 43 is memory in a segmented swapping memory scheme that cannot be swapped out or discarded. It remains allocated in RAM as long as the application that owns this memory is loaded. Working Set Memory 45 is defined as (i) all the memory segments which are not swappable nor discardable, and (ii) all the memory segments which are swappable/discardable and which are used during the execution of the applicable scenario. Used Memory 47 is RAM allocated by the system and present in physical memory (i.e. memory that is allocated and not swapped out). Working Set Memory is not an instantaneous value. It is the memory used over a period of time
To calculate the Working Set Memory 45 of the whole system, an enhanced device driver provides a very quick calculation of memory utilization. It uses a Working Set Period dynamically specified by the user. The device driver, which is coded in assembly language and runs at Ring O for best performance and uninhibited access to protected resources, obtains the Working Set for the whole system, not by session as was previously done in the prior art. Ring O will be known to those of ordinary skill in the art to be the ring running at the core level of an operating system, or most closest to the CPU hardware. Other levels, such as levels 1-3 in the preferred embodiment operating system of OS/2, run at respectively lower access levels of the CPU's internal resources.
In reference to FIG. 4, the reported Working Set Memory is the percent of memory accessed over the last "Working Set Period" 51 seconds. It is updated, or snapshots are taken, every "Sampling Period" 53 seconds. This invention uses a sliding window 55 of memory use to calculate the Working Set Memory. The snapshot of memory taken every Sampling Period examines the Least Recently Used (LRU) timestamps for all memory segments (the methods for timestamping will be described later, in the device driver section). The LRU timestamps tell how recently a memory segment was accessed. For each snapshot, two values are found:
1. The latest LRU timestamp for the entire contents of memory. This value is the last time the most-recently-accessed part of memory was accessed. This value is used "Working Set Period" seconds later.
2. Which segments have been accessed since the LRU time stamp value that was saved "Working Set Period" seconds ago. The sum of the size of these segments comprises the Working Set 25 for that time period.
The procedure works as follows. The device driver walks through all the physical memory blocks. For each swappable, discardable block it does two comparisons:
1. Compares the block's LRU timestamp to the LRU timestamp acquired Working Set Period seconds earlier.
If the block's timestamp is greater than Working Set Period timestamp, then the block is in the Working Set, and the block size is added to the Working Set sum.
2. Compares the block's LRU timestamp to the maximum (newest) timestamp found thus far; if larger, it uses this new value for the current maximum timestamp.
The device driver returns the maximum (newest) LRU timestamp, the sum of the size (in bytes) of all the blocks in the Working Set, and the total physical memory.
This procedure is depicted in more detail in FIG. 5. Various variables are initialized at 60. The next block of memory is read by the device driver at 72. The blocksize of memory being read is added to variable 70 which contains the count of Physical Memory at 74. A determination is made on whether the block is free, or unused, at 76. If not free, the blocksize is added to the variable 66 which contains the count of Used Memory at 78. Next, a determination is made on whether the block is swappable/discardable at 80. If not, the blocksize is added to the variable 68 which contains the count of Fixed Memory at 82. Additionally, since Fixed Memory is defined to be part of Working Set, the blocksize is also added to the variable 64 which contains the count of Working Set memory at 86. If the block is swappable/discardable, processing continues to 84 where a check of the block's LRU timestamp is made. If the block LRU timestamp is greater than the maximum Working Set Period timestamp, the blocksize is added to the variable 64 which contains the count of Working Set memory at 86. In either event, the next determination is made at 88 on whether the block's LRU timestamp is greater than MaxTimestamp 62. If it is greater, the block LRU timestamp is saved as the new MaxTimestamp 62 at 90. Finally, a check is made to see if more blocks exist at 92. If so, processing continues at 72. If not, the device driver returns at 94 the values for MaxTimestamp, Working Set memory, Used memory, Fixed memory, and Physical memory as defined in FIG. 3.
A graphics program, to be later described, invokes the device driver on a periodic basis, plotting the Working Set Memory as a percentage of the whole physical RAM in the user's machine. This invocation is achieved by the Data Collection Facility communicating via a system API call to the device. Information is then passed to the graphics program via the API over named pipes 29 of FIG. 1. Referring again to FIG. 3, the device driver is invoked every Sampling Period 53 to recalculate the Working Set Memory 45 (if the Working Set exceeds physical memory, it is displayed as 100%). As can be seen in FIG. 8, a typical Sampling Period is 5 seconds and a typical Working Set Period is 60 seconds.
Referring now to FIG. 6, Fixed and Used Memory are graphed as the upper 100 and lower 102 bounds, respectively, of the Working Set Memory. Since the Working Set Memory 104 is never less than the Fixed Memory nor more than the Used Memory, the graph shows the possible range of the Working Set Memory. This feature assists a user in providing a self-calibration mechanism such that the absolute possible minimum and maximum values are depicted on the graph automatically. The minimum absolute value is the computed value of Fixed memory, and the maximum absolute value is the computed value of Used memory.
For a stable scenario, if the Working Set Period is decreased, the reported Working Set will be lower because less memory is typically accessed over shorter periods of time. If the Working Set Period is increased, the Working Set is higher because more memory for more applications is typically accessed over longer periods of time.
The value of the Working Set Period parameter can affect the reported Working Set Memory. Longer periods cause the Working Set Memory to approach Used Memory, or the upper limit. Shorter periods cause Working Set Memory to approach Fixed Memory, or the lower limit. Fixed and Used memory are instantaneous values. Working Set, however, is defined as memory used over a period of time.
The following Table 1 describes how the RAM monitor can be used to interpret system resources.
TABLE 1 ______________________________________ RAM Monitor Scenario Interpretation Scenario Interpretation ______________________________________ A large application The loaded program is is loaded. The reported as part of working set shows a the working set, and its a big increase. The fixed memory is reported as fixed memory shows a part of the system fixed small increase. The memory (also included in user decides not to the working set). For 60 use the application seconds the memory used for a while, and a loading the program continues minute later the to be reported in the working working set drops back set. down. Because the application is not active during the 60 seconds (and therefore most of the application's memory is not accessed), the working set drops back down after a minute even though the program is still loaded. The application's fixed memory, however, is still reported as part of the working set and as part of fixed memory. A large application is This application probably loaded. The working uses more memory than it will set shows a bigger during normal operation. The increase than expected. reported working set may drop later during normal opera- tion. A large application is When OS/2 unloads the loaded but then application, OS/2 frees the immediately ended. application's memory. Freed The reported working memory is not reported in set rises and falls working set. quickly. The swap-in and When new segments must be swap-out graphs show swapped in or loaded, old quite a bit of segments that have not been activity, even though accessed recently may need to the working set is not be swapped out or discarded. 100% The memory swapped out was reported in the working set if it was last accessed more than 60 seconds ago. Even with occasional swap activity, there may still be. enough memory for good performance. More physical memory is not necessarily needed. When the OS/2 system The fixed memory may include and the SPN a large VDISK or DISKCACHE as application first as defined in the CONFIG.SYS start, fixed memory is file. higher than anticipated. For a stable scenario, The working set is lower the working set period because less memory is is changed from 60 typically accessed in 10 seconds to 10 seconds. seconds than in 60. The reported working set is now lower. For a stable scenario, The working set is higher the working set period because more memory for more is changed from 60 applications is typically seconds to 1000 accessed in 1000 seconds than seconds. The reported in 60 seconds. working set is now higher. ______________________________________ Note: The Working Set Period is set to 60 seconds for all scenarios.
This information on memory utilization, especially the Working Set Memory, is useful for showing if the physical memory in the computer is sufficient for the currently active applications. This technique further allows a user to ask `what if?` questions without actually resetting the parameters that affect the variable or entity in question. In summary, this technique quickly calculates the Random Access Memory (RAM) utilization for an operating system as a whole, including the Working Set, Fixed, and Used amounts of RAM and displays these results graphically.DYNAMIC MONITORING
The procedure for allowing a data processing system user to vary parameters that affect the display of dynamic monitors on a display screen will now be described. This procedure concerns the control of dynamic monitoring of a time-related function on a data processing system display when the function is affected by at least one variable. The data being monitored varies depending upon how certain parameters are set. As shown in FIG. 7b, a dialogue box is presented to a user on the display screen, which the user has selected from the window's menu or action bar 110 as shown in FIG. 7a. This dialogue box 120 contains fields 122 in which the user can enter new values of the parameters. After the user types in new, or modified, parameters, the program dynamically modifies the underlying function to use the new parameter's value. This is accomplished via an API call by the program controlling the dialogue box to the program controlling the data collection. As shown in FIG. 8, a user parameter is queried at 112 via a dialogue box on the screen of FIG. 7b. A check is made at 114 to determine if the parameter is valid. If not valid, an error message is displayed at 116 and the user parameter is again queried at 112. If valid, the new parameter is sent via a named pipe (29 of FIG. 1) to the Data Collection Facility API at 118. The Data Collection Facility accepts data and changes the parameter of the specified function at 119.
Although the preferred embodiment uses a dialogue box, other types of controls could similarly be used to obtain new parameters from a user, such as scroll bars, spin buttons, entry fields or command line parameters.
This method for varying parameters is used to modify the above-described RAM Working Set Period, the parameter which affects the dynamic display of the RAM Working Set Memory on the RAM Monitor window. As was previously discussed, the RAM Working Set Memory usually becomes lower when the user selects a lower RAM Working Set Period, and higher when selects a higher RAM Working Set Period.PERIPHERAL DEVICE UTILIZATION
The general technique used for determining device utilization does not require high-resolution timing or changes to the hardware and/or operating system. Rather, this method periodically samples the device's status and records the number of times that the device returns a `device busy` status. The technique used for generating the periodic rate can vary from implementation to implementation, and is not specific or critical to understanding the underlying device utilization measurement technique. For example, on a personal computer it is convenient to use the hardware timer interrupt, which occurs every 32 milliseconds on an IBM Personal Computer running OS/2, and every 55 milliseconds when running DOS. Further, the technique used to query device status will vary from device to device, but is similarly extendable to other types of devices without departing from the spirit and scope of the present invention. For example, an IBM Personal Computer ESDI disk drive provides continuous status at input port address x`3512` (hex). Other devices require that a device query command be sent to the device before before the device returns status information.
Referring now to FIG. 9, the collection program 140, which is a device driver in the preferred embodiment, receives interrupts 142 from a hardware timer 144. Each timer `tic` causes the poll count to be incremented at 146. Then, the device 148 being measured is queried at 152, through its associated device controller 150 to determine if the device 148 is busy or not. This busy information is reported at 154 by the device controller 150. A check is made at 156 to see if the device reported a busy status. If so, the Busy Count is incremented at 158, and the collection ends until triggered again by a tic 142.
Once the collection program has a sufficient number of samples, as determined by the user specified or default parameters, the reporting program 162 then gathers the busy and total counts at 164, and calculates device utilization at 166 by dividing the busy count by the total count. This calculation is shown as follows:
Device Utilization=Busy Count/Total Count
This utilization number can then be reported by any number of methods, such as written to the display at 168 in either numeric or graphical form as hereinafter described, or written to a log file. This report program periodically invokes the collection program device driver, and plots the ratio of the number of busy tics to the total number of tics 142 as a ratio, in the preferred embodiment. The device driver is invoked every one second to recalculate the device utilization, although the frequency of this invocation is user-defined and modifiable by the procedures described elsewhere in this preferred embodiment description.
Because device utilization is being estimated by sampling, rather than measured directly, there is potential for error in the estimate. Statistical methods can predict this potential error. As will be readily understood by those of skill in the art, the sampling technique above uses repeated samples that have only two possible values, busy or not busy. Such samples are called Bernouli samples, and follow the Binomial Distribution. Further, if the number of samples is relatively large, say greater than 20, then the Binomial Distribution may be approximated by the Normal Distribution. For the Normal Distribution, the error in the sample percentage as compared to the actual percentage is less than:
a=Desired confidence level(typically 0.95 or 0.99)
Z=Standard random variable for Normal Distribution
x=`Successful` number of samples (in this case, busy samples)
n=Total number of samples
The value for Z(a/2) is found in statistical tables. For a 95% confidence, Z(a/2) equals 1.960. For a 99% confidence Z(a/2) equals 2.576.
As a specific example, consider that on an IBM Personal Computer running OS/2 a total of 10*1/.032=312 samples can be collected in 10 seconds. Further, consider that the largest value that the (x/n*(1-x/n)) can attain is 0.25 when the x is exactly one-half of n (This assertion can be proved by elementary calculus). One can then assert with 95% confidence that the maximum error found in a ten second device utilization estimate does not exceed:
A similar calculation would show that the maximum error in a one minute sample would be 2.3%. Thus, statistics show that the device busy sampling method described above does provide good accuracy in estimating device utilization. Further, this method is simpler and less expensive than previous used methods in obtaining device utilization information.
An alternative method of measuring peripheral device utilization is as follows. For measuring logical disk activity, file system events, which are generated when processes access the file system via an API, are traced and reduced by the methods described in the device driver section.CPU ACTIVITY
CPU activity, or utilization, is measured in the preferred embodiment by starting a process and assigning the process to the lowest priority level in the system. Rather than tracking the amount of work that the process can perform, as was done in the prior art, this invention tracks the amount of time this lowest priority process is executing in the system. Since the process only executes when all other processes at a higher priority have completed their tasks, and no longer need the CPU, the amount of time the system is idle (or available to perform other tasks) is the amount of time the idle process was executing. In the preferred embodiment, data processing system tasks are divided into four classes: (i) Time Critical, which is the highest priority, (ii) Fixed High, which runs before any regular task, (iii) Regular, which is the normal class assigned to application programs, and (iv) Idle, which means don't run if Time Critical, Fixed High, or Regular priority tasks are ready to execute.
In the preferred embodiment, the OS/2 RAS Trace Facility, or SYSTRACE, provided by the OS/2 operating system is used to obtain an event trace of this low-level process system activity. This SYSTRACE facility is more fully discussed in the device driver section. Other similar types of system tracing facilities provided by other operating systems could be used in a similar manner to provide this utility, and not depart from the spirit and scope of the present invention. The following describes the specific SYSTRACE utilization.DEVICE DRIVER
In the preferred embodiment, a device driver has been written to perform the following SYSTRACE utility. The device driver is installed in the normal way, being identified in the CONFIG.SYS file which the data processing system reads upon Initial Program Load(IPL). Special groups of instructions, called hooks, are included at key points in system and application programs in order to track execution flow. Each hook has a unique identity (Major code and Minor code) distinguishing it from all other hooks, and may or may not include key program variables, symbols, or return codes as data items. In the preferred embodiment of OS/2, there exists a facility known as SYSTRACE which provides means for hooks to be generated, collected, and stored in a buffer. Other operating systems provide similarly functionality through their own system utilities, and this utility can be considered as a generic tool for managing hooks.
The device driver intercepts all hooks passing through SYSTRACE, filters out undesired hooks or information contained therein, and passes only the precise hooks and information desired by the control program. The device driver and control program are the two elements comprising the previously discussed Data Collection Facility.
Upon device driver installation during system initialization, a 64K buffer is allocated in which data will be formatted and passed to the control program. This buffer is internally divided into two 32K buffers, with a portion of the second buffer being a communications area for use between the device driver and the control program. The communication area is simply a portion of data processing system memory reserved for variables. This memory is accessible by both the device driver and the application program. The following Table 2 defines the variables which occupy the highest (i.e. last) 32 words of the second 32K buffer.
TABLE 2 ______________________________________ time.sub.-- int equ OFFEOH First DD variable uses OFFEO & OFFE2 varAO equ OFFEOH One of words used on timetag arithmetic varA2 equ OFFE2H One of words used on timetag arithmetic start.sub.-- time equ OFFE4H Second DD variable uses OFFE4 & OFFE6 varBO equ OFFE4H One of words used on timetag arithmetic varB2 equ OFFE6H One of words used on timetag arithmetic elapsed.sub.-- time equ OFFE8H Third DD variable uses OFFE8 & OFFEA var.sub.-- FFE8 equ OFFE8H One of words used on timetag arithmetic var.sub.-- FFEA equ OFFEAH One of words used on timetag arithmetic Dekko.sub.-- SEL equ OFFECH Fourth DD: DEKKO FIRST OFFEC only 1 word PID equ OFFEEH Fourth DD: OTHER word for PID var.sub.-- FFEC equ OFFECH One of words used on timetag arithmetic var.sub.-- FFEE equ OFFEEH One of words used on timetag arithmetic flush equ OFFOH if 1, flush hook, otherwise process normally var.sub.-- FFFO equ OFFOH One of words used on timetag arithmetic switch equ OFFF2H if not 0, switch buffers == "flush buffers" var.sub.-- FFF2 equ OFFF2H One of words used on timetag arithmetic reals equ OFFF4H accumulates number of real mode hooks var.sub.-- FFF4 equ OFFF4H One of words used on timetag arithmetic var.sub.-- FFF6 equ OFFF6H One of words used on timetag arithmetic var.sub.-- FFF8 equ OFFF8H One of words used on timetag arithmetic int.sub.-- nesting equ OFFAH keeps up with nesting depth of interrupts var.sub.-- FFFA equ OFFAH one of words used on timetag arithmetic current.sub.-- time equ OFFCH last DD variable uses OFFFC & OFFFE oldtime equ OFFCH save previous value biotime equ OFFEH keep up with high word of time shortbuf equ O2O2OH approx. 24 bytes effective buffer size is 08000 - shortbuf ______________________________________Hooking
Also during this device driver install, the device driver saves a copy of the original SYSTRACE code located at the label "strp.sub.-- common" for future use. A call to the OS/2 system routine DevHelp is used to obtain this address, as shown below:
TABLE 3 ______________________________________ SAMPLE ASSEMBLY CODE TO OBTAIN THE LOCATION OF "strp-common" AX:BX POINTS TO THE VARIABLE ______________________________________ mov a1,10D mov dl,DevHlp.sub.-- GetDOSVar call DevHelp ______________________________________
At some later time, the control program executes a "READ" to the device driver at which time the device driver installs a patch (modified code) over a portion of the SYSTRACE kernel code. The patch contains bi-modal (REAL or PROTECT, two differing addressing modes known to those of ordinary skill in the art to be a part of the Intel microprocessor architecture) code which can intercept hooks coming through SYSTRACE in either REAL or PROTECT mode, and filter out those tasks of interest, and perform other tasks, such as event tracing.Unhooking
At a still later time, when the system is ready to shutdown, the control program executes a "WRITE" to the device driver, at which time the previously saved SYSTRACE kernel code is restored to its original position in the SYSTRACE facility, thus fully reinstating the original SYSTRACE function.DATA GATHERING
Event tracing refers to a process of tracing events as they occur in the data processing system. Time stamps are associated with each event. The events are stored and processed in chronological order. Since the events are chronologically ordered, the events provide the sequence of activities that take place in the data processing system. An example of an event trace is shown in the following Table 4.
TABLE 4 ______________________________________ EVENT TRACE EXAMPLE ______________________________________ Time.sub.-- 0 Event.sub.-- 0 data Time.sub.-- 1 Event.sub.-- 1 data Time.sub.-- 2 Event.sub.-- 2 data Time.sub.-- 3 Event.sub.-- 3 data Time.sub.-- 4 Event.sub.-- 4 data Time.sub.-- 5 Event.sub.-- 5 data Time.sub.-- n-1 Event.sub.-- n-1 data Time.sub.-- n Event.sub.-- n data ______________________________________
The SYSTRACE facility uses the low resolution system clock to place time stamps on events its processes. This is inadequate for the present invention when attempting to analyze performance on system resources. Thus, one of the data processing system's timers is used to determine the delta (difference) times between events and to replace the time in the SYSTRACE records shown above in Table 3 with a high resolution time tag.TIMER
The hardware timer of the preferred embodiment is an Intel 8253 timer, which has multiple timers contained within. More detailed information on the 8253 timer can be found in the Intel Manual entitled "Intel Component Data Catalogue", available from the Intel Literature Dept. in Santa Clara, Calif., and hereby incorporated by reference as background material. Timer 0 is programmed to Mode 2. This mode provides a high resolution timer which starts at 0.times.FFFF and counts downward to 0.times.0000 and repeats. The timer function again begins at 0.times.FFFF, or in other words the timer rolls-over. Timer 3 is partially initialized so that the ordinary interrupt generated by other timers on the 8253 timer module are disabled. Ordinarily, when one of the timer/counters counts down to zero, an interrupt is issued so that the system will know that the time being counted has elapsed. In the preferred embodiment of this invention, an interrupt is not desired at the expiration of the timer/counter, and so this is inhibited by partially initializing Timer 3, also known as the watchdog timer (in other possible embodiments, the above timers may be real or they may merely be emulated by software techniques). The actual time interval being counted is approximately 0.8380953445 microseconds per tic. Referring now to FIG. 10, an internal register 180, allocated in system main memory 182 and initialized to 0.times.0000, is incremented each time the interval timer rolls over from 0.times.0000 to 0.times.FFFF. The device driver reads at 170 the value from the internal timer 172 of the timer module 174. This value is then one's-complemented, so that the value effectively ranges from 0.times.0000 to 0.times.FFFF. This complemented timer value 176 is combined with the internal register value 178 to provide a 32 bit timer 180 which can count to approximately one hour before it rolls over. The high order word 178, which is 16 bits, is the internal register rollover counter, and the low order word 176, also 16 bits, is the complemented timer value. This 32 bit value is known as the Time Tag 180, whose use will be described below.
In order to maintain timing integrity, the above described internal timer must be read at least once every 55 milliseconds, in order to not miss a rollover. Activating SYSTRACE Major Code 04 will suffice for this requirement. Major Code 04 turns on or enables interrupts, which includes the timer interrupt. Since each timer interrupt occurs every 32 milliseconds in the preferred embodiment, this will guarantee that an event occurs (and an associated read of the 8253 timer) at least once every 55 milliseconds. This is because the 8253 timer is read every time an event, including an interrupt, occurs. Now that the timer operation is understood, discussion will now turn to when the timer is read.
Hooks are events that are capable of being monitored, and trigger a particular response in the data processing system. An event in OS/2 is usually described by two hooks, a pre-hook and a post-hook. For example, when an I/O request is made, the device driver generates a pre-hook signalling the system that a request is about to be made to the I/O adapter. When the adapter completes the I/O request, the device driver signals the completion of the event with a post-hook. The time between the pre- and post-hooks represents the elapse time of the event. More specifically, as events occur, such as an I/O request, the kernel servicing the events calls the SYSTRACE routine with information describing the event. This allows SYSTRACE to process the event. Each time a hook arrives at the SYSTRACE patch code, meaning that a hook was invoked and that SYSTRACE is processing it, the timer is read and the high byte incremented if necessary(i.e. if the timer rolled over, as described above). The hook is examined to see if it is one of the desired hooks. If the received hook is one that is being monitored, it is processed further. Otherwise, it is flushed, or continues on with normal processing.
If the hook is an interrupt, 04/xx, the device driver measures the time spent processing interrupts. This is accomplished by matching the event called "start of an interrupt", called a pre-hook and which is generated when an interrupt handler begins to process the interrupt request, with the event "end of interrupt", called a post-hook and which is generated when an interrupt handler completes the processing of an interrupt request. As such, there is a one-to-one correspondence between pre- and post-hooks, and the timestamps of each are subtracted from one another to yield the time spent processing the interrupt.
It is also possible that after a pre-hook occurs, a subsequent pre-hook occurs before a corresponding post-hook occurs for the first pre-hook. This nesting of hooks is easily handled in that any post-hook received is paired with the most recently received pre-hook. In other words, after one hook starts, another can start, but the second will end before the first will end. In this nesting scenario, the end time minus the start time, and minus all nested activities, is how long the outer event took.
If the hook is a Mode Switch, 02/xx, the device driver measures the time spent in the REAL mode of the CPU by tracking the time from the first mode switch until the scheduler dispatches a different process. This time is then subtracted from the time when a mode switch to PROTECT mode occurs.
If the hook is a Thread Dispatch, 12/01, the device driver first saves the process identification (PID) and thread identification (TID) from its data area (PID and TID is common terminology in OS/2 architected systems; the PID is a 16-bit number that uniquely identifies a process within the OS/2 environment. The PID value starts at 0001 and increments each time a process is created. TID's are required as several threads can exist in one process). Then, the device driver examines its data to see if it has a PID identical to the PID in the previous Thread Dispatch hook 12/01, in which case the hook is flushed. Otherwise, the time spent in Interrupts and the time spent in REAL mode is appended to the existing Thread Dispatch 12/01 data, which is the PID and TID provided by the scheduler describing the event. The entire Thread Dispatch hook is reformatted to conform to standard PERFMON/DEKOVERT format, as shown in FIG. 11a and described later, and written to one of the device driver's 32K buffers. The two registers holding the accumulated Interrupt time and the REAL mode time are then reset to zero.
If the hook is a FileSystem hook, 30/xx, then the current TID 191 is inserted ahead of the Normal Data, as shown in FIG. 11b.
The above listed, and other, hooks of interest are also reformatted so that they resemble the PERFMON/DEKOVERT format, and written to one of the 32K buffers. The first eight bytes of each record are the Major Code 183, the Minor Code 184, the Data Length 185, a Flag 186, and the four byte Time Tag 188, as shown in FIG. 11. The subsequent bytes shown, DD1-DDn at 189 are the hook data. When one of the buffers is full, i.e. has used 24K of its 32K space, the buffers are switched using conventional programming techniques, and the full 32K buffer is made available to the control program. Data collection continues in the other 32K buffer.
The device driver also provides for swapping these buffers on a signal from the control program, in order to be able to provide the control program with data accumulated up to that point. A similar operation occurs whenever a TRACE Command is issued, 00/02, hook is received and the first data byte is 0.times.00 (meaning that TRACE has been turned off). In this case, it is mandatory that the control program receive the current buffer immediately, as there will be no further accumulation of data in either buffer.
Communication between the control program and the device driver is achieved by using the communication area in the respective 32K buffer as follows. In order for the control program to reset the device driver and the device driver's buffers, the control program loads a control word in the communication area to the value `2`, as shown in Table 2. When the device driver completes a reset, it changes this a value to `1`. If the control program desires to pause the device driver and buffer filling, the control program loads a control word in the communication area to a value of `1`. When the control program desires the device driver to resume, the control program loads this control word to a value of `0`. When the control program desires to shut down, or stop, the control program unhooks the device driver as previously described. Operation is then suspended until such time that the control program sends another READ command to the device driver.DATA REDUCTION
Low-level event trace performance data is transformed into high level system activities. This is accomplished by the following methodology. First, pre-hook and post-hook events are matched, as previously discussed, and then these two hooks are transformed into one event. This is because a single record can be used to replace the pre- and post-hooks since it is now known how long the event took, and this event timing is the desired granularity of information needed. Additionally, as described above, events are filtered to only use information in the event records that are of interest to the control program.APPLICATION PROGRAMMING INTERFACE (API)
The following describes the application programming interface (API) to the Data Collection Facility. This API allows client applications to retrieve performance data and access the Memory Analyzer.
The API is implemented through two named pipes called the System Pipe and the Trace Pipe. The System Pipe is used by a client application to send parameters to and receive responses from the Data Collection Facility. The Trace Pipe is used by a client application to receive continuous performance data. The Data Collection Facility creates both pipes; the client application issues the OS/2 function calls DosOpen and DosClose to access the pipes. Both pipes are created as message pipes in blocking mode (see the "IBM Operating System/2 Version 1.2 Programming Tools and Information" for additional information, hereby incorporated by reference as background material).System Pipe
A client application controls the actions of the Data Collection Facility through the System Pipe. The client application reads from and writes to the pipe in message mode. Each message written to the pipe represents one parameter from the syntax diagram. A message must be an ASCIIZ string (that is, a null-terminated string, or one byte of binary zeros) including numbers (for example, decimal 10 must be sent as the string "10").
The Data Collection Facility sends responses back to the client application through the System Pipe. The name, used by the client application on the OS/2 function call DosOpen, of the System Pipe in a local machine is PIPE SYSTEM.SPM; on a remote server the name of the pipe is server.sub.-- namePIPE SYSTEM.SPM.
Output from the Memory Analyzer (/THESEUS theseus.sub.-- command) is also sent from the Data Collection Facility to the client application through the System Pipe. First the return codes are sent. Then, output, if any, from the Memory Analyzer command is sent. Each message represents a single line from the Memory Analyzer; maximum line length is 100 characters. This output is followed by a done message represented by five pound signs (#####) followed by a null character (00). The System Pipe is disconnected by the Data Collection Facility when the client application closes the pipe with the OS/2 function call DosClose.
FIG. 12 details a syntax diagram for messages that may be sent to the Data Collection Facility through the System Pipe. Syntax parameters are explained in Table 5. A parameter is represented as a contiguous set of characters. Parameters with uppercase characters are keywords.
Each parameter must terminate with a null character (binary zero). For example, to send the comment "Performance data for SERVER1" to the SPM application, send the following messages:
TABLE 5 ______________________________________ /COMMENT Performance data for SERVER1 Data Collection Facility Parameters Parameter Action ______________________________________ /START Indicates the types of resources about which trace pipe records are to be sent by the Data Collection Facility. See also Table 8-3. *Indicates CPU, physical disk, RAM and swap resources when used with the /START parameter (does not indicate logical disk). Indicates all resources when used with the /STOP parameter. CPU Indicates CPU resources. PHYSICALDISK Indicates physical disk resources. LOGICALDISK Indicates logical disk resources. RAM Indicates random access memory resources. SWAP Indicates swapping resources Note: All trace pipe records without a specific type (designated as "No Type" in Table 8-3 are included whenever any of the preceding options are specified. /STOP Indicates the types of resources about which trace pipe records are not to be sent by the Data Collection Facility. See option descriptions under /START. See also Table 8-3. ##### Done message. Indicates the end of resource specification messages follow- ing the /START or /STOP parameter. /COMMENT Imbeds a comment with the collection data. string Comment to be imbedded in the current collection data. Comments cannot be longer than 40 characters; longer comments are truncated to 40 characters and are accepted without error by the Data Collection Facility. The string must be sent as a separate message if it contains embedded blanks. /EXIT Stops capturing data and releases the Data Collection Facility from memory. All processes started by the Data Collection Facility are also stopped (IDLECPU and THESEUS). /INITDATA Sends initialization records from the Data Collection Facility through the Trace Pipe. The following records are included: A Process Info record for the IDLECPU process. This is the process used by the Data Collec- tion Facility to determine the time the CPU was idle. This process executes at idle priority, level 0 (zero). A System Info record. A Process Info record for all processes currently executing in the system. These records are only sent if the Memory Analyzer has been started (see the /THESEUS START parameter). Note: The CPU resource must be started (see the /START CPU parameter Table 8-3) in order to receive Process Info records. /TOD Specifies the interval (in seconds) between Time of Day records sent by the Data Collection Facility through the Trace Pipe. interval The number of seconds between Time of Day records. The range of possible values is 1 to 100 seconds. The default is 5 seconds, but the inter- val parameter may have been set to another value by a previous application. /RAM Controls the periods used in sampling random access memory. See the RAM record description in Table 8-3 for information about the samples. Note: This parameter does not imply /START RAM. See /START RAM at beginning of table for more information about enabling the RAM resource. working.sub.-- set.sub.-- period The time frame, in seconds, used in determining the amount of physical RAM included in the working set. Each sample repre- sents the amount of RAM used during the last working set period. The range of possible values is 5 to 3600; the default is 60 seconds, but the work- ing.sub.-- set.sub.-- period parameter may have been set to another value by a previous application. Note: Until a full working set period has elapsed, the working set represents only the percentage of RAM in the working set since issuing the /RAM parame- ter or since the working set period was changed. sample.sub.-- interval The number of seconds between RAM samples. A RAM trace pipe record is sent each time a sample is taken. The range of possible values is 5 to 3600; the default is 10 seconds, but the sam- ple.sub.-- interval parameter may have been set to another value by a previous application. Note: For performance reasons, the SPM application requires that the working.sub.-- set.sub.-- period parameter value divided by the sample.sub.-- interval parameter value be less than or equal to 200. /THESEUS Starts the Memory Analyzer if it has not already been started by the Data Collection Facility. Provides a programming interface to the Memory Analyzer from an application. Note: The Memory Analyzer full-screen interface is not available from the copy of the Memory Analyzer started by the Data Collection Facility in this manner. START Causes the Memory Analyzer to be started if it has not already been started by the Data Collection Facility. theseus-command Any Valid Memory Analyzer command. The theseus.sub.-- command must be sent as a separate message if it contains embedded blanks. Note: All the Memory Analyzer commands (theseus.sub.-- command) are interpreted directly by the Memory Analyzer, including the THESEUS LOG command. All actions will occur from the reference point of the Memory Analyzer started by the Data Collection Facility as though they were typed at the Memory Analyzer full-screen interface. /NOTHESEUS Terminates the Memory Analyzer if it has been started by the Data Collection Facility. This saves the RAM overhead associated with the Memory Analyzer on the collection machine. However, Process Info records for processes currently executing in the system (excluding the IDLECPU process) are not sent through the Trace Pipe. This includes processes executing when the /INITINFO parameter is sent. /DEBUG Indicates that the Data Collection Facility is to log parameters it receives from client applications to the log file SPMLOG.LOG in the working directory. ______________________________________
One status message is sent to the client application by the Data Collection Facility for every parameter that has a slash (/) as its first character. This status message provides an indication of the success of the request from the parameter. The format of a status message is described in the following table.
______________________________________ SPM Return Code 2 Bytes (Word) Service Return Code 2 Bytes (Word) Reserved 2 Bytes (Word) ______________________________________
Next, the output from any Memory Analyzer commands specified with the /THESEUS parameter (theseus.sub.-- command) is sent to the client application. Each message represent a single line from the Memory Analyzer. A done message (#####) follows this output.
Values that may be returned in the SPM return code field are contained in Table 6. All values are given in hexadecimal.
TABLE 6 ______________________________________ SPM Return Codes Code Description ______________________________________ X'0000' No error, the parameters were accepted. X'0007' Invalid parameter. The service return code contains the sequence number of the parame- ter that failed. Each parameter beginning with a slash (/) will reset the sequence number to 1. X'0010' The working.sub.-- set.sub.-- period value is out of range (/RAM parameter). X'0011' The sample.sub.-- interval value is out of range (/RAM parameter). X'0012' The sample.sub.-- interval value is not a multiple working.sub.-- set.sub.-- period value (/RAM parameter). X'0013' The working set.sub.-- period value divided by the sample.sub.-- interval value is greater than 200 (/RAM parameter). X'0014' The /TOD interval value is out of range. X'0108' Unable to issue the TRACE.EXE ON command to the OS/2 system through the OS/2 function call DosExecPgm. X'0208' Unable to issue the TRACE.EXE OFF command to the OS/2 system through DosExecPgm. X'0408' Unable to start the IDLESPU.EXE program through the OS/2 function call DosKillProcess. X'0409' Unable to stop the IDLESPU.EXE program through the OS/2 function call DosKillProcess. X'0806' The Memory Analyzer does not recognize this OS/2 version. X'0807' Unable to communicate with the Memory Analyzer. X'0808' Unable to start the THESEUS.EXE program through the OS/2 function call DosExecPgm. X'0809' Unable to stop the THESEUS.EXE program through the OS/2 function call DosKillProcess. X'1003' The device drive THESEUS.SYS was not loaded from the CONFIG.SYS file. X'1005' An invalid version of the device driver THESEUS.SYS was not loaded from the CONFIG.SYS file. X'2003' The device driver SPMDCF.SYS is missing in the CONFIG.SYS file. X'2004' Errors occurred while initializing the SPMDCF.SYS device driver through DosOpen or DosRead. ______________________________________ Note: The service return code is the return code from the requested OS/2 servic unless otherwise mentioned in this table.TRACE PIPE
The Trace Pipe is used by a client application to retrieve performance data from the Data Collection Facility. The Trace Pipe is a one-way named pipe: Data Collection Facility to client application. On a stand-alone machine, the name of the pipe, as used by the client application on the DosOpen function call, is PIPE TRACE.SPM; on a remote server, the pipe name is server.sub.-- namePIPE TRACE.SPM. The Trace Pipe is a message stream named pipe (as opposed to a byte stream named pipe) with a maximum message length of 8 kilobytes. The client application should send a /STOP or /EXIT message on the System Pipe to stop the collection and transmission of performance data through the Trace Pipe.
Data is queued in a buffer by the Data Collection Facility before transmission through the Trace Pipe. Messages on the Trace Pipe contain one or more complete trace pipe records. A message is transmitted through the pipe at least every 4 seconds, provided data is available.
The sequence of actions a client application would take to collect performance data from the Data Collection Facility is as follows:
1. Open the System Pipe.
2. Send appropriate messages to the Data Collection Facility (SPMDCF) through the System Pipe (including the /START message), obtaining return codes as applicable.
3. Open the Trace Pipe. Read data from the Trace Pipe until ready to stop collecting.
5. Send a /STOP or /EXIT message to Data Collection Facility through the System Pipe, obtaining return codes as applicable.
6. Close the System and Trace Pipes.TRACE PIPE RECORD FORMAT
The general format of records sent through the SPM Trace Pipe is:
______________________________________ Variable Length Length of Record Trace Pipe Code Data ______________________________________ (1 byte) (1 byte) (max. 250 bytes) ______________________________________TRACE PIPE RECORDS
The records listed in FIGS. 13A-C may be sent from the SPM application to a client application through the Trace Pipe.TABLE DEFINITIONS
ASCIIZ string
A string of characters followed by a nullcharacter (ASCII 00). Maximum number of characters is 250.
data overflow
Indicates that data has been discarded by the Data Collection facility. Usually this occurs if the client application is not reading data from the Trace Pipe quickly enough.
4 bytes in Intel format (that is, byte/word-reversed). In IBM C/2, this is an unsigned long integer (ULONG).
elapsed time
Total timertics encountered during the operation. This is not to be interpreted as time the operation was busy using the CPU, but rather, the time between when a request was submitted and when the operation completed. For example, a swap request is made by the swapper; then the swapper may give up the CPU to another process until disk I/O can complete; then the swapper completes the operation. The elapsed time includes the entire time, including the time the swapper was blocked waiting for the disk.
ID of the first physical disk
The ID assigned to the first physical disk by the system. Each physical disk is assigned a sequential number, beginning with the ID assigned to the first physical disk.
number of physical disks
The total number of physical disks installed in the system.
number of sectors
Number of 512-byte sectors.
physical disk ID
The ID assigned to the physical disk.
process name
This is the name of the process defined in the .EXE header or the file name of the .EXE file (does not include a period or the file extension).
time executing previous process
Total timertics encountered while executing the previous process (includes time spent at interrupt level [time in interrupts previous process]).
time in interrupts previous process
Total timertics encountered while at interrupt level while executing the previous process.
time since last Time of Day record
The elapsed timertics since the last record was sent. This value is provided for accurate calculations.
A value derived from the 8253/8254 chip. This value can be converted to microseconds by multiplying the value by 0.8380953445; that is:
Indicates that the user issued a trace command.
2 byes in Intel format (that is, byte-reversed). In IBM C/2, this is an unsigned short integer (USHORT).GRAPHICAL PRESENTATION
In order to graphically depict the resource utilizations or performance monitors described above, the preferred embodiment of this invention uses OS/2 Presentation Manager window and graphics functions. This method allows a user to view multiple groups of related information in multiple windows (or viewports) simultaneously. One main window, called the parent window, contains all the other windows, called child windows, that display resource utilization information. As shown in FIG. 6, the resource information is presented in the form of graphs which display percentage utilization of a certain data processing system resource. The resource utilization data is displayed to represent a user-configurable period of time (e.g. the last 600 seconds), or the viewing period 122 of FIG. 7b. Thus, it provides both instantaneous and recent/past records of resource utilization. A user can choose to view some or all of the resource monitors, as well as modify the display characteristics of the windows. Other information, or the same information in other forms, could be presented in the child windows. Presentation parameters, which control how, and when, the data is displayed in the child windows are changeable by the user from the main window's menu (action) bar. As will be appreciated to those of ordinary skill in the art, standard windows programming techniques are used to present the desired graphical representation to the OS/2 Presentation Manager interface. The Presentation Manager is the entity that actually presents the data in a display window or viewport. Other operating systems, such as DOS in combination with Microsoft's Windows .sup.2 HP's New Wave.sup.3, XWindows.sup.4 or AIXWindows.sup.5 provide similar programming interfaces to a window-like presentations and could similarly be used in the presentation of resource monitors in their respective systems, without departing from the spirit and scope of the present invention.
.sup.2 Trademark of Microsoft Corp.
.sup.3 Trademark of Hewlett-Packard Corp.
.sup.4 Trademark of M.I.T.
.sup.5 Trademark of IBM Corp.
Finally, FIG. 14 depicts are generalized data processing system which is the preferred embodiment of this invention. A CPU 190, RAM 194, and peripheral device 196 (shown as a direct access storage device, or DASD), and interconnected via a bus structure. Similarly, ROS 192 and a keyboard 198 having an pointer/input device 200 are attached to this bus 204. These are the resources capable of being monitored in the preferred embodiment. Also attached to this bus is a display means 202, capable of rendering the resource monitor's results to a user. This display means is similarly attached to the common bus 204. Other variations having high speed paths between specific devices, and not a general bus as shown, would similarly fall within the realm of this invention, and would not be a departure from the scope of spirit of the herein claimed invention.
As has been shown in the above description, this data processing system utilization monitor with tracing provides for real-time performance monitoring without specialized hardware and without significant impact to the system performance being monitored.
While we have illustrated and described the preferred embodiments of our invention, it is to be understood that we do not limit ourselves to the precise construction herein disclosed and the right is reserved to all changes and modifications coming within the scope of the invention as defined in the appended claims. ##SPC1##
1. A method for indicating utilization of resources including a random access memory, a processor and at least one peripheral device in a data processing system, comprising the steps of:
- monitoring usage of said random access memory, a portion of said monitoring being performed by a first device driver which computes a non-allocatable working amount of memory for specific time period and then adds a portion of allocatable memory to said working memory when it is determined that the allocatable memory portion has been accessed by said processor more recently than said working memory;
- determining by a second device driver, usage of said at least one peripheral device by computing a ratio of a total number of hardware timer interrupt signals sent to said at least one peripheral device and a number of corresponding signals received from said device indicating that said device is busy;
- measuring, by a third device driver, activity of said processor by initiating a process with a lowest possible priority on said processor and determining an amount of idle time when said low priority process is executing on said processor;
- generating, by said data processing system, resource data, indicating usage of said random access memory, said processor and said at least one peripheral device; and
- displaying in real time, by said data processing system, said resource data of said data processing system.
2. The method of claim 1 wherein said at least one peripheral device is a direct access storage device or a communication adapter.
3. The method of claim 1 wherein said step of displaying in real time said resource data is displayed on a data processing system display.
4. The method of claim 3 wherein said resource data is displayed in at least one window of said data processing system display.
5. The method of claim 3 wherein said resource data is displayed on a local data processing system display.
6. The method of claim 3 wherein said resource data is displayed on a remote data processing system display.
7. The method of claim 1 wherein said step of monitoring is performed by a device driver in conjunction with a control program.
8. A system for indicating utilization of resources in a data processing system, including a random access memory, a processor and at least one peripheral device, said data processing system, comprising:
- monitor means for monitoring usage of said random access memory in said data processing system, a portion of said monitoring being performed by a first device driver, which computes a non-allocatable working amount of memory for a specific time period and then adds a portion of allocatable memory to said working memory when it is determined that the allocatable memory portion has been accessed by said processor more recently than said working memory;
- means, within a second device driver, for determining usage of said at least one peripheral device by computing a ratio of a total number of hardware timer interrupt signals sent to said at one peripheral device and a number of corresponding signals received from said device indicating that said device is busy;
- means, within a third device driver for measuring activity of said processor by initiating a process with a lowest possible priority on said processor and determining an amount of idle time when said priority process is executing on said processor;
- generator means for generating resource data, indicating usage of said random access memory, said processor and said at least one and
- display means for displaying in real time said resource data of said data processing system.
|April 19, 1977
|September 22, 1981
|October 27, 1981
|February 8, 1983
|July 10, 1984
|Wilder, Jr.
|November 27, 1984
|Duff et al.
|August 6, 1985
|Sukonick et al.
|August 6, 1985
|May 20, 1986
|Ellert et al.
|October 20, 1987
|April 11, 1989
|Levin et al.
|April 18, 1989
|Fasack et al.
|October 31, 1989
|February 27, 1990
|Kiel et al.
|June 26, 1990
|Rassman et al.
|January 14, 1992
|February 4, 1992
|October 6, 1992
|May 25, 1993
|November 23, 1993
|Rawson et al.
|October 25, 1994
|Moran et al.
- "Monitoring Distributed Embedded Systems", by Ray Ford 1990, pp. 237-244. "General Purpose Data Collection Method", IBM TDB, vol. 16, No. 6, pp. 1796-1798, Nov. 1973. "Structure of Performance Monitor for Distributed Computer Systems", IBM TDB, bol. 20, No. 11B, Apr. 1978, pp. 5060-5065. "Computer with Integraal Function Monitor", IBM TDB, vol. 10, No. 11, Apr. 1968, pp. 1700-1703. "Performance Evaluator for Operating System", IBM TDB, vol. 16, No. 1, Jun. 1973, pp. 110-118. "General Trace Facility", IBM TDB, vol. 15, No. 8, Jan. 1972, pp. 2446-2448. "Definition and Measurement Method of `Working Set` When Analyzing Memory Utilization in OS/s," IBM TDB, vol. 33, No. 2, Jul. 1990, p. 186. "Software Tool for Reducing Page Fault Frequency", IBM TDB, vol. 32, No. 5B, Oct. 1989, pp. 464-466. "Performance Monitor of Small Remote Computer Systems", IBM TDB vol. 19, No. 6, Nov. 1976, pp. 2386-2388. "Memory Usage Estimator", IBM TDB, vol. 16, No. 1, Jun. 1973, pp. 284-285. "Functional Working Sets", IBM TDB, vol. 19, No. 4, Sep. 1976, pp. 1363-1364. "Working Set Determination", vol. 26, No. 9, Feg. 1984, p. 4761. "Working-Set Coprocessor", IBM TDB, vol. 32, No. 4A, Sep. 1989, pp. 240-242. "Memory Utilization Monitor", IBM TDB, vol. 15, No. 5, Oct. 1972, pp. 1709-1712. "The OSRM2 System", OS/2 Resource Monitor System, Version 1.1, copyright 1989-1990, C.O.L. Consulting Ltd.
Type: Grant
Filed: Jun 20, 1994
Date of Patent: Oct 31, 1995
Assignee: International Business Machines Corporation (Armonk, NY)
Inventors: Jimmie E. DeWitt (Georgetown, TX), Timothy M. Holck (Austin, TX), James H. Summers (Round Rock, TX), Samuel L. Emrick (Austin, TX)
Primary Examiner: Thomas G. Black
Assistant Examiner: Jean R. Homere
Attorneys: Wayne P. Bailey, Mark E. McBurney, Richard A. Henkler
Application Number: 8/263,153
International Classification: G06F 1300; G06F 1200;


text:
source GAIA package: Sx_MilitaryTimes_M6201410301250005_5675.zip Origin key: Sx_MilitaryTimes_M6201410301250005 imported at Fri Jan 8 18:18:13 2016
"We have a mass cas! Mass cas! Mass cas!"
The radio call broke into the crisp Nevada night. A routine live-fire training operation splintered into a triage scene as corpsmen came running, sorting through shrapnel, carnage and equipment to aid the injured.
A command investigation into the tragic March 18, 2013, mortar explosion that killed seven Marines and wounded eight more troops, newly released to the Marine Corps Times through a Freedom of Information Act request, found the cause of the deadly blast was a double-loaded mortar tube, a human error exacerbated by insufficient training and lack of familiarity with the weapons system.
But these findings leave more questions unanswered, about the sequence of events that night and about the firings of two Marine officers and a seasoned warrant officer in the wake of the tragedy. For the families grieving the loss of a son or a brother, it's likely that some doubts will always remain.
The unit
Alpha Company, 1st Battalion, 9th Marines, had just completed a winter exercise at the Mountain Warfare Training Center in Bridgeport, Calif., before the Marines arrived at the Hawthorne Army Depot at Hawthorne, Nev., for live-fire training. The Camp Lejeune, N.C.-based unit was freshly back from a four-month deployment to Kuwait, which had ended in January.
The company's new commander, Capt. Kelby Breivogel, had transferred to the unit in February. About half of the company's mortar section was relatively new, too, having come from an 81mm mortar platoon about eight months previously to switch to the smaller 60mm system. They hadn't shot their mortars in Kuwait and they hadn't done any mortar training together since January. But the unit had a reputation, and it was a good one: Lt. Col. Andrew McNulty, commander of 1/9, told investigators that Alpha Company had one of the best mortar sections he'd ever dealt with.
"I know those guys were the freaking best, freaking always talking about knowledge," said an 0351 assaultman with Alpha Company, who was interviewed by investigators. "Always freaking drilling their guys on the proper way to do things. ... I understand it, like completely understand why, now."
The two-day training evolution at Hawthorne started off well enough. The section started with a daytime attack at the depot's Range 500, firing about 12 rounds from three 60mm M224A1 mortar systems. But toward the end of the day, one of the tubes had a malfunction: the trigger system stopped working properly.
Section leaders decided to move forward into the night training with just two mortars, shuffling some Marines to new positions to accommodate the change.
Though McNulty didn't know about the mortar adjustments late in the day, he observed a portion of the day training and said he was impressed.
"I went downrange and was surprised about how smooth it was running and how strong the command and control was," he said. "I was confident; I had no concern that anybody was going to get hurt — it was just a matter of how well they would execute it — and it was a great run. It was on par with the other two companies, who had more experience, but everybody needs to have their first go, and this was theirs."
Night training
Conditions were good for the planned night training; though overcast, the evening was no darker than it had been when the battalion's Bravo and Charlie companies had trained on the range days before. Because of the terrain, the Marines were grouped tightly around the two weapons, in a position known as a "lazy V." As they had done in day training, the Marines fired their weapons in handheld mode, using a trigger to send the rounds downrange.
McNulty and Breivogel observed the training that night from a machine gun hill a short distance away, listening for the booms and monitoring radio traffic. Others, too, were taking the opportunity to observe the spectacle of live-fire mortar training. A chemical, biological, radiological and nuclear officer, serving as the officer in charge for the range, observed the training from a side road about 10 feet away. He told investigators he called his Marines' attention to the mortars as they began to fire.
"I turned my head to look at my Marine and tell him, 'You know, this is some good s--- — you might want to keep your [night vision goggles] downrange and pay attention,' " the officer, who is unnamed in the report, said. "About that time is when the boom happened."
The mortars section had shot off several illumination rounds first, then high-explosive rounds, according to the report. About three minutes into their training, an explosion came from the mortar position itself. The investigation determined that a Marine was loading a second round into the mortar tube when another Marine on the trigger fired the round already in the tube, shooting the half-loaded round downrange and causing the deadly blast.
Breivogel and McNulty knew something was wrong as soon as when they heard the explosion, and came running down the hill. The company commander began gathering up spent mortar rounds to clear them out of the way while the battalion commander conferred with the Marines performing casualty assistance and tallied up the dead and wounded. One severely wounded Marine held his own airway open with his fingers as he waited for help.
The first medevac helicopter touched down at an improvised landing zone near the blast site just before 11 p.m., barely an hour after the blast. But for a number of the Marines, it was already too late.
Those killed in the blast included Pfc. Joshua M. Martino, 19, of Dubois, Pa; Lance Cpl. David P. Fenn II, 20, of Polk City, Fla.; Lance Cpl. Roger W. Muchnick Jr., 23, of Fairfield, Conn.; Lance Cpl. Joshua C. Taylor, 21, of Marietta, Ohio; Lance Cpl. Mason J. Vanderwork, 21, of Hickory, N.C.; Lance Cpl. William T. Wild IV, 21, of Anne Arundel, Md.; and Cpl. Aaron J. Ripperda, 26, of Madison, Ill.
Seven other Marines and a sailor were wounded.
The probe
The command investigation, which took nearly two months, involved nearly 30 interviews with Marine witnesses and range experts, cataloguing of evidence from the scene of the explosion, and analysis of the mortar tube by the Army's Benet Laboratories, the support facility for large-caliber weapons systems.
Based on analysis, the equipment the Marines were using was fine, with no hairline fractures or faulty ammunition to cause a malfunction, according to the investigation report. The mortar tubes were new, and the one from which the blast originated had only fired off 43 rounds in its career. Early reports about the blast said it was caused by a single mortar round exploding in the tube, but the physical evidence began to tell a different story.
The 40-inch mortar tube was found raggedly sheared off. The tail assembly from the round that had been fired was discovered at the scene of the blast, and the second, half-loaded round was found damaged, but unexploded, about 82 meters downrange. While it's not possible for a round's fuze to fully arm inside a mortar tube, investigators found that the force of the fuze striking another object, the second round, inside the tube would be enough to partially arm the munition and cause a premature detonation.
As laid out in the investigation report, the evidence showing how the blast took place appears conclusive.
Less simple is the question of why it took place.
The decisions
The Marines' 60mm mortar system can be fired in two modes: from the ground using a bipod, sight and baseplate, or in handheld mode, which employs a smaller base and requires line-of-site firing and a trigger mechanism to fire rounds at will, rather than the conventional drop-in method, which fires them automatically when loaded.
The larger 81mm system, which a number of Marines in the mortar section had used in Afghanistan, doesn't have the trigger option and can't be used in handheld mode. Because of this, double-loads on the 81mm system are "virtually impossible," the investigators state in their report.
The battalion gunner, Chief Warrant Officer 3 Douglas Derring, who served as the range safety officer for the exercise, told investigators that he told the mortar section to fire in the handheld mode because it had been some time since they trained with that method. But it wasn't a controversial choice: McNulty said he felt that the handheld mode was actually a little safer for the Marines because they had to keep their eyes on the mortar barrel and therefore had a better chance of seeing if something was wrong.
The investigation would find that the "tight" positioning of the Marines in the mortar section around the two weapons contributed to the large number of casualties. Breivogel said he counseled his Marines on not crowding other squads' positions, and McNulty said that, in retrospect, he would have increased the dispersion slightly. But both said they didn't have a problem with the decision to consolidate three mortar teams into two after the daytime equipment malfunction, which put more Marines around the two weapons.
Another concern was speed: As Marines proceeded to "fire for effect" on notional targets in the dark, were they moving too fast to be careful?
The CRBN officer overseeing the range said he was watching the loading process with that concern in mind.
"They are often a little bit rushed — like they are trying to run too fast," he told investigators. "But everything felt great. It was actually a really good run."
The investigation ultimately found that four factors contributed to the tragedy: inadequate training and preparation for the complexity of the exercise; improper mortar gunnery commands and firing procedures; a "perceived sense of urgency and resultant haste" within the mortar section during the exercise; and a systemic lack of supervision of the mortar section during the exercise and in the months prior to it.
It notes, however, that the troop deaths and injuries "occurred in the line of duty and [were] not the result of misconduct on the part of any of the victims."
The report calls for new Marine guidance regarding minimal distance between mortar systems and use of the handheld mode, and better training and procedures for safety officers and live-fire exercises.
McNulty, Breivogel, and Derring were all relieved from their posts at the unit, in accordance with the report's recommendations.
A source close to the investigation said McNulty submitted a lengthy rebuttal to the investigation's findings, but that was not provided to Marine Corps Times in response to the Freedom of Information Act request.
A Naval Criminal Investigative Service probe that took place at the same time as the command investigation is within days of completion, said NCIS spokesman Ed Buice. This investigation did not turn up any evidence of foul play, he said, and no one has been charged in connection with the incident.
Questions remain
For some of the families of the fallen, though, the officer reliefs aren't enough to bring justice for their sons.
Karen Perry, mother of Pfc. Joshua Martino, said she felt the investigation did not do enough to explain how a double-loaded round — an extremely rare event with mortars — took place.
Reading comments on news stories and listening to Marines, she said, "You've got maybe 90 percent of people that feel there's no way this could have happened."
Even if the double-load did take place, she said, she feels the unit leaders should have been closer to the mortar section during the range exercise, and maybe the unit should have taken more time in training before attempting live fire. Nearly a year later, there are still so many frustrating unknowns for Perry.
"The ones who know are dead, and we've got this big, stupid report to read," she said.
Roger Muchnick Sr., father of Lance Cpl. Roger Muchnick, said he, too, felt the Marines were underprepared after coming from Bridgeport, where some in the unit, including his son, had gotten sick.
"I don't think they had the right equipment. I don't think they had the right training schedule. I don't think they had anything," he said. "I know these kids who were with Roger. They were careful. They were sick, they shouldn't have ever been there."
None of the relieved officers opted to comment for this story, but a career infantry Marine with close knowledge of the accident and the investigation expressed outrage at how the investigation was handled and its outcome.
The Marine, who asked that his identity be withheld for fear of reprisal, said the mortar section was well-prepared and had performed without a problem up until the fatal accident. Even coming from the harsh winter training at Bridgeport, the unit was in better shape than most. They were experts, he said, they were well-led, and they knew what they were doing. At the end of the day, he said, someone made a tragic mistake — a mistake that should not have led to three firings.
"The kid loading the mortars loaded two rounds," he said.

subset: commoncrawl


text:
Ark: Survival Evolved Taming Calculator
Ark: Survival Evolved Taming Calculator
304 points Taming & KO
To tame one of those early game you just need to get yourself a slingshot (You can get the engram at Level 5), a low Level Trike (Level 1 - 30) and to be safe around 40 Stones. Then find some Trees and attack the Trike with your Slingshot then use a Hit and Run Technique. It should be much easier because the Trike gets stuck in the Trees and has to get around them. Which gives you enough time to shot him some times with your Slingshot. Once he is unconcious you just have to gather Berries. Use Mejoberries for a higher level after taming. Keep an eye on the Trike's Torpor(You find it in the bottom right hand corner in its Inventory). Once it drops on 0 your Trike will wake up and you have to knock it out again. To raise its Torpor you need to put Narcoberries in its Inventory, click on them and then click on the Remote use item Button (Each Narcoberry adds 8 Torpor). In the Dododex App you can Look how many Slingshot-Shots, Narcoberries and Mejoberries your Trike needs. Good Luck!
More Triceratops Taming & KO Tips
38 points Taming & KO
Trikes Usually found on beaches
61 points Taming & KO
You can make one unconscious by standing on a big rock and hitting it with a slingshot
60 points Taming & KO
I would say to get tranq darts and stand on top of a rock and shoot down on it. If you are a early beginner this a good tactic. 🦖
26 points Taming & KO
Dododex said it'll take 38 savoroot to tame a lvl 40. It only took me 15 savoroot.
824 points Taming & KO
If you get in a fight with a couple of trikes, you'll see their head is adorned with 3 spikes, but there's no need to fear, just attack from the rear whilst using a really long pike.


text:
So much for leaving beauty up to the eye of the beholder. Basing its results on a series of studies published in 2009 on the mathematical formula for faces deemed most attractive, British firm Lorraine Cosmetics announced the winner of its search for "Britain's Perfect Face." Meet 18-year-old Florence Colgate, a student from Kent, England, whose features were determined to almost completely fit the mathematical standard.
The perfect face, according to the study, has a distance between the pupils of 46% of the entire face; the distance between the eyes and the mouth should be just over a third of the distance from the hairline to the chin.
Colgate's ratios were 44% and 32.8%, respectively. In addition, her features are symmetrical, which, according to a 1998 study by Gillian Rhodes, is generally considered more attractive. She's also possessed of some of the more traditional traits of beauty: large eyes, full lips and high cheekbones.
But the cosmetics company might have been on to something when it called its contest a search for the "perfect face" rather than the "most beautiful face." The two are by no means synonymous. And the company might want keep in mind next time that nothing manages to objectify women quite like breaking down their features to a blueprint.


text:
Password needs to be a minimum of 6 characters.
Thank you for registering an account! With this account you will be able to save items to your favorites, place items in a cart, and share your digital images with others.
by creating an account, you agree to our Website Policies and Privacy Policy
Due to variances in monitors, the colors and patterns displayed may vary slightly from the actual product. Physical samples should be ordered prior to specifying.
A soft color palette, mixed with a few bold hues, is the perfect compliment for this thin threaded linen. Snyder adds a simple, yet understated, texture to linens, refreshing a classic look.


text:
Penn State undergrads invited to get a jump on law school
March 17, 2010
Thinking about going to law school? If you're a Penn State undergrad heading into your junior or senior year, don't delay. There are only two weeks left before the April 1 deadline to register for an incredible opportunity to discover what it's like to be a law student. From learning how to brief a case and analyze a statute to making an argument in court, "Explore Law" will give you the tools you need to succeed as a law student. In addition to improved LSAT scores and critical thinking skills, participants in the program also benefit from having an advisor to help them through every step of the process up to law school admission.
Current Penn State Law student, Cassandra Matos, who attended a similar program two years ago, credits the introduction to law program with being a large part of why she was so successful her first year of law school. "If I could tell undergraduate students anything about the program, it would be that the experience was of immeasurable value to me. Until the program, I had no real idea what to expect in law school or how to properly prepare for it," said Matos. "The program allowed me to understand the way law school classes work and to better prepare myself for the caliber of work that is required to be successful in law school."
Sponsored by the Penn State University Dickinson School of Law, this intensive one-week program is free of charge to Penn State undergraduate students accepted into the program, which includes housing and meals. This year's program will be held from May 17 to May 21 in the Lewis Katz Building in University Park.
More information on the program, including application details can found online. Questions may be addressed to Professor Michele Volmer at 814-867-2805.