U. Glaeser

to predictor size, and so are xlisp and perl to some extent. The hybrid predictor is the most sensitive to
size, because it must allocate the available hardware budget across four tables: the selector’s PHT, the
global-history component’s PHT, and the local-history component’s BHT and PHT. Each of these tables
is therefore substantially smaller than in a single two-level predictor and therefore suffers more destructive
interference. This especially affects the programs with large static branch footprints, like go and gcc. Yet
a hybrid predictor also has an important advantage: in order to better control destructive conflicts, it
can dynamically shift which component it uses to make a prediction for each branch.
Note that these results do not include the effects of predication, context switching, operating system
behavior, or any profile-guided feedback. All of these effects might change the results.
Summary
Branch prediction is important because otherwise every branch stalls the fetch engine. Some alternatives
exist, like delay slots and predication, but delay slots are not compatible with modern, wide-issue superscalar
processors, and predication cannot remove all branches. Static prediction techniques that require
no hardware support are also possible, but they are either very simple, or in the case of compiler directives,
require instruction-set support. Static techniques also have the drawback that they cannot adapt to changing
run-time conditions.
Dynamic branch-prediction techniques have evolved from the simple bimodal predictor to more
sophisticated two-level and hybrid predictors that exploit patterns in branch behavior and correlation
among branches. Refinements to these techniques, as well as new fetch organizations that permit fetching
past multiple branches, continue to be active areas of research.
The massive effort to find better branch-handling techniques is motivated by the severe penalty
imposed by mispredictions. Especially with the long and wide pipelines of modern processors, a very
small misprediction rate can severely harm performance. Indeed, the fetch bottleneck remains one of
the most severe limitations on faster processing, and Jouppi and Ranganathan [53] argue that it may
become the most severe bottleneck in future processors, even more severe than memory latency or
memory bandwidth.
References
1. Skadron, K., Characterizing and removing branch mispredictions, PhD thesis, Princeton University
Department of Computer Science, Princeton, NJ, 1999.
2. Calder, B. and Grunwald, D., Reducing indirect function call overhead in C++ programs, in Proc.
21st ACM SIGPLAN-SIGACT Symp. on Principles of Programming Languages, pp. 397–408, Jan.
1994.
3. Chang, P.-Y., Hao, E., and Patt, Y. N., Target prediction for indirect jumps, in Proc. 24th Ann. Int.
Symp. on Computer Architecture, pp. 274–283, June 1997.
4. Driesen, K. and Hölzle, U., Accurate indirect branch prediction, in Proc. 25th Ann. Int. Symp. on
Computer Architecture, pp. 167–178, July 1998.
5. Kalamatianos, J. and Kaeli, D. R., Predicting indirect branches via data compression, in Proc. 31st
Ann. ACM/IEEE Int. Symp. on Microarchitecture, pp. 272–281, Dec. 1998.
6. Kaeli, D. R. and Emma, P. G., Branch history table prediction of moving target branches due to
subroutine returns, in Proc. 18th Ann. Int. Symp. on Computer Architecture, pp. 34–41, May 1991.
7. Webb, C. F., Subroutine call/return stack, IBM Technical Discl. Bull., 30(11), April 1988.
8. Gwennap, L., Digital 21264 sets new standard, Microprocessor Report, pp. 11–16, Oct. 28, 1996.
9. Gwennap, L., Intel’s P6 uses decoupled superscalar design, Microprocessor Report, pp. 9–15, Feb. 16,
1995.
10. Patterson, D. A. and Hennessy, J. L., Computer Architecture: A Quantitative Approach, 2nd ed., Morgan
Kaufmann, San Francisco, 1996.
© 2002 by CRC Press LLC