Abstract:
Indicating usage in a system includes implementing a performance counter associated with one or more hardware threads; counting events associated with the one or more hardware threads to determine an event count; deriving an initial measure of usage of a processor core associated with the one or more hardware threads based at least in part on the event count; applying a corrective function to modify the initial measure of usage and determine a modified measure of usage, wherein the modified measure of usage has a value that is different from and not equivalent to the initial measure of usage; and outputting an indication of a processor usage, the indication being based at least in part on the modified measure of usage.

Description:
CROSS REFERENCE TO OTHER APPLICATIONS 
     This application is a continuation of co-pending U.S. patent application Ser. No. 11/449,154, entitled CPU UTILIZATION METERING ON SYSTEMS THAT INCLUDE MULTIPLE HARDWARE THREADS PER CORE filed Jun. 7, 2006 which is incorporated herein by reference for all purposes. 
    
    
     BACKGROUND OF THE INVENTION 
     Multithreaded cores have recently become available from multiple vendors, and ship in many servers (e.g., Xeon hyper-threaded cores from Intel, Power 5 from IBM, Niagara from Sun). Multithreaded cores execute multiple hardware threads concurrently (or in a tightly interleaved fashion) on a single processor core. When used by common operating systems (e.g., Linux, Windows, AIX, Solaris), each hardware thread is typically represented by the operating system (OS) as a CPU (or processor, or hardware thread): a hardware entity that can execute a software thread. The OS is responsible for scheduling software threads for execution by cores and their hardware threads. The OS also monitors and reports on the utilization of hardware thread resources. A commonly used indication of utilization is CPU % or idle %, which is often measured and displayed independently for each hardware thread, each core, or aggregated for the entire system. For example, commands such as vmstat, mpstat, top, etc. and performance monitoring tools such as top, windows performance monitor, etc. may be used to view an indication of utilization. Current operating systems (e.g., Linux, Windows, AIX, Solaris) report utilization of hardware threads as CPUs. For monitoring purposes, these OSs treat hardware threads that share a common core in the same way that they have treated single-threaded processor cores. 
     While the use of multiple hardware threads tends to allow cores that support them higher total throughput per core than they would when running a single hardware thread per core, virtually all multi-threaded cores can show significant performance interference between threads sharing the same core. This interference can result in significant inaccuracies in the correlation between CPU utilization or idle % and system throughput. For some applications, such as applications that perform many dependent memory accesses and take many cache misses, hardware threads may interleave almost perfectly on a core, while for other applications, such as tight loop register-only computations, or bandwidth-saturating streaming, a single hardware thread can consume a significant portion of a core&#39;s execution resources, leaving little additional throughput to be gained by additional hardware threads sharing the core. This inconsistency introduces a new problem for system capacity and utilization monitoring, where one of the main indicators used by system administrators and monitoring systems to track system utilization and available headroom can now generate strongly flawed indications. 
     Thus, it would be desirable to measure and report system and core utilization in a way that correlates more closely with achieved or achievable throughput. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       Various embodiments of the invention are disclosed in the following detailed description and the accompanying drawings. 
         FIG. 1  is a block diagram illustrating an embodiment of a system having multithreaded cores. 
         FIG. 2  is a flow chart illustrating an embodiment of a process for indicating usage in a system. 
         FIG. 3  is a flow chart illustrating an embodiment of a process for indicating usage in a system based on active thread information and the ability of the core to increase throughput by utilizing additional threads. 
         FIG. 4  is a flow chart illustrating an embodiment of a process for indicating usage in a system based on active thread information and the ability of the core to increase throughput by utilizing additional threads. 
         FIG. 5  is a flow chart illustrating an embodiment of a process for indicating processor usage in a system based on a performance counter. 
     
    
    
     DETAILED DESCRIPTION 
     The invention can be implemented in numerous ways, including as a process, an apparatus, a system, a composition of matter, a computer readable medium such as a computer readable storage medium or a computer network wherein program instructions are sent over optical or electronic communication links. In this specification, these implementations, or any other form that the invention may take, may be referred to as techniques. A component such as a processor or a memory described as being configured to perform a task includes both a general component that is temporarily configured to perform the task at a given time or a specific component that is manufactured to perform the task. In general, the order of the steps of disclosed processes may be altered within the scope of the invention. 
     A detailed description of one or more embodiments of the invention is provided below along with accompanying figures that illustrate the principles of the invention. The invention is described in connection with such embodiments, but the invention is not limited to any embodiment. The scope of the invention is limited only by the claims and the invention encompasses numerous alternatives, modifications and equivalents. Numerous specific details are set forth in the following description in order to provide a thorough understanding of the invention. These details are provided for the purpose of example and the invention may be practiced according to the claims without some or all of these specific details. For the purpose of clarity, technical material that is known in the technical fields related to the invention has not been described in detail so that the invention is not unnecessarily obscured. 
       FIG. 1  is a block diagram illustrating an embodiment of a system having multithreaded cores. In the example shown, system  100  is shown to include chips  102 - 104 , which each include multiple cores. For example, chip  102  includes cores  106 - 108  and chip  104  includes cores  110 - 112 . Each core may include multiple hardware threads. Usage meter  114  may indicate utilization of each hardware thread or of each core or of the whole system or of a portion of the system. For example, usage meter  114  may be displayed in a user interface to a system administrator. 
     As used herein, “hardware thread” and “thread slot” may be used interchangeably. The OS schedules software threads for execution on hardware threads. In some embodiments, the OS controls which hardware thread(s) execute which software thread(s) and for how long, and core(s) control which instruction(s) are run on which hardware thread(s) and when. 
     CPU utilization % indications are measured by operating systems in various ways. One way is to measure the amount of “idle” time a system, core, or hardware thread has, and report either the idle %, or the CPU utilization % (100%-idle %). Collecting the measurement of the amount or % of idle time can be done in various ways. These measurement methods can be used to establish the amount of time, or the % of time over some measurement interval, during which a hardware thread could have been used to execute a software thread, but was not used to do so by the operating system. This % measurement can then be reported directly, or dampened in some form (a linear or non-linear dampening function or filter), with the dampened indication being reported as idle %. 
     One method used to measure idle % is to track the elapsed time spent by each “CPU” (hardware thread or core) in an “idle loop”, which the operating system executes when no software thread is scheduled for execution on the hardware thread. The amount (or %) of time that this elapsed idle represents out of a measurement interval is then computed as the idle time (or %). Another method used to save power or avoid taking up core resources in the execution of an idle loop is to “idle” the hardware thread when no software thread is scheduled for execution on it, and to account for the amount of elapsed time that the hardware thread was so “idled” in computing idle time and idle %. “Idling” a hardware thread can be done in many different ways, and often depends on the hardware&#39;s architecture and capabilities. Some cores may recognize a specific idle loop pattern, and minimize the spending power or thread execution resources when executing that pattern. Some cores support specific instructions, configuration and/or control registers, or some other control means that place a hardware thread (or an entire core) in an “idle” mode that minimizes the consumption of power, and the consumption of execution resources that could otherwise be used by other hardware threads. Many other methods of measuring idle time and idle % of an individual hardware thread may be used, and may be used by operating systems to track and report idle time and idle % on hardware threads, cores, and the system as a whole. 
     When idle time or idle % is measured independently on multiple hardware threads that share execution resources, a false indication of idle resources and available headroom can result. While this situation is true of independent measurements in the presence for any shared resource (including system memory bandwidth, shared bus bandwidth, shared cache space, shared cache bandwidth, etc.), it can be especially disruptive when the shared resources are tightly interleaved between hardware threads, such as the case of shared execution units, pipelines, ALUs, floating point units, etc. 
     The resulting false idle indications, can lead the CPU % indication (which has historically been used by system administrators to determine available headroom and potential total system throughput) to be potentially inaccurate, potentially erratic, and potentially very application dependent. Specifically, systems based on 4-threaded cores can be demonstrated to peak in throughput (with simple tight loop series computations) while showing 30-40% CPU indications, where the system produces little or no additional throughput as CPU % indications grow from 30%-40% to 100%. This existing behavior (seen in operating systems such as Linux and Solaris) can lead to significant challenges in deploying and managing systems based on multi-threaded cores. A system administrator must either face significant uncertainty about what a system&#39;s “fullness” is, or they must overprovision the system to compensate for the potential inaccuracy and erratic readings (which could lead to 3×over-provisioning needs on top of current provisioning methods). 
     Thus, it would be desirable to create a more accurate means of tracking CPU utilization % on multi-threaded core based systems, such that CPU utilization % more closely tracks achieved system throughput on common workloads. This is especially true for workloads that have historically shown near-linear (or directly proportional) throughput-to-CPU % relationships on normal (non multithreaded core based) servers, and have established a significant expectation of CPU % representing available compute headroom. 
       FIG. 2  is a flow chart illustrating an embodiment of a process for indicating usage in a system. At  202 , active thread information related to the number of hardware threads in a processor core is obtained. For example, a % idle may be determined by determining the average number of active hardware threads over an interval of time. As used herein, “active” refers to non-idle. A thread is idle when it is idling or could be idling (e.g., running an idle loop). 
     At  204 , the active thread information is combined with information related to a decreasing ability of the processor core to increase throughput by utilizing (e.g., executing) additional threads. In some embodiments, the core has a decreasing ability to increase throughput by executing additional threads, as opposed to throughput being directly proportional to the number of threads executing on the core. In other words, adding a second thread does not necessarily double the throughput. 
     Cycles per instruction (CPI) is an example of information related to a decreasing ability of a core to increase throughput by executing additional threads. In some cases, the lower the CPI, the lower the ability of a core to increase throughput by executing additional threads. 
     At  206 , the usage in the system, based on both the active thread information and the ability of the processor core to increase throughput by utilizing additional hardware threads, is indicated. For example, a % idle and CPI measurement may be used to determine a usage in the system. The usage may be indicated in a user interface, e.g., using a usage meter. Further examples are described below. 
       FIG. 3  is a flow chart illustrating an embodiment of a process for indicating usage in a system based on active thread information and the ability of the core to increase throughput by utilizing additional threads. At  302 , for each hardware thread, an elapsed time in an idle state over a previous interval is determined. In other words, for each hardware thread, the % idle time over an interval is determined. At  304 , for each hardware thread, a CPI over the previous interval is determined. In some embodiments, a performance counter is used to determine CPI. At  306 , for each core, a core idle % based on hardware thread idle times and CPIs is determined. For example, for each core, core idle % may be determined as follows: 
     
       
         
           
             
               core_idle 
               ⁢ 
               
                   
               
               ⁢ 
               % 
             
             = 
             
               100 
               × 
               min 
               ⁢ 
               
                 { 
                 
                   
                     
                       
                         
                           
                             ∑ 
                             
                               i 
                               = 
                               1 
                             
                             n 
                           
                           ⁢ 
                           
                             
                               
                                 HWT 
                                 i 
                               
                               ⁢ 
                               _idle 
                               ⁢ 
                               _time 
                             
                             
                               n 
                               × 
                               interval 
                             
                           
                         
                         , 
                       
                     
                   
                   
                     
                       
                         1 
                         - 
                         
                           
                             ( 
                             
                               core_typ 
                               ⁢ 
                               _CPI 
                             
                             ) 
                           
                           ⁢ 
                           
                             ( 
                             
                               
                                 ∑ 
                                 
                                   i 
                                   = 
                                   1 
                                 
                                 n 
                               
                               ⁢ 
                               
                                 1 
                                 
                                   
                                     HWT 
                                     i 
                                   
                                   ⁢ 
                                   _CPI 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
                 } 
               
             
           
         
       
     
     where: 
     n is the number of hardware threads 
     HWT i— idle_time is the idle time for the ith hardware thread 
     HWT i— CPI is the CPI for the ith hardware thread 
     core_typ_CPI is the typical CPI on the core at full throughput 
     For example, if the core can execute one cycle per instruction, its core_typ_CPI is 1. If the core can execute up to two cycles per instruction, its core_typ_CPI is 2. 
     Thus, the core idle % depends on both the idle time and CPI of each hardware thread. 
     At  308 , a system CPU % is determined based on the core idle %. For example, the system CPU % may be determined as follows: 
     
       
         
           
             
               system_CPU 
               ⁢ 
               
                   
               
               ⁢ 
               % 
             
             = 
             
               100 
               - 
               
                 
                   ∑ 
                   
                     core_idle 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     % 
                   
                 
                 num_cores 
               
             
           
         
       
     
     The above equations are some examples of ways in which usage in a system can be determined or approximated based on the number of active threads and the ability of the core to increase throughput by utilizing additional threads. In other embodiments, other equations may be used. 
     In some embodiments, at the end of each interval, the above computations are performed. In other embodiments, each time a software thread starts executing on or stops executing on a hardware thread, the above computations are performed. 
     Alternatively, instead of a system CPU %, a core CPU % may be determined at  308  as follows:
 
core_CPU %=100−core_idle %
 
     A core CPU % may be determined for any number of cores. 
       FIG. 4  is a flow chart illustrating an embodiment of a process for indicating usage in a system based on active thread information and the ability of the core to increase throughput by utilizing additional threads. In this example, a corrective function is used to determine system usage. 
     At  402 , for each hardware thread, an elapsed time in an idle state over a previous interval is determined. At  404 , a system idle % is determined based on hardware thread idle times. For example: 
     
       
         
           
             
               system_idle 
               ⁢ 
               
                   
               
               ⁢ 
               % 
             
             = 
             
               100 
               × 
               
                 
                   
                     ∑ 
                     
                       i 
                       = 
                       1 
                     
                     N 
                   
                   ⁢ 
                   
                     
                       HWT 
                       i 
                     
                     ⁢ 
                     _idle 
                     ⁢ 
                     _time 
                   
                 
                 
                   N 
                   × 
                   interval 
                 
               
             
           
         
       
     
     where N is the number of hardware threads 
     At  406 , the system idle % is modified based on a corrective function. The corrective function may be any appropriate function used to improve the accuracy of system idle % determined at  404 . In some embodiments, the corrective function is heuristically determined. For example, based on measurements of number of executing threads versus throughput, a corrective function may be determined. Alternatively, the system could be probed. For example, an integer loop and/or other workload(s) could be run periodically and sampled. Based on the result, a corrective function may be determined. The corrective function may be different depending on the workload. Examples of workloads include memory accesses, floating point operations, etc. The corrective function may be implemented using a lookup table. The corrective function could be static or dynamic. Corrective functions are discussed more fully below. 
     At  408 , a system CPU % is determined based on the system idle %. For example:
 
system_CPU %=100−system_idle %
 
     Alternatively, instead of a system CPU %, a core CPU % may be determined, in which case a core idle % is determined using the idle times of the hardware threads running on the core at  402  (N=number of hardware threads on the core). A core CPU % may be determined at  408  as follows:
 
core_CPU %=100−core_idle %
 
       FIG. 5  is a flow chart illustrating an embodiment of a process for indicating processor usage in a system based on a performance counter. At  502 , a performance counter associated with a hardware thread is implemented. A performance counter may be implemented for one or more hardware threads, cores, or systems. Any number of performance counters may be implemented. 
     At  504 , events associated with the hardware thread are counted. A performance counter may be configured to count any appropriate event associated with one or more hardware threads, cores, or systems. Events include instructions executed, cache misses, loads, stores, etc. For example, a performance counter may accumulate average CPI, count memory accesses, count cycles and/or count instructions. CPI may be computed using the counted cycles and the counted instructions. There may be a performance counter that indicates utilization or data associated with utilization. For example, the number of idle cycles in a core may be counted. At  506 , a measure of usage of a processor core associated with the hardware thread is derived based on the counted events. For example, based on a performance counter result alone or in combination with other data, a system CPU % or core CPU % may be determined. The usage may then be indicated in a user interface, e.g., using a usage meter. 
     As described herein, a corrective function may be used in the reporting of idle CPU % for each core in a system. A corrective function can take many forms. Any corrective function applied to classic methods of measuring idle CPU % to more closely represent available system throughput may be used. 
     In addition, alternative means of measuring “idle potential” of a core that use performance counter indications (in addition to or other than elapsed time) in establishing the idle duty cycle of a core or a hardware thread may be used. 
     The corrective function may, in some embodiments, use profiling information gathered about software threads and processes in the system (such as CPI, miss rates, branch rates, etc.) to establish some corrective model of the potential utilization and available headroom of a core when running software threads that meet the measured profiles. 
     Examples of corrective functions include: 
     1. A non-linear static translation of idle time, applied independently to the idle time of each hardware thread in the core. 
     2. Accounting for total core utilization by accounting for utilized cycles on the core (using some form of performance counter). 
     3. Accounting for total core utilization by accounting for utilized memory and prefetch bandwidth of the core (using some form of performance counter). 
     4. Accounting for total core utilization by accounting for total number of cache misses performed by the core (using some form of performance counter). 
     5. Establishing software thread behavior metrics by periodically (or statically) profiling software threads individually (or across multiple threads in a process, or across all threads in a system, or by sampling some of the threads and extrapolating the sample to other thread), and using such behavior metrics to establish an estimated CPU utilization corrective function. 
     a. The corrective function could be applied identically to all cores in a system, to each core separately, or to each hardware thread on each core in the system, using common profiling metrics across all threads in a system. 
     b. The corrective function could be separately applied to each core in the system, using information about the software threads currently scheduled for execution on the core, and attempting to estimate the amount of “available extra throughput” the core has in not-currently-scheduled hardware thread slots. 
     c. The corrective function could be applied to each hardware thread in a core separately, using information about the software threads currently scheduled on other hardware thread slots in the same core. 
     6. Limiting thread scheduling such that only threads of a common process can concurrently share a core, and using process-specific profiling information to establish the core utilization more accurately. 
     In the following example, idle core time is calculated by profiling CPI under fully loaded core conditions, establishing the potential instructions per second a core can sustain: 
     Define “loaded core CPI” as the core cycles per executed instruction that a core experiences when simultaneously running a software thread on each hardware thread on the core. 
     Collect average “core CPI” across all cores in the system during a period of time (or sample some cores, when they are “full” of threads, or artificially schedule multiple threads to a single core for a short period of time to establish the “recent” loaded core CPI even when the system utilization is low). 
     Calculate “Core Instructions Per Second Potential” (CIPSP) as Core_Frequency/Loaded_Core_CPI 
     Track executed instructions per second on each core. 
     Calculate idle time for a core as idle %=executed instructions/CIPSP. 
     In the following example, each software thread&#39;s “single threaded” CPI is continuously or periodically instrumented (i.e., data is collected), and this information is used to estimate the amount of “empty resources” that exist on a core when that thread uses it, resulting in a more accurate modeling of CPU idle % on each core: 
     Instrument “single threaded” CPI of each individual software thread. This can be done in various ways, for example, each thread can periodically be scheduled for a short amount of time on a dedicated core (with no other software threads scheduled at the same time on the same core), and the core&#39;s CPI can be measured to establish the thread&#39;s single-threaded CPI. Alternatively, a per-hardware-thread performance counter can be constructed that would establish or approximate a thread&#39;s single-threaded CPI by discounting core cycles that were not made available to the specific hardware thread when the hardware thread could have actually made use of them (in effect, cycles where the thread was “hardware executable and not blocked”, but did not receive core cycles). 
     Using the CPI information established for each software thread, model the amount or % of “empty cycles” in a core by accounting for the expected cycle consumption of each hardware thread currently executing on the core. Use modeled empty cycles as “idle %” for the core. 
     For example, assume core modeling shows that the core can execute 1 instruction per cycle with an ideally fed pipeline, and that the core can execute 4 or more hardware threads. The core has 3 threads currently executing, with single threaded CPIs of 3, 3, and 6. An approximation model would show that out of every 6 core cycles, 5 are actually utilized by threads, and the core is ⅙th “idle”. The resulting Core CPU % on mpstat should be 83%. 
     In another example, assume core modeling shows that the core can execute 1 instruction per cycle with an ideally fed pipeline. The core has 2 threads currently executing, with single threaded CPIs of 2 and 1.5. An approximation model would show that all core cycles would be tightly consumed by the two threads, and the core is 0% “idle”. The resulting Core CPU % on mpstat should be 100%. 
     Although the foregoing embodiments have been described in some detail for purposes of clarity of understanding, the invention is not limited to the details provided. There are many alternative ways of implementing the invention. The disclosed embodiments are illustrative and not restrictive.