Method and apparatus for instruction execution hot spot detection and monitoring in a data processing unit

[0002] This patent application claims the benefit of U.S. Provisional Patent Application No. 60/168,481, filed Dec. 1, 1999.

[0004] The present invention relates generally to program profiling, and relates more particularly to a technique for hot spot detection and monitoring that may be implemented in hardware to support adaptive runtime optimization.

[0005] Traditionally, program runtime performance has been enhanced through optimization performed in connection with compilation. In some cases, compiler optimization is based upon profile information (such as statistics about frequency of execution of conditionally executed statements) gathered from execution of a program with a set of sample inputs. This is an inherently static technique, however, since the program performance is optimized only for a the set of sample inputs, possibly at the expense of other inputs. In other words, if the inputs to the program differ from the inputs considered by a compiler during optimization, the optimized program may actually perform worse on the different inputs than an unoptimized program.

[0006] A number of different techniques have been used to gather profile information about programs. Traditionally, the program is augmented with additional instructions that incrementally collect a profile of the program as it executes. Since these additional instructions are executed frequently, significant slow down of the program being profiled is often observed. Recently, low-overhead profiling techniques have been proposed where the microprocessor contains extra hardware designed to collect profile information. The profile information may then be analyzed to determine if the program performance may be improved or optimized. The basic approach of this technique, however, requires gathering profile information for the program's entire execution which is then averaged into a large database that is then fed back into a static compiler. The disadvantage of this technique is that it does not automatically filter out data that is most useful for optimization. Instead, another process must analyze the complete data set, searching for optimization opportunities. Because the profile data for a program's entire execution is often quite large, storing the data may require more space than is available, and analyzing the data may take an undesirably long time. Furthermore, because an entire profile of the program must be continuously maintained at runtime, the profile represents only average behavior across an extended period of time, and it is difficult to detect variations in program behavior because only long term average behavior is tracked.

[0007] Although such static optimization techniques are useful to increase program performance in some respects, additional opportunities for optimization may be realized through dynamic or adaptive techniques capable of monitoring and reporting program performance based upon specific runtime information. In particular, certain runtime optimizers have been proposed that gather program performance information during execution of a program and such information is made available to a dynamic optimizer that may modify program code while the program is running in an attempt to improve program execution accordingly.

[0008] U.S. Pat. No. 5,151,981 for Instruction Sampling Instrumentation discloses a hardware implemented technique that allows for periodic sampling of instructions that are executing. According to the technique, each time a predetermined instruction is executed, information associated with the execution of the instruction is stored. Although this approach results in gathering of information that may be useful for runtime optimization, the approach requires interruption of the processor to copy out data gathered when the memory buffer is full and also requires interruption of the processor when the predetermined instruction to be monitored is changed. This technique does not provide a means for automatically detecting optimization opportunities among the data that are collected.

[0009] U.S. Pat. No. 5,452,457 for Program Construct and Methods/Systems for Optimizing Assembled Code for Execution discloses a software implemented technique that includes gathering, by means of executing additional instructions, information that may be used to perform optimizations that are environment-specific. However, as a software implemented technique, it requires substantial overhead that detracts from its overall objective of improving program performance.

[0010] The foregoing limitations and disadvantages of the prior art are overcome by the present invention which provides a technique that may be implemented in hardware for supporting runtime optimization. An important observation fundamental to the present invention is that when a collection of intensively executed program blocks also has a small static footprint, it represents a highly favorable opportunity for runtime optimization. Such a set of blocks and their corresponding periods of execution are referred to as “hot spots”—a set of intensively executed instructions. The present invention involves dynamic runtime hot spot detection, as well as hot spot monitoring to determine whether program execution has strayed from a set of hot spots that have previously been detected. Thus, a hot spot detector may be selectively enabled or disabled, depending upon whether detected hot spot portions of a program are currently being executed. Once a hot spot is detected, information regarding the hot spot may be supplied to an operating system or other supervisory process for an opportunity to optimize the hot spot to enhance overall program performance.

[0011] Several advantages of the present invention over the techniques proposed by the prior art are realized. First, the technique of the present invention provides for rapidly detecting hot spots by continuously monitoring program execution rather than relying upon statistical sampling as taught in the prior art. Thus hot spot information is almost immediately available for optimization opportunities during execution. Second, hot spots are detected during timeslices of execution, rather than over the entire execution of a program, so that optimizations can adjust the program to changes in its behavior throughout execution. Third, a processor is interrupted or an operating system or other supervisory process is notified only when a hot spot has been detected, resulting in minimal interference with normal execution. Fourth, since the technique may be implemented in hardware independent of other hardware mechanisms in a data processing unit, it will not significantly degrade processor performance, complicate the rest of the processor design or increase cycle time.

[0012] The above and other advantages of the invention will be more clearly appreciated from the following detailed description when taken in conjunction with the accompanying drawings, in which:

[0013] FIG. 1 is a schematic diagram illustrating the components of the hot spot detector in accordance with one embodiment of the present invention;

[0014] FIGS. 2A and 2B are flow diagrams that illustrate the steps performed by the hot spot detector of FIG. 1;

[0015] FIG. 3 is a schematic diagram illustrating the components of the hot spot monitor in accordance with one embodiment of the present invention; and

[0016] FIG. 4 is a flow diagram that illustrates the steps performed by the hot spot monitor of FIG. 3.

[0017] The invention is described herein in connection with certain exemplary embodiments and implementations. In particular, although the simplicity and design of the invention lends itself to being advantageously implemented in hardware, it may alternatively be advantageously implemented in software as well. Although the invention is described and illustrated in connection with an embodiment where hot spots are detected and monitored, it may readily be implemented to detect and monitor other program execution behavior of interest as well. For example, the invention may be used to detect and monitor program behavior associated with particular memory usage characteristics by tracking “hot” memory locations (a collection of intensely accessed memory locations) instead of hot instructions. From this, profiling information could be gathered about the access frequency of “hot” memory locations or the values and sizes being stored in those locations. Similarly, the invention could be adapted to track hot cache lines, collecting profile information about the usage patterns of the data elements in the cache line (such as whether or not other data elements in the cache line are also accessed shortly after one element, or if an accessed element is a lone access to the cache line). In another alternative arrangement, the invention could be used to track other types of instructions, instead of just branches as described herein. Some architectures have conditionally executed instructions based on the value contained in a register, a technique called predication. The invention could be used to collect profile information on the frequency of execution of conditionally executed instructions.

[0018] Thus, it should be understood that the following description and illustrations of various exemplary embodiments is not intended to limit the invention to those particular embodiments. It is intended that the invention described herein in connection with various exemplary embodiments covers all alternatives, modifications and equivalents falling within the scope and spirit of the invention defined by the appended claims.

[0019] According to one embodiment of the invention, the detection of runtime optimization opportunities consists of two stages. In the first stage, a profiler detects hot spots as they develop during execution. This may be accomplished by tracking the execution frequency of code blocks across a relatively short period of time. When a set of blocks fit the characteristics of a hot spot, the profiler notifies the runtime optimizer. Once detected, the hot spots may be added to a monitor table and the profiling hardware may be disabled. In the second stage, program execution is monitored to determine if execution strays from the hot spots previously detected. In such a case, the profiler may be enabled once again to allow for detection of new hot spots.

[0020] According to one embodiment of the invention, three characteristics are considered in determining whether a region of code classifies as a hot spot: (1) the region must have a relatively small static code size to facilitate rapid optimization, (2) the region must be active over a certain minimum time interval so that it is likely to have an opportunity to benefit from runtime optimization, and (3) the instructions in the selected region of code must account for a large majority of the dynamic execution during its active time interval.

[0021] The invention may be implemented based upon three major components. First, a hot spot detector is provided that identifies program hot spots and associated information during execution. Second, a hot spot monitor is provided that maintains information regarding a collection of hot spots that have previously been discovered by the hot spot detector. Third, operating system support is provided that controls the flow of information from the hot spot detector to the hot spot monitor, and may additionally call and supply information to a runtime optimizer. According to this arrangement, the invention advantageously performs hot spot detection and monitoring such that processor interruption only occurs when a new optimization opportunity is detected.

[0022] Turning now to FIG. 1, there is illustrated by way of example the components of a hot spot detector in accordance with an embodiment of the invention. The components of the hot spot detector include a branch behavior buffer, a refresh timer, a reset timer, and a hot spot detection counter that may be implemented as a saturating up-down counter.

[0023] According to one embodiment of the invention, the branch behavior buffer may be comprised of a memory buffer having fields for information pertaining to a branch address, branch execution counter, branch taken counter, branch candidate flag and a valid entry bit. As illustrated, the branch behavior buffer provides for a plurality of different entries. The valid entry bit serves as an indicator of whether a particular entry is available. If a valid entry bit is set, this indicates that the entry is full and the branch address and other information is filled in. If the valid entry bit is cleared, the entry is available for new branch information. As will be explained in greater detail, according to one embodiment of the invention, when the hot spot detector is enabled, an entry may be made in the branch behavior buffer when the processor retires a branch instruction. For efficiency, the branch behavior buffer may be indexed based upon the branch address of a branch instruction. Other information relating to the branch instruction, such as branch direction and target address, may also be used (alone or in combination) as an index into the branch behavior buffer. When a branch instruction is retired, the index is determined and the associated execution counter is incremented, and, if the branch is taken (which may be determined, for example, by checking the program counter), the branch taken counter may be incremented as well. As will be apparent, the combination of the values of the branch execution counter and the branch taken counter constitutes an arc weight profile of the recently executed code. If the execution counter reaches its maximum value for the data size allocated for that field within the buffer, preferably there will be no further incrementation of the execution or taken counter in order to accurately preserve the ratio between the execution and taken counters.

[0024] In the event that the execution of a particular branch is frequent enough during a particular interval such that the associated execution counter exceeds a predetermined candidate threshold, a candidate flag will be set for the associated branch address. The candidate flag will remain set while the execution counter and taken counter, as appropriate, continue to be incremented accordingly. As will be evident, the candidate flag may be represented by a single bit associated with a particular branch address within the branch behavior buffer. Likewise, the valid entry bit may be represented by a single bit.

[0025] To ensure that only frequently executing branches are marked as candidates and to prevent less frequently executing branches from monopolizing entries in the branch behavior buffer, a refresh timer is provided that periodically clear entries from the branch behavior buffer that are not yet marked as candidates (i.e., having a candidate flag set). The refresh timer may be simply implemented as a counter that counts up (or down) to a certain trigger value which, when reached, initiates a process that clears branch behavior buffer entries for which the candidate flag is not set. This periodic refreshing of the branch behavior buffer allows for more efficient use of the buffer space for branches that are more frequently executed. According to an important aspect of the present invention, in addition to the refresh timer, there is provided a reset timer that, when triggered, clears the entire branch behavior buffer. According to the illustrated embodiment of the invention, the reset timer is decremented once for each branch instruction encountered. When it reaches zero, all of the entries in the branch behavior buffer are cleared by clearing all the valid bits, thus making room for new branches. The difference between the reset timer and the refresh timer, however, is that the reset timer interval is much longer and upon triggering, it clears the entire branch behavior buffer. In other words, when initialized or reset, the reset timer will hold a value that is much greater than the refresh timer. In addition, the refresh timer upon triggering clears only those entries where the candidate flag is not set, while the reset timer clears all entries of the branch behavior buffer. The reset timer interval, i.e., the initial value of the timer before any decrementing, should be large enough to allow the hot spot detector to saturate on valid hot spots but also small enough to allow quick identification of a new phase of execution. In order to clear branch behavior buffer entries, it is not necessary to clear each field for the entries. Instead, the valid entry bits for the entries may be cleared.

[0026] Although according to the illustrated embodiment, the refresh and reset timers are decremented upon encountering a branch instruction and are triggered when the counter is exhausted, other implementations are possible as well. For example, the timers could be decremented by clock pulses instead of encountering branch instructions, such that the timers are independent of the number of branch instructions encountered. In another embodiment, a wall clock timer could periodically clear the branch behavior buffer. Processors commonly use wall clock timers to interrupt processing at regular intervals. The same signal could also be used to clear the branch behavior buffer. In accordance with an important aspect of the present invention, there is provided a saturating counter that is used in hot spot detection. As illustrated, each time a branch instruction is encountered, the branch behavior buffer is checked for a corresponding entry. If an entry exists (the branch address matches the entry address and its valid bit is set) and the entry candidate flag is set (indicating the branch instruction is a hot spot candidate), then the counter is decremented by a predetermined value D. If any entry does not exist or, if the candidate flag is not set (indicating the branch address has not been recognized as a hot spot candidate) then the detection counter is incremented by a predetermined value I. According to a preferred embodiment, the incrementing and decrementing of the detection counter is weighted in order to provide stability and more meaningful hot spot detection results. For example, the value of I and D may be set at 2 and 1 respectively such that the detection counter is incremented by 2 each time a branch instruction is encountered that does not have its candidate flag marked, and is decremented by 1 each time a branch instruction is executed that has its candidate flag marked. The weighting of I and D determine how sensitive the hot spot detection counter is to the execution of candidate branches. Increasing the value of D increases the sensitivity of the detection counter. That is, a smaller percentage of the branches must be candidates for the detection counter to decrease toward zero. Likewise, decreasing the value of D decreases the sensitivity of the detection counter to candidate branches. Naturally, changing the value of I has the opposite effect.

[0027] Another important preferred characteristic of the saturating detection counter is that when at its maximum value it remains at its maximum value when there is an attempt to increment it. In other words, it does not reset (or “rollover”) to zero, as would commonly be the case for other values that are incremented beyond their maximum value. As will be apparent, the size of the detection counter as well as the values of I and D will be factors in the performance of the hot spot detector. A larger detection counter will generally result in a longer latency until hot spots are detected, while a smaller detection counter will generally result in a shorter latency.

[0028] Furthermore, the values of I and D, and likewise the relationship between I and D, may be adjusted during execution. For example, if the processor is running and an excessive number of hot spots are detected, the ratio of I and D may be adjusted to reduce the number of hot spot detections. Similarly, if very few or infrequent hot spots are detected, the values of, and the relationship between, I and D may be adjusted to increase the sensitivity of the detector so that hot spots are detected more frequently. Thus, the values of I and D may be changing dynamically as the execution characteristics of the code change. In this regard, the hot spot detector may be “tuned” during execution of the code.

[0029] Generally, the detection counter will initially be set to its maximum value. As branch instructions are encountered, it will be incremented and decremented by I and D in accordance with whether a non-hot spot candidate branch or a hot spot candidate branch has been encountered. As more and more hot spot candidate branches are encountered, the detection counter approaches zero. When the detection counter reaches zero, the operating system is notified of that condition and, as will be described in more detail to follow, the contents of the branch behavior buffer may be copied.

[0030] As will be apparent, the invention may be implemented according to many different alternative arrangements. For example, the branch behavior buffer may be provided with room for 2048 different entries, although it appears that a buffer with even as few as 512 entries will also work well. According to one embodiment of the invention, the branch behavior buffer may be implemented as a two-way set associative buffer, where the buffer is comprised of two 1024-entry tables, and for any particular branch address there are two possible locations in which it can be stored at the same index in each table. Alternatively, the branch behavior buffer may be implemented as a four-way set associative buffer, or in some arrangements perhaps even a fully associative buffer may be provided. The branch address field may be up to 32 bits wide, although a tag of only the top 22 bits may be all that is necessary for a 2048 entry two-way set associate table, depending on the size and associativity of the table. Executed and taken fields may each be 9 bits in size, while the candidate threshold of 16 may work well when combined with a refresh interval of 4096 branches (resulting in a candidate execution ratio of 0.03125) and a reset interval of 65536 branches. The hot spot detection counter may be implemented as a 13 bit counter that may be incremented, for example, by a value of 2 and which may be decremented, for example, by a value of 1.

[0031] As can be seen, an important aspect of the present invention is that minimal operating system interruption is involved in the hot spot detection process. When activated, the branch behavior buffer is updated based upon retired branch instructions, and the hot spot detector is updated based upon hot spot candidate branch instruction information. The refresh timer clears non-hot spot candidates from the branch behavior buffer, while the reset timer periodically clears all entries from the branch behavior buffer. Finally, when the detection counter is decremented to zero, the operating system is notified and the information from the branch behavior buffer is made available for the operating system.

[0032] Turning now to FIG. 2A, there is shown a flow chart that illustrates the flow of steps performed in conjunction with the branch behavior buffer and hot spot detector of FIG. 1. As indicated earlier, the present invention may be advantageously implemented in the retirement stage of a pipelined processor. The first step, step 100, is performed when an instruction is retired. Next, in step 110, the retired instruction is examined to determine if it is a branch instruction. If it is not a branch instruction, then the process returns in step 120 and will be entered again upon another instruction being retired.

[0033] If, in step 110, the retired instruction is a branch instruction, then the branch behavior buffer is examined in step 130 to determine if there is already an entry in the branch behavior buffer for the branch address specified by the branch instruction and that the associated valid entry bit is set. If there is not already a valid entry for the branch address in the branch behavior buffer, then in step 140, the branch behavior buffer is checked to see if there is an entry available for the branch address. If there is no entry available for the branch address, then the process continues to step 150 where the hot spot detection counter is incremented and the process returns in step 160. In accordance with the example illustrated in FIG. 1, the value of the detection counter is incremented in step 150 by I.

[0034] It should be noted that for practicality, the size of the branch behavior buffer may result in being unable to add a new entry for several branch addresses, such as the situation that occurs when the routine reaches step 150. However, if the branch addresses are actually being frequently executed (i.e., part of a genuine hot spot), it is likely that the branch address will be entered into the branch behavior buffer after a refresh or reset cycle.

[0035] If in step 140, there is space in the branch behavior buffer to accommodate the new branch address, then in step 170 a new entry is created associated with the branch address. In this step, information relating to the branch address is filled into the branch behavior buffer, the executed counter is set to one, the taken counter is set to 0 and, initially, the candidate flag is cleared. At this point, the entry in the branch behavior buffer for the new branch address has been completed and the process continues to step 180 where the detection counter of the hot spot detection counter is incremented by I and the process continues to step 230.

[0036] If, in step 130, it is determined that the branch address already has an entry in the branch behavior buffer, the process continues to step 190 where the branch execution counter for the associated branch address is incremented. Next, in step 200, the execution counter is compared to a predetermined candidate threshold value to determine whether the branch address has been encountered frequently enough in the present interval to qualify the branch address as a hot spot candidate.

[0037] The candidate threshold value is a predetermined value that affects how many times a particular branch address must be encountered in an interval for it to qualify as a hot spot candidate. The candidate threshold value may be a variable that may be adjusted depending upon characteristics of the code being considered. If the candidate threshold value is set too low, the hot spot detection results may not be meaningful because the branch behavior buffer may be filled too quickly with information from less important branch instructions thereby preventing more important branches from being discovered and possibly reporting excessively large hot spots. On the other hand, if the candidate threshold value is set too high, the hot spot detection results may also not be meaningful, because very few if any hot spots may be detected because no branch instruction addresses are encountered frequently enough prior to refreshing or resetting of the branch behavior buffer. As should be evident to one of skill in the art, the candidate threshold value may be adjusted while the hot spot detection routine is being performed in order to result in the detection of only those few genuine hot spots that might justify optimization.

[0038] If, in step 200, the execution counter for the associated branch address in the branch behavior buffer does not exceed the candidate threshold value, the routine continues to step 180 where the detection counter of the hot spot detector is incremented by I and the routine continues to step 230. Otherwise, in step 200, if the execution counter for the associated branch address does exceed the candidate threshold value, the routine continues to step 210 where the candidate flag is set for the associated branch address, indicating that this branch address is in a potential hot spot. Next, in step 220, the hot spot detection counter is decremented by D and the routine continues to step 230.

[0039] In step 230 it is determined whether the branch specified by the current branch instruction was taken. This step could be performed by, for example, comparing the branch address computed by the branch instruction to the program counter of the next executed instruction, which is available after the current instruction retires; if the values are the same, this indicates the branch was taken, but if the values differ, this indicates that the branch was not taken. If it is determined in step 230 that the branch was taken, the routine continues to step 240 where the taken counter in the branch behavior buffer entry associated with the branch address for the current branch instruction is incremented, and the routine continues to step 250. Otherwise, in step 230, if it is determined that the branch was not taken, the routine continues directly to step 250.

[0040] In step 250, the detection counter of the hot spot detection counter is examined to determine if it has reached 0. If it has reached zero, this indicates that a hot spot has been detected during the current interval and the process continues to step 260 where the operating system is notified of the hot spot detection. As shown in step 265, after the operating system is notified, the contents of the branch behavior buffer will be copied or used by the operating system to update the known program hot spots, such as in the monitor table, which will be described in more detail later. In addition, the operating system may use the hot spot information from the branch behavior buffer to perform runtime optimization of the hot spots. The process then continues to step 300 in which the branch behavior buffer entries are invalidated and the refresh and reset timers are set to their maximum values. Otherwise, in step 250, if the hot spot detection counter is not 0, then the process continues to step 270.

[0041] In step 270, the refresh timer is decremented, and in step 280, the reset timer is also decremented. In step 290, the reset timer is checked to determine if it has been decremented to 0 and, if it has, the routine continues to step 300 where all of the valid entry bits in the branch behavior buffer are cleared, the reset and refresh timers are reset and the routine returns in step 310. Otherwise, in step 290, if the reset timer is not yet 0, the routine continues to step 320 where the refresh timer is checked to determine if it has been decremented to 0. If the refresh timer is not yet 0, the routine returns in step 310. However, if the refresh timer is 0, the routine continues to step 330 where all the valid bits corresponding to the branch behavior buffer entries for addresses which do not have a candidate flag set are cleared. This purges the branch behavior buffer of branches that are not encountered frequently enough to qualify as hot spot candidates, so that buffer space may be available for branches that might qualify as hot spot candidates. Next, the routine returns in step 340.

[0042] After hot spots have been detected using the hot spot detector described in connection with FIGS. 1 and 2, the operating system is notified and optimization of the hot spot code may be performed. In addition, information relating to the hot spot branch addresses may be entered into a monitor table that tracks where execution of the program has strayed from the hot spots. After the hot spot detector has reported an initial set of hot spots to the operating system, it may be deactivated as long as the program continues to operate in the hot spots. However, when the monitor table senses that the program is no longer operating in a hot spot region, the hot spot detector may be activated again to determine if a new hot spot has been encountered.

[0043] Turning now to FIG. 3, there is illustrated a schematic diagram that shows the various components of the hot spot monitor in connection with one embodiment of the present invention. The monitor is comprised of a monitor table and a saturating up-down counter that may be weighted as illustrated such that counting up is done in an increment of I and counting down is done in a decrement of D. Similar to the hot spot detector, when a branch instruction is retired, the hot spot monitor table is examined to determine if there is an entry in the monitor table, i.e., whether the valid bit for the particular branch address has been set. In general, an entry will appear with the valid bit set if the branch address has previously been determined to be a hot spot by the hot spot detector. In other words, the branch address makes its way to the monitor table from previous detection by the hot spot detector.

[0044] If the branch address is found in the table with the valid bit set, the monitor counter is decremented by D. Otherwise, if the branch address is not found in the table, or if it is present but the valid bit is not set, the monitor counter is incremented by I. It should be noted that the valid bit is provided in the monitor table as a convenient way to determine if the address appears in the table as a result of being intentionally set. In other words, when the table is cleared, all of the valid bits may be set to 0, without having to clear all the address fields. Additionally, in some architectures, a branch address of 0 is possible, so it is preferable to use a separate valid bit to indicate whether there is branch address entry in the table.

[0045] In a situation where the monitor counter is aggressively decremented, such as, for example, by frequent decrementing resulting from encountering hot spot branch addresses in the monitor table, the monitor counter may reach 0, a condition that indicates program execution is concentrated in hot spots. In this case, it is preferable to disable the hot spot detector, since it is unnecessary and costly to optimize a hot spot that has already been detected. On the other hand, in a situation where the monitor counter is aggressively incremented, such as, for example, by frequent incrementing resulting from encountering branch instructions that are not designated as hot spots with a valid bit set in the monitor table, the monitor counter may reach its maximum value, a condition that indicates program execution has strayed from the known set of hot spots. In this case, it is preferable to enable the hot spot detector to detect new hot spots.

[0046] It is preferable to continue to operate the hot spot monitor of FIG. 3 while the hot spot detector of FIG. 1 attempts to detect new hot spots, because it is possible that the program execution has strayed from known hot spots only briefly and may return once again before any additional hot spots are detected. In this situation, the monitor counter of the hot spot monitor will again reach 0 due to frequent hot spot branches and the hot spot detector will be disabled again until the monitor counter reaches its maximum.

[0047] Turning now to FIG. 4, there is shown a flow chart that illustrates the flow of steps performed in conjunction with the hot spot monitor of FIG. 3. The first step, step 400, is performed when an instruction is retired. Next, in step 410, the retired instruction is examined to determine if it is a branch instruction. If it is not a branch instruction, then the process returns in step 420 and will be entered again upon another instruction being retired. If, in step 410, the retired instruction is a branch instruction, then the monitor table is examined in step 430 to determine if there is an entry corresponding to the branch address. If there is not an entry in the monitor table, the routine continues to step 440 where the monitor counter is incremented, indicating that a non-hot spot branch instruction has been encountered. Otherwise, in step 430, if there is an entry in the monitor table that corresponds to the branch address, the routine continues to step 490.

[0048] If, in step 490, there is an entry in the monitor table corresponding to the retired branch address but the valid bit for that entry is not set, the process continues to step 440 where the monitor counter is incremented, indicating that a non-hot spot branch instruction has been encountered. After the monitor counter is incremented by I in step 440, the routine continues to step 450 where the monitor counter is checked to determine if it has been incremented to its maximum value. If the monitor counter has not reached its maximum value, the routine returns in step 460. Otherwise, in step 450, if the monitor counter has reached its maximum value, the routine continues to step 470 indicating that the program execution has strayed from the known hot spots in the monitor table. In step 470, the hot spot detector is enabled to detect additional hot spots, and the routine returns in step 480.

[0049] Otherwise, in step 490, if the valid bit corresponding the retired branch instruction is set, the routine continues to step 500 indicating that a known hot spot instruction has been retired. In step 500, the monitor counter is decremented by D and the routine continues to step 510 where the monitor counter is checked to determine if it has been decremented to 0. If the monitor counter has not been decremented to 0, the routine returns in step 480. Otherwise, in step 510, if the monitor counter has been decremented to 0, the routine continues to step 520 indicating that the program execution is concentrated in known hot spots within the monitor table, the hot spot detector is disabled and the routine returns in step 530.

[0050] As can be seen from the foregoing, the present invention provides a method and apparatus for efficiently detecting and monitoring program hot spots. The invention may be advantageously implemented in hardware where two main memory buffers are allocated for the branch behavior buffer and the hot spot monitor table. In addition, several registers may be provided for the refresh timer, the reset timer, the hot spot detection counter and the monitor counter. The logic of the flow charts illustrated in FIGS. 2 and 4 may also be readily implemented in hardware. Thus, the present invention may be implemented in hardware independent of other hardware mechanisms in the data processing unit and it will not degrade processor performance, complicate the processor design or increase cycle time.