Thread starvation profiler
A profiler of a multithreaded process that determines whether a process is runnable but not running by determining whether a process is both waiting for the processor and also not waiting for other events such as I/O. Counters are maintained for each such process that is runnable but not running. Reports are generated summarizing data relating to any process that may be starved due to lack of processor time. Information obtained by the method and apparatus assists developers in optimizing resources in multithreaded environments.
Latest IBM Patents:
The present invention relates to an improved data processing system and, in particular, to a method and apparatus for optimizing performance in a data processing system. Still more particularly, the present invention provides a method and apparatus for profiling multithreaded or multitasking processes to improve performance.
BACKGROUND INFORMATIONIn analyzing and enhancing performance of a data processing system and the applications executing within, it is helpful to know which software modules are using system resources. Effective management and enhancement of data processing systems require knowing how and when various system resources are being used. Performance tools are used to monitor and examine resource consumption as various software applications are executing. For example, a performance tool may identify modules that execute most frequently, allocate the largest amount of memory, or perform the most I/O requests.
In analyzing and enhancing performance of a data processing system, a developer may focus on where time is being spent by the processor in executing software code. Such efforts are commonly known in the computer processing arts as locating “hot spots.” Ideally, one would like to isolate such hot spots at the instruction level in order to focus attention on areas that might benefit most from improvements to the code.
For example, isolating such hot spots to the instruction level permits compiler writers to find significant areas of less than optimal code generation, at which they may focus their efforts to improve code generation efficiency. Another potential use of instruction level detail is to provide guidance to the designer of future systems. Such designers employ profiling tools to find threads, modules, functions, codepaths, characteristic code sequences, or single instructions that require optimization for a given hardware environment.
Multitasking can describe a processor or set of processors that operate on one process or subprocess before another is completed. The term “process” is sometimes used interchangeably with “task,” “thread,” and other such terms. A multitasking system splits time between processes depending on factors such as input/output (I/O) activity, interrupts, or the expiration of a fixed time interval. Threading can be a form of multitasking.
Threading can improve single-application performance by constantly feeding instructions to a single processor. For example, a single-threaded web server would be trapped in a wait state every time it fetched data from a disk. However, a multithreaded web server can handle new requests with one thread while another thread waits on the data from the disk. Multiple threads running on a processor can be analyzed to determine how much time a processor spends on each thread. Such a multithreaded arrangement improves performance by allowing the processor to operate continuously rather than wait for a slow process, such as I/O, to complete.
Process scheduling is the method by which the operating system determines which thread to run on the processor. Threads are sometimes assigned a class depending on the thread's priority. Threads running in a lower-priority class often only receive the processor time left over by higher-priority classes. Schedulers may allocate processor time to threads based on class and may interrupt a thread before the thread is complete. Schedulers may determine the order in which a thread should run and how much processor time each thread is allocated while running.
Sample-based profiling can describe a technique of periodically interrupting the operation of process execution at regular intervals. At each interruption, samples are taken to inform a developer which function was executing just before the interruption. After the interruption, normal processing is restarted. The interrupting and restarting of the process is looped for a predetermined length of time, for a predetermined number of events of interest, or upon an event such as user input.
At each time interval, the processor collects a sample that is then used to determine the function the processor is running. By sampling for many time intervals, a profiler can determine statistically on which functions a processor is spending its time. A profiler can then generate a report summarizing the sampled data.
An example profiler stops an application and samples the program counter of the currently executing thread. The profiler repeatedly stops the processor over many clock cycles to obtain a statistically meaningful quantity of data. The program counter values may be resolved against a load map and symbol table information for determining the function on which the processor is executing. The profiler increments a counter for the area of the particular area of code that is executing. Some profilers process information on the fly and create data structures representing an ongoing history of the runtime environment. Other profilers add data to a buffer or file for processing after sampling.
If profiling was carried out for 100 interrupts, a profile might indicate that the processor was running code from function A during 50 interrupts, the processor was running code from function B during 25 interrupts, and the processor was running code from function C during 25 interrupts. Such data would indicate to the developer that processor time was split among functions A, B, and C on a percentage basis of 50%, 25%, and 25%, respectively. If functions A, B, and C all were written to have equal distribution, the example profile would tend to indicate that functions B and C are not receiving enough processor time and function A is processor-bound, requiring too much processor time.
A sample-based profiler may obtain information from the stack of an interrupted thread. A “stack” is a region of reserved memory in which a program or programs store status data, such as procedure and function call addresses, passed parameters, and local variables. A “stack frame” is a portion of a thread's stack that represents local storage (arguments, return addresses, return values, and local variables) for a single function invocation. Every active thread of execution has a portion of system memory allocated for its stack space. A thread's stack could consist of sequences of stack frames. The set of frames on a thread's stack could represent the state of execution of that thread at any time. Many operating systems provide software timer interrupts useful to profilers. These timer interrupts can be employed to sample information from a call stack.
In a multitasking system, threads can be queued before the threads are executed. One technique for queuing threads is to maintain a single. centralized queue that may be referred to generically as a “run queue.” If a processor becomes available, the next available thread is assigned from the run queue to the processor.
In some multi-processor systems, queuing threads may be accomplished by maintaining separate queues for each processor. Thus, when a thread is created, it could be assigned to a processor in a round robin fashion. With such a technique, some processors may become overloaded while other processors are relatively idle. Furthermore, some low priority threads may become starved, i.e. not provided with enough processing time, because higher priority threads are added to the run queue of the processor for which the low priority threads are waiting.
Previous sample-based profiling systems collected data relating to a specific process the processor was executing during each scheduled interruption of a process. Such profilers provided no data or limited data on a process that was runnable but not running when the interruption occurred. Runnable but not running means that the only resource the process is waiting on is the CPU itself. Such previous profiling systems are limited in the ability to determine whether a process is starved of processor time. Thus, there is a need for an apparatus and method for profiling processes are runnable but not running in a multithreaded environment.
SUMMARY OF THE INVENTIONAn embodiment of the present invention is a computer program in a computer readable medium for profiling a multithreaded system. The computer program has first instructions for interrupting the operation of an application running in a multithreaded system. Second instructions identify, for a desired process, if this process is runnable but not running. Third instructions increment a counter for the process, signifying that it was runnable but not running, or signifying a function of the process was running. In an embodiment, the computer program loops for a predetermined amount of time or until otherwise interrupted. An embodiment includes instructions for generating a report summarizing function counts to allow developers the ability to see function characteristics including which functions may be starved of processor time.
Another embodiment is a method for profiling a multithreaded process after identifying a process to be profiled. Instructions are executed on a processor in a multithreaded manner and the executing of instructions is interrupted. A determination is made of whether the process is runnable but not running and a counter is incremented for the process if the process is runnable but not running.
Another embodiment is a data processing system for processing a multithreaded application. A profiler system waits a predetermined period of time, interrupts the processing of the multithreaded application, identifies a thread that is runnable but not running, and increments a counter for the thread that is runnable but not running. The multithreaded application is restarted and a report is generated summarizing the value of the counter.
The foregoing has outlined rather broadly the features and technical advantages of the present invention in order that the detailed description of the invention that follows may be better understood. Additional features and advantages of the invention will be described hereinafter which form the subject of the claims of the invention.
BRIEF DESCRIPTION OF THE DRAWINGSThe present invention can be used to profile process starvation for processes operating in a multithreaded environment. For a more complete understanding of the present invention and the advantages thereof, reference is now made to the following descriptions taken in conjunction with the accompanying drawings, in which:
In the following description, numerous specific details are shown in flow diagrams to provide a thorough understanding of the present invention. However, it will be obvious to those skilled in the art that the present invention may be practiced without such specific details. In other instances, well-known circuits, software, and hardware functions have been summarized as flow chart elements in order not to obscure the present invention in unnecessary detail. For the most part, details concerning software encoding and the like have been omitted inasmuch as such details are not necessary to obtain a complete understanding of the present invention and are within the skills of persons of ordinary skill in the relevant art.
Refer now to the drawings wherein depicted elements are not necessarily shown to scale and wherein like or similar elements are designated by the same reference numeral through the several views.
Although the present invention and its advantages have been described in detail, it should be understood that various changes, substitutions and alterations can be made herein without departing from the spirit and scope of the invention as defined by the appended claims.
Claims
1. A method for profiling a multithreaded process comprising the steps of:
- identifying a process to be profiled;
- executing instructions on a processor in a multithreaded manner;
- interrupting the executing of instructions on the processor;
- determining whether the process was runnable but not running upon interrupting the executing of instructions; and
- incrementing a counter for the process if the process was runnable but not running.
2. The method of claim 1 further comprising the steps of:
- restarting the executing of instructions on the processor;
- interrupting the executing of instructions after a predetermined period of time; and
- incrementing the counter for the process if the process was runnable but not running upon interrupting the executing of instructions after the predetermined period of time.
3. The method of claim 1 further comprising the step of assigning a counter to the process.
4. The method of claim 1 wherein the process comprises a plurality of functions and the method further comprises the step of assigning a separate counter for each of the plurality of functions.
5. The method of claim 1 further comprising the step of generating a report summarizing the value of the counter for the process.
6. The method of claim 1 wherein the step of executing instructions on a processor in a multithreaded manner comprises executing instructions on a plurality of processors in a multithreaded manner.
7. The method of claim 1 wherein the multithreaded process runs a multitasking operating system and wherein the multithreaded system operates instructions on a single processor.
8. A computer program product in a computer readable medium for profiling a multithreaded system, comprising:
- first instructions for interrupting the operation of an application running in a multithreaded system;
- second instructions for identifying a process that was runnable but not running upon interrupting the operation of the application; and
- third instructions for incrementing a counter for the process that was runnable but not running wherein the counter has a counter value representing a number of times the counter is incremented.
9. The computer program product in claim 8 further comprising:
- fourth instructions for repeating the first, second and third instructions for a pre-determined time period.
10. The computer program product in claim 9 further comprising fifth instructions for generating a report summarizing the counter value.
11. The computer program product in claim 9 wherein the second instructions identify a plurality of processes that were runnable but not running and the third instructions increment a separate counter for each of the plurality of processes that; were runnable but not running wherein each separate counter has a separate counter value representing the number of times the third instructions increment each separate counter.
12. The computer program product in claim 11 further comprising seventh instructions for reporting each counter value as a percentage of a total counter value wherein the total counter value is a summation of each of the separate counter values.
13. The computer program product of claim 8 further comprising fourth instructions for incrementing a second counter signifying a function of the process was running upon interrupting the operation of the application.
14. A method of profiling a data processing system comprising the steps of:
- starting processing of a multithreaded application by a processor, wherein the processor selects threads to process from a run queue;
- starting a profiler;
- waiting a predetermined period of time;
- interrupting the processing of the multithreaded application;
- identifying a thread on the run queue that was runnable but not running upon interrupting the processing;
- incrementing a counter for the thread on the run queue that was runnable but not running wherein the counter has a value representing the number of time the counter is incremented;
- restarting the processing by the processor of the multithreaded application; and
- generating a report wherein the report comprises the value of the counter.
15. A data processing system comprising:
- a system for processing a multithreaded application by a processor, wherein the processor processes a plurality of threads of the multithreaded application;
- a profiler system for waiting a predetermined period of time, interrupting the processing by the processor of the multithreaded application, identifying a thread that is runnable but not running, incrementing a counter for the thread that is runnable but not running wherein the counter has a value representing the number of times the counter is incremented, restarting the processing of the multithreaded application, and generating a report wherein the report comprises the value of the counter.
Type: Application
Filed: Aug 5, 2004
Publication Date: Feb 9, 2006
Applicant: International Business Machines Corporation (Armonk, NY)
Inventor: Andrew Theurer (Austin, TX)
Application Number: 10/912,492
International Classification: G06F 9/46 (20060101);