Instruction level parallelism using ppm branch prediction

INTERNATIONAL Computer Engineering and Technology ENGINEERING &
International Journal of JOURNAL OF COMPUTER (IJCET), ISSN 0976 –
6367(Print), ISSN 0976 – 6375(Online) Volume 3, Issue 3, October-December (2012), © IAEME
TECHNOLOGY (IJCET)
ISSN 0976 – 6367(Print)
ISSN 0976 – 6375(Online)
Volume 3, Issue 3, October - December (2012), pp. 137-146
IJCET
© IAEME: www.iaeme.com/ijcet.asp
Journal Impact Factor (2012): 3.9580 (Calculated by GISI) ©IAEME
www.jifactor.com

INSTRUCTION LEVEL PARALLELISM USING PPM BRANCH
PREDICTION

K.Babu Rao Dr. N. Satyanarayana Prof. K.Vikram
Vice-Principal & HOD CSE, Principal, Medak Ollege of Engg& Tech.
Sahasra College of Engineering for Women, NITS, Hyderabad Siddipet, Medak (D)
Warangal-506007 mail: vikramkarimella@yahoo.com
Sahasra.principal@gmail.com

ABSTRACT

The two independent predictions are combined using a neural network. The CBP-2 is introduced
traces the proposed scheme twice the prediction accuracy . predictors have been very successful
in predicting branch outcomes. We introduced a hybrid scheme by Partial Matching Markovian
predictors

1. INTRODUCTION

One common way of achieving this goal in data compression is Prediction by Partial attaching
(PPM) [1, 5]. PPM is a Markov predictor in which the prediction is a function of the current
state. The state information in an mth-order PPM predictor is an ensemble of the m most recent
symbols. If the pattern formed by the m recent symbols has occurred earlier, the symbol
following the pattern is used as the prediction. As an example of how PPM works, consider
the sample stream of binary symbols presented in Figure 1. Data compression and branch
prediction share many similarities. Given a stream of symbols e.g., ASCII characters for text
compression or past branch outcomes for branch prediction), the goal in both cases is to predict
future symbols as accurately as possible.. To predict what symbol will appear at position 0 we
look for clues earlier in the stream. For example, we observe that the previous symbol is a 1. The
last time a 1 was observed—at position 2—the following symbol was a 1. Hence, we can predict
that position 0 will be a 1. However, we do not have to limit ourselves to examining a single-
symbol pattern. The last time 1 1 (positions 2 and 1) appeared was at positions 10 and 9 and the
subsequent symbol (position 8) was a 0 so we can predict 0. We ﬁnd the next longer pattern, 0 1
1 (at positions {3, 2, 1}), at positions {13, 12, 11} with position 10 predicting 1. The longest
pattern with a prior match is 0 1 0 1 0 0 1 1 (positions {8, 7, 6, 5, 4, 3, 2, 1}) at positions {24,

137

International Journal of Computer Engineering and Technology (IJCET), ISSN 0976 –

23, 22, 21, 20, 19, 18, 17}. The subsequent symbol is 0 so we can choose 0 as our best guess for
position 0’s value. Generally, predictors that use longer patterns to make a prediction are more
accurate than those that use shorter patterns. However, with longer patterns, the likelihood of the
same pattern having occurred earlier diminishes and hence the ability to predict decreases. To
address this problem, an mth-order PPM scheme first attempts to predict using the m most recent
symbols. Progressively smaller patterns are utilized until a matching pattern is found and a
prediction can thereby be made. In the context of branch prediction, the symbols are branch
outcomes. The past outcomes used in prediction can be either local or global. In a local scheme,
the prediction for a given branch is based solely on the past outcomes of the (static) branch that
we are trying to predict. In contrast, a global scheme uses outcomes from all branches to make
the prediction. In this paper we propose a hybrid PPM-based branch predictor that employs
pattern matching on both lo-cal and global histories. The predictions based on the two histories
are combined using a perceptron-based neural net-work [3] to achieve a high prediction
accuracy. Hardware implementability is not our goal. Rather, we determine the best prediction
accuracy that can be achieved from PPM-like schemes given virtually unlimited memory and
processing time. This approach corresponds to the “idealistic” track of the 2nd JILP
Championship Branch Prediction Competition [2]. There are many optimizations and
heuristics that improve the speed, accuracy, and memory utilization of the basic PPM method. In
Section 2 we present our implementation technique and a set of modifications that prove
empirically to be beneficial to performance or resource usage. Finally, we draw some
conclusions in Section 3.

2. IMPLEMENTATION

Figure 2 shows the high-level block diagram of the Neuro- PPM predictor. Our scheme consists
of two PPM-based predictors [1], one that uses local-history information and the other that uses
global-history information to identify patterns and predict branch outcomes. For a given branch,
both PPM predictors are invoked to predict the branch outcome.

Figure -2 Figure 3

2.1. Global History PPM Predictor

We first describe the global PPM predictor and then detail the differences compared to the local
predictor. Figure 3 shows the block diagram for the PPM predictor that uses global history. An
m-bit shift register records global history and reflects the outcome of the last m dynamic
branches (abit’s value is one for branch taken, zero otherwise). Each time a branch outcome
becomes available, the shift register discards the oldest history bit and records the new outcome.
When a prediction is made, all m bits of history are compared against previously recorded

138


patterns. If the pattern is not found, we search for a shorter pattern, formed by the most recent m
− 1 history bits. The process of incrementally searching for a smaller pattern continues until a
match is found. When a pattern match occurs, the outcome of the branch that succeeded the
pattern during its last occurrence is returned as the prediction. The total number of patterns that
an m-bit history can form is ∑m 2L . To efficiently search L=1 the vast pattern space, we group
patterns according to their length and associate each group with a table. For example, table t is
associated with all attends of length t and table 1 with all patterns of length 1. When making a
prediction we use all m history bits to compute a hash value of the pattern. The n least signiﬁcant
bits of the computed hash are used to index into one of the 2n rows of table m. We resolve the
collisions caused by different hash values indexing into the same row of the table by searching a
linked list associated with this row. Each node in the linked list contains the pattern hash and the
predicted outcome. If a hash match is found the prediction is returned. Otherwise, we continue to
search for successively smaller patterns using the corresponding tables. During update, when the
actual outcome of the branch becomes available, we update all m tables. When a previously is
added to the corresponding linked list. While this general principle works well in many
scenarios, the accuracy of the prediction can be further improved by the following heurists

• program-counter tag match
efﬁcient history encoding
exploiting temporal pattern reuse

For example, applying these heuristics decreased the MPKI (Mispredicts Per Kilo Instruction)
for two lf by 30% and improved the simulation time by a factor of 700. We now de scribe these
heuristics in detail. Program-counter tag match One drawback of the base scheme is that it
cannot discriminate among global histories corresponding to different branches. For example,
assume that branch b21 is positively correlated with branch b8 while branch b32 is negatively
correlated with b8 . If the global histories when predicting b21 and b32 are identical, the patterns
destructively interfere and result in 100% wrong predictions. We address this problem by storing
the program counter (PC).

Figure 4. Figure 5
Improvement in prediction Communication distribution of
to PC tag match String length

In addition to the pattern hash in each node of the linked list associated with a hash table entry.
We return a prediction only when both the pattern hash and the PC match. One might wonder if
hashing schemes such as those employed by the gshare predictor [4] in which the PC is exclusive
or’ed with history bits to index into the table would eliminate the need for PC tag matching.

139


Though such schemes significantly reduce hash collisions they do not eliminate them. We have
experimentally determined that even with a more so phisticated hashing scheme than that used
by gshare, PC tag matching improves prediction accuracy for the CBP-2 traces. Figure 4 shows
the percent improvement in prediction accuracy for the CBP-2 traces when PC tagging is used.
As that figure indicates, PC tagging improves prediction accuracy by an average by 5.4% across
the 20 benchmarks and by as much as 18.3% (for vortex). Efficient history encoding One
disadvantage of our mbit shift register scheme as described thus far is that the history of a long
loop displaces other useful information from the history tables. For example, consider the
following code fragment:

k = 0; // #1
// #2
if (i == 0) k=1;
for (j=0; j<LEN; j++)
{ c += a[j]; }
if (k != 0) c -= 10;
// #3

Branches corresponding to lines #1 and #3 are positively correlated. That is, if the condition i==0
is true, then k!=0 is guaranteed to be true. However, the loop at line #2 that interleaves the
perfectly correlated branches will pollute the global history with LEN − 1 takens and one not
taken. If LEN is much larger than the global-history length (m), the out come of the branch at
line #1 is lost and therefore the correlation cannot be exploited when predicting the outcome of
the branch at line #3. One solution to this problem is to in crease the length of the global-history
indow. Because each additional history bit exponentially increases the memory requirement for
storing the patterns, this solution is not very practical. An alternate solution is to compress the
global history using simple schemes such as run-length encoding (RLE). With RLE, the m-bit shift register
is replaced with n counters. These counters reflect the lengths of the most recent n strings, where
a string is defined as a contiguous stream of zeros or ones. For example, a global history of 0 0 0
0 1 1 0 0 0 has an RLE representation of 4, 2, 3. If m = 2, the last two counter values (2 and 3)
are stored. We use 8-bit counters in our implementation. To help differ- entiate a string of zeros
from a string of ones, we initialize the counters to 0 or 128, respectively, at the start of a string.
The chance of counter overflow is negligible because 99% of the sequences of zeros or ones in
the global history are less than 100 elements long for the CBP-2 traces. During pattern search,
the hash values are computed from the n RLE counters instead of the m-bit shift-register. Of all
the CBP-2 benchmarks, RLE noticeably benefited only raytrace and mtrt. However, because the
reduction in MPKI was significant in both cases—approximately 57%—and increased MPKI in
none of the other cases we decided to retain RLE in our implementation.
The reason that some benchmarks observe a significant benefit from RLE while others observe
minimal benefit is explained by the string-length distributions of each trace. Figure 5 presents the
cumulative distribution function (CDF)of the global-history string lengths observed in mtrt and
perlbmk. It is clear from the CDF that strings of zeros and ones are significantly longer in mtrt
than in perlbmk. Consequently, RLE is more requently applicable to mtrt than perlbmk and
therefore yields a much greater improvement in MPKI for mtrt than for perlbmk.

140


Pattern bias Instead of using only the last outcome as prediction for a given pattern, tracking a
pattern’s bias towards taken or not taken can significantly improve the prediction accuracy.
Biastaken is given by P(taken|pattern). The prediction is taken if Biastaken > 0.5, suggesting that
the pattern is biased towards taken. Pattern bias can be captured easily by associating each
pattern with an up-down counter. Each time a given history pattern is seen the associated counter
is incremented when the branch outcome following the pattern is taken and decremented when
the outcome is not taken.
The prediction is simply the sign of the counter. For the sample stream shown in Figure 1, the
counter value associated with patterns of length one are: counter{1} = −2 and counter{0} = +5.
This suggests that pattern {1} is biased

Figure 6. Percent improvement in crafty’s prediction accuracy when saturating bias counters
areused in lieu of non-saturating counters towards not taken and pattern {0} towards taken.
Pattern bias appears to exhibit phases. During certain phases, a pattern may be biased towards
taken and in other phases the same pattern may be biased towards not taken. A non-saturating
counter—or saturating counter with an excessively large saturation value—exhibits lags in
tracking the bias and is therefore unable to track rapid phase changes. Conversely, a counter that
saturates too quickly will fail to capture pattern bias. Figure 6 quantifies the impact of counter
size of prediction accuracy for crafty. The figure plots the percent improvement in prediction
accuracy as a function of saturation value and indicates a maximum improvement of 12.7%
relative to a non-saturating counter. For the CBP-2 traces we determined empirically that a
counter that saturates at ±8 delivers the best performance overall.

Dynamic pattern length selection The baseline algorithm uses the longest pattern to predict a
branch outcome. The implicit assumption is that longer patterns result in higher confidence in the
prediction and are therefore more accurate. Although this is generally true, in some benchmarks
such as gzip and compress, using a shorter pattern actually results in higher accuracy than
matching longer patterns. To help dynamically select the best pattern length for a given branch,
we track the prediction accuracy along with the PC and pattern hash in each node of the linked
list. Rather than predicting based on the longest pattern match, we predict using the pattern that
results in the highest accuracy. For javac, the misprediction rate decreased by 16% due to
dynamic pattern length selection. The average improvement in prediction accuracy across the
CBP-2 traces is 3%.

141


Hash function We experimented with various hash functions and empirically identified that the
AP hash function [6] results in fewer collisions than other schemes. The lower number of
collisions in turn improved the linked-list search time and resulted in 10X faster code execution
than that achieved by using other hashing schemes. The AP hash is computed as follows:

rle_cou[], n_cou, PC
(h) pattern hash for the
n_cou counters of rle_cou[]
rle_cou[], n_cou, PC
for (h=i=0; i<n_cou; ++i) (h) pattern hash for the
{ n_cou counters of rle_cou[]
h = h ˆ (i&1 == 0)?
(h<<7 ˆ rle_cou[i] ˆ h>>3):
˜(h<<11 ˆ rle_cou[i] ˆ h>>5); rle_cou[], n_cou, PC
} (h) pattern hash for the
n_cou counters of rle_cou[]
h = h ˆ PC;

The index into the pattern tables is obtained by considering the n least significant bits of the
computed hash. Like the gshare predictor, the above scheme uses the PC in the hash
computation. Although the AP hash significantly lowers hash collisions it does not eliminate
them. We therefore resolve hash collisions by tag matching both the PC and the pattern hash in
the linked list associated with the indexed row of a given table. Note that the primary function of
the hash function is to speed up the pattern search process. Comparable hash functions have little
effect on prediction accuracy.

Memory cleanup For the two of benchmark, if 60 RLE counters are used for encoding the global
history more than 4 GB of memory is required to store all the patterns. This leads frequent page
swaps and causes the simulation to take about 2 days to complete on the test system (a Pentium 4
machine with 1 GB of RAM). Because the CBP-2 rules allow only 2 hours to process all 20
traces we perform periodic memory cleanups to speed up the simulation. Specifically, we scan all
the linked lists at regular intervals and free the nodes that have remained unused since the last
cleanup operation. The frequency of the cleanup operation is dynamically adjusted to restrict the
memory usage to a preset limit of 900 MB. This results in an almost 50X increase in simulation
speed for the CBP-2 traces. However, the main disadvantage of memory cleanup is the loss in
prediction accuracy.
Pattern length skipping In the original algorithm, when a pattern of length m is not found,
we search the history for the pattern of length m − 1. This process of searching for incrementally
smaller patterns continues until a match is found. To lower memory usage and computation time
requirements we modified our implementation to skip many pattern lengths. Using 60 RLE
counters for global history encoding we found that searching patterns of length {m, m − 5, m −
10, . . . , 1} for the gzip benchmark produceda fivefold faster simulation than searching patterns
of length {m, m − 1, m − 2, . . . , 1}. Also, because the memory usage of an m − 5 search
granularity is considerably smaller than an

142


Figure 7. MPKI for the local-PPM, global-PPM, and hybrid predictor

m − 1 search, memory cleanup is performed less frequently, which leads to a slight improvement
in prediction accuracy. Temporal reuse To exploit the temporal reuse of patterns, nodes
matching a given hash value and PC are moved to the head of the linked list. Doing so decreases
the pattern search time and produces an almost 3X improvement in simulation

2.2. Local-History PPM Predictor

The local-history PPM predictor uses the same algorithm and optimizations as those used in the
global predictor. However, it uses different history information for the pattern match. Instead of
using a single set of RLE counters, the local PPM predictor uses one set of counters for each
static branch in the trace. As in the global-history PPM predictor, patterns from all branches are
grouped according to length and stored in up to m tables. During pattern search, both the pattern
hash and the PC of the branch being predicted are matched. Because consecutive strings of zeros
and ones are signiﬁcantly longer in local history than in global history, 8-bit RLE counters are
insufﬁcient for the run-length encoding. One solution to this problem is to increase the counter
size (e.g., 32 bits). This increase, however, can result in long predictor warmup time and in
certain cases will perform no better than an always taken or always not taken prediction scheme.
Therefore, we restrict the counters to 8 bits and handle counter saturation by pushing a new
counter that represents the same bit as the saturated counter and dequeuing the oldest counter in
the RLE list.

Figure 8 The neural-network mixer

143


Figure 9. Percent reduction in MPKI when a perceptron instead of voting is used in the selector
2.3. The Neural Network

Typically, tournament (or hybrid) predictors use simple voting schemes to generate the ﬁnal prediction
from the constituent predictors. For example, the Alpha 21264 employs a 4K × 2-bit table (i.e., a 2-bit
saturating counter for each of 4K branches) to track which of two predictors is more accurate for a given
branch. Predictions are always made using the more accurate predictor. We experimented with different
selection techniques and found that a perceptron-based neural network outperforms traditional approaches
such as the 21264’s voting scheme. This is because, unlike traditional approaches, a perceptron can learn
linearly-separable boolean functions of its inputs.

Figure 8 illustrates the perceptron-based neural network mixer used in our hybrid predictor. The
output of the perceptron is given by y = w0 + w1 PL + w2 PG . The prediction is taken if y is
positive and not taken otherwise. The inputs PL and PG correspond to the predictions from the
local and global predictor, respectively, and is -1 if not taken and +1 if taken. 1 × 106 weights of
the form {w0 , w1 , w2 } are stored in a table. The lower 20 bits of the branch PC are used to
index into the table to select the weights. Training the neural network involves incrementing
those weights whose inputs match the branch outcome and decrementing those with a mismatch
[3].

Figure 9 shows the percent reduction in MPKI by using a perceptron mixer instead of a
traditional voting scheme. The average reduction in MPKI is 14% across all of the CBP-2 traces
and is as high as 66% in vortex and bzip. twolf is the only application that shows no imrovement

Figure 10. Percent reduction in MPKI for the idealistic scheme over the a realistic PPM predictor

2.4. Comparison to More Realistic PPM Schemes The hybrid PPM predictor

The hybrid PPM predictor proposed in this work uses more on-chip memory to store the patterns
than is available on current CPUs. This extra storage leads our predictor closer to the upper limit
on achievable prediction accuracy. We now compare the prediction accuracy of our predictor

144


against that of a more implementable PPM predictor. For this “realistic” predictor we use the
PPM predictor from CBP-1 [5], which uses purely global history and accommodates all of the
state information in 64 Kbits. This PPM predictor was ranked 5th in the contest and had only a
7% higher MPKI than the best predictor overall. Figure 10 shows the percentage reduction in
MPKI obtained by our PPM predictor relative to the best PPM predictor in the CBP-1 contest. It
is surprising to note that the average improvement possible with the idealistic PPM predictor is
only 30%. Though applications like raytrace, mtrt, perlbmk and vortex present a greater
opportunity for improvement, these applications generally exhibit small absolute MPKIs.

3. CONCLUSION

Our results, in contrast, suggest not only that identical history patterns often correspond to
different branches but also that these identical history patterns often lead to different predictions.
By qualifying each pattern in the history with the PC of the associated branch we are able to
disambiguate convicting patterns and reduce vortex’s MPKI by 18%, for example.
This strongly suggests that branch-prediction techniques need to monitor a pattern’s changing
bias towards taken or not taken and predict accordingly. The challenge is in selecting an
appropriate sensitivity to changes in bias: excessively rapid adaptivity causes the predictor to be
misled by short bursts of atypical behavior; excessively slow adaptivity delays the predictor’s
identiﬁcation of a phase change. We found that measuring bias using a 4-bit saturating counter
delivers the best prediction accuracy for the CBP-2 traces. Our second observation is that the
same history pattern at the same branch PC can result in different branch outcomes during
different stages of the program’s execution.
Finally, most branch-prediction schemes use a ﬁxed length shift register to encode history. In
benchmarks such as raytrace useful history is often displaced by long loops. The lesson to be
learned is that branch predictors need to treat repeated loop iterations as a single entity to
preserve more useful data in the history buffer. By RLE-encoding the history we reduced
raytrace’s MPKI by 57%, for example.
Our proposed predictor achieves an average MPKI of 3.00 across the 20 traces provided as part
of CBP-2. This represents a 2.1X improvement over the baseline gshare predictor distributed
with the CBP-2 simulation infrastructure.

References

[1] I-Cheng K. Chen, John T. Coffey, and Trevor N. Mudge. Anal ysis of branch prediction via
data compression. In Proceed ings of the Seventh International Conference on Architectural
Support for Programming Languages and Operating Systems, 1996.

[2] Daniel A. Jim´ nez et al. The 2nd JILP championship branche prediction competition
(CBP-2) call for predictors.http:// amino.rutgers.edu/cbp2/.

[3] Daniel A. Jim´ nez and Calvin Lin. Dynamic branch predice tion with perceptrons. In
HPCA ’01: Proceedings of the 7th International Symposium on High-Performance Computer
Ar chitecture, 2001.

145


[4] Scott McFarling. Combining branch predictors. Techni cal Report TN-36, Digital
Equipment Corporation, Western Research Laboratory, June 1993. http://www.hpl.hp.
com/techreports/Compaq-DEC/WRL-TN-36.pdf.

[5] Pierre Michaud. A PPM-like, tag-based branch predictor. In Proceedings of the First
Workshop on Championship Branch Prediction (in conjunction with MICRO-37), December
2004.

[6] Arash Partow.General purpose hash functionalgoithms.http://www.partow.net/programming/
hashfunctions/.

Authors Profile

Mr. K.Baburao is working as a Principal in Sahasra College of Engineering for
Women,Warangal. He has recived B.Tech & M.Tech. Now he is pursuing Ph.D at
JNTUH.

Dr. N.Satyanarayahna is working as a Principal at nagole institute of technology &
science . He has published so many international journals.

K.Vikram is working as a Vice-Principal at Medak College of Engineering and
Technology (MCET), Hyderabad, India. He has received ME.(Computer Science and
Engineering) from Anna University. Presently, he is a Research Scholar. He submitted
his thesis at JNTUH. He has published and presented good number of technical papers
in National and International Conferences. His main research interests are Software Engineering, Data
Mining, and Network Security.

146

Instruction level parallelism using ppm branch prediction

More Related Content

What's hot (19)

Similar to Instruction level parallelism using ppm branch prediction (20)

More from IAEME Publication (20)

Instruction level parallelism using ppm branch prediction