branch.h

Go to the documentation of this file.

/*
        Copyright (C) 1997 CFU Corporation

        File: branch.h
        Description: branch predictors
        Author: Chao-yinig Fu
        Date: Oct. 26, 2000

        ^..^
        (00)

         $__$
        <~00~>
         (oo)
          ||

        ```````
        C ^|^ D
         \ O /
*/

#ifndef INCLUDED_BRANCH_H
#define INCLUDED_BRANCH_H

#include <stdio.h>
#include <assert.h>

/*
class Virtual_Branch_Predictor
{
public:
        Virtual_Branch_Predictor() {}
        ~Virtual_Branch_Predictor() {}

        virtual void show(FILE *f);
        virtual void predict(int bhr,int ip,int &direction);
        virtual void update(int bhr,int ip,int actual_slot_taken);

private:
};
*/

class Branch_Predictor
{
public:
        Branch_Predictor():_tag(NULL),_counter(NULL) {}

        // b => block size
        // m => total number of bits to index the prediction table
        // s => issue_width
        // l => low order bit of branch
        Branch_Predictor(int b, int m,int s,int l):_b(b),_m(m),_num_of_slot(s+1),_l(l)
        {
                _num_of_entry=1<<_m;

                _tag=new int[_num_of_entry];
                _counter=new int[_num_of_entry];

                for(int i=0;i<_num_of_entry;i++)
                {
                        _counter[i]=0;  // initial value (weak fallthrough)
                }

                _low_bhr_mask=(1<<_l)-1;

                _index_mask=(1<<_m)-1;

                _num_of_slot_bits;
                int num_of_slot=_num_of_slot;
                for(;num_of_slot!=0;_num_of_slot_bits++)
                {
                        num_of_slot=num_of_slot>>1;     
                }
                
                _strong_mask=1<<_num_of_slot_bits;
                _slot_mask=_strong_mask-1;

                //show(stderr); 
                //exit(0);
        }

        void show(FILE *f)
        {
                fprintf(f,"_b=%d\n",_b);
                fprintf(f,"_m=%d\n",_m);
                fprintf(f,"_num_of_entry=%d\n",_num_of_entry);
                fprintf(f,"_l=%d\n",_l);
                fprintf(f,"_low_bhr_mask=%d\n",_low_bhr_mask);
                fprintf(f,"_index_mask=%d\n",_index_mask);
                fprintf(f,"_num_of_slot=%d\n",_num_of_slot);
                fprintf(f,"_num_of_slot_bits=%d\n",_num_of_slot_bits);
                fprintf(f,"_strong_mask=%d\n",_strong_mask);
                fprintf(f,"_slot_mask=%d\n",_slot_mask);
        }

        void predict(int bhr,int ip,int &direction);
        void update(int bhr,int ip,int actual_slot_taken);

        ~Branch_Predictor() 
        {
                delete []_tag;
                delete []_counter;
        }

private:
        int _b;         // operation size are the 2^_b bytes
        int _m;         // number of total bits as the index
        int _l;         // number of low-order IP to from the index
        int _num_of_entry;      // number of entries in the predictor table
        int *_tag;      // store the tag of this op
        int *_counter;  // store the value for prediction
        int _num_of_slot;       // number of slot in finite state machine
                                // = number of issue width + 1 (fall through)
        int _index_mask;        // the mask to get _m bits
        int _low_bhr_mask;              // the mask to get _l bits

        int _num_of_slot_bits;  // the bits to represent slots
        int _strong_mask;       
        int _slot_mask; 
        // the first bit of the counter value is strong(1) or weak(0)
        // the rest of bit is the slot number
        // Ex:
        //   000000, predict slot 0 (fall through) is weak taken 
        //   100011, predict slot 3 is strong taken 
        //   001011, predict slot 11 is weak taken 
        //
};

#endif // INCLUDED_BRANCH_H

---