statistical_corrector.cc

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Metempsy Technology Consulting
 * All rights reserved.
 *
 * Copyright (c) 2006 INRIA (Institut National de Recherche en
 * Informatique et en Automatique  / French National Research Institute
 * for Computer Science and Applied Mathematics)
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Author: André Seznec, Pau Cabre, Javier Bueno
 *
 */
 
/*
 * Statistical corrector base class
 */
 
 #include "cpu/pred/statistical_corrector.hh"
 
 #include "params/StatisticalCorrector.hh"
 
 StatisticalCorrector::StatisticalCorrector(
    const StatisticalCorrectorParams *p)
  : SimObject(p),
    logBias(p->logBias),
    logSizeUp(p->logSizeUp),
    logSizeUps(logSizeUp / 2),
    numEntriesFirstLocalHistories(p->numEntriesFirstLocalHistories),
    bwnb(p->bwnb),
    logBwnb(p->logBwnb),
    bwm(p->bwm),
    lnb(p->lnb),
    logLnb(p->logLnb),
    lm(p->lm),
    inb(p->inb),
    logInb(p->logInb),
    im(p->im),
    chooserConfWidth(p->chooserConfWidth),
    updateThresholdWidth(p->updateThresholdWidth),
    pUpdateThresholdWidth(p->pUpdateThresholdWidth),
    extraWeightsWidth(p->extraWeightsWidth),
    scCountersWidth(p->scCountersWidth),
    firstH(0),
    secondH(0),
    stats(this)
{
    wb.resize(1 << logSizeUps, 4);
 
    initGEHLTable(lnb, lm, lgehl, logLnb, wl, p->lWeightInitValue);
    initGEHLTable(bwnb, bwm, bwgehl, logBwnb, wbw, p->bwWeightInitValue);
    initGEHLTable(inb, im, igehl, logInb, wi, p->iWeightInitValue);
 
    updateThreshold = 35 << 3;
 
    pUpdateThreshold.resize(1 << logSizeUp, p->initialUpdateThresholdValue);
 
    bias.resize(1 << logBias);
    biasSK.resize(1 << logBias);
    biasBank.resize(1 << logBias);
}
 
StatisticalCorrector::BranchInfo*
StatisticalCorrector::makeBranchInfo()
{
    return new BranchInfo();
}
 
StatisticalCorrector::SCThreadHistory*
StatisticalCorrector::makeThreadHistory()
{
    return new SCThreadHistory();
}
 
void
StatisticalCorrector::initBias()
{
    for (int j = 0; j < (1 << logBias); j++) {
        switch (j & 3) {
          case 0:
            bias[j] = -32;
            biasSK[j] = -8;
            biasBank[j] = -32;
            break;
          case 1:
            bias[j] = 31;
            biasSK[j] = 7;
            biasBank[j] = 31;
            break;
          case 2:
            bias[j] = -1;
            biasSK[j] = -32;
            biasBank[j] = -1;
            break;
          case 3:
            bias[j] = 0;
            biasSK[j] = 31;
            biasBank[j] = 0;
            break;
        }
    }
}
 
void
StatisticalCorrector::initGEHLTable(unsigned numLenghts,
    std::vector<int> lengths, std::vector<int8_t> * & table,
    unsigned logNumEntries, std::vector<int8_t> & w, int8_t wInitValue)
{
    assert(lengths.size() == numLenghts);
    if (numLenghts == 0) {
        return;
    }
    table = new std::vector<int8_t> [numLenghts];
    for (int i = 0; i < numLenghts; ++i) {
        table[i].resize(1 << logNumEntries, 0);
        for (int j = 0; j < ((1 << logNumEntries) - 1); ++j) {
            if (! (j & 1)) {
                table[i][j] = -1;
            }
        }
    }
 
    w.resize(1 << logSizeUps, wInitValue);
}
 
unsigned
StatisticalCorrector::getIndBias(Addr branch_pc, BranchInfo* bi,
                                 bool bias) const
{
    return (((((branch_pc ^(branch_pc >>2))<<1) ^ (bi->lowConf & bias)) <<1)
            +  bi->predBeforeSC) & ((1<<logBias) -1);
}
 
unsigned
StatisticalCorrector::getIndBiasSK(Addr branch_pc, BranchInfo* bi) const
{
    return (((((branch_pc ^ (branch_pc >> (logBias-2)))<<1) ^
           (bi->highConf))<<1) + bi->predBeforeSC) & ((1<<logBias) -1);
}
 
unsigned
StatisticalCorrector::getIndUpd(Addr branch_pc) const
{
    return ((branch_pc ^ (branch_pc >>2)) & ((1 << (logSizeUp)) - 1));
}
 
unsigned
StatisticalCorrector::getIndUpds(Addr branch_pc) const
{
    return ((branch_pc ^ (branch_pc >>2)) & ((1 << (logSizeUps)) - 1));
}
 
int64_t
StatisticalCorrector::gIndex(Addr branch_pc, int64_t bhist, int logs, int nbr,
                             int i)
{
    return (((int64_t) branch_pc) ^ bhist ^ (bhist >> (8 - i)) ^
            (bhist >> (16 - 2 * i)) ^ (bhist >> (24 - 3 * i)) ^
            (bhist >> (32 - 3 * i)) ^ (bhist >> (40 - 4 * i))) &
           ((1 << (logs - gIndexLogsSubstr(nbr, i))) - 1);
}
 
int
StatisticalCorrector::gPredict(Addr branch_pc, int64_t hist,
        std::vector<int> & length, std::vector<int8_t> * tab, int nbr,
        int logs, std::vector<int8_t> & w)
{
    int percsum = 0;
    for (int i = 0; i < nbr; i++) {
        int64_t bhist = hist & ((int64_t) ((1 << length[i]) - 1));
        int64_t index = gIndex(branch_pc, bhist, logs, nbr, i);
        int8_t ctr = tab[i][index];
        percsum += (2 * ctr + 1);
    }
    percsum = (1 + (w[getIndUpds(branch_pc)] >= 0)) * percsum;
    return percsum;
}
 
void
StatisticalCorrector::gUpdate(Addr branch_pc, bool taken, int64_t hist,
                   std::vector<int> & length, std::vector<int8_t> * tab,
                   int nbr, int logs, std::vector<int8_t> & w,
                   BranchInfo* bi)
{
    int percsum = 0;
    for (int i = 0; i < nbr; i++) {
        int64_t bhist = hist & ((int64_t) ((1 << length[i]) - 1));
        int64_t index = gIndex(branch_pc, bhist, logs, nbr, i);
        percsum += (2 * tab[i][index] + 1);
        ctrUpdate(tab[i][index], taken, scCountersWidth);
    }
 
    int xsum = bi->lsum - ((w[getIndUpds(branch_pc)] >= 0)) * percsum;
    if ((xsum + percsum >= 0) != (xsum >= 0)) {
        ctrUpdate(w[getIndUpds(branch_pc)], ((percsum >= 0) == taken),
                  extraWeightsWidth);
    }
}
 
bool
StatisticalCorrector::scPredict(ThreadID tid, Addr branch_pc, bool cond_branch,
                     BranchInfo* bi, bool prev_pred_taken, bool bias_bit,
                     bool use_conf_ctr, int8_t conf_ctr, unsigned conf_bits,
                     int hitBank, int altBank, int64_t phist, int init_lsum)
{
    bool pred_taken = prev_pred_taken;
    if (cond_branch) {
 
        bi->predBeforeSC = prev_pred_taken;
 
        // first calc/update the confidences from the TAGE prediction
        if (use_conf_ctr) {
            bi->lowConf = (abs(2 * conf_ctr + 1) == 1);
            bi->medConf = (abs(2 * conf_ctr + 1) == 5);
            bi->highConf = (abs(2 * conf_ctr + 1) >= (1<<conf_bits) - 1);
        }
 
        int lsum = init_lsum;
 
        int8_t ctr = bias[getIndBias(branch_pc, bi, bias_bit)];
        lsum += (2 * ctr + 1);
        ctr = biasSK[getIndBiasSK(branch_pc, bi)];
        lsum += (2 * ctr + 1);
        ctr = biasBank[getIndBiasBank(branch_pc, bi, hitBank, altBank)];
        lsum += (2 * ctr + 1);
 
        lsum = (1 + (wb[getIndUpds(branch_pc)] >= 0)) * lsum;
 
        int thres = gPredictions(tid, branch_pc, bi, lsum, phist);
 
        // These will be needed at update time
        bi->lsum = lsum;
        bi->thres = thres;
 
        bool scPred = (lsum >= 0);
 
        if (pred_taken != scPred) {
            bool useScPred = true;
            //Choser uses TAGE confidence and |LSUM|
            if (bi->highConf) {
                if (abs (lsum) < (thres / 4)) {
                    useScPred = false;
                } else if (abs (lsum) < (thres / 2)) {
                    useScPred = (secondH < 0);
                }
            }
 
            if (bi->medConf) {
                if (abs (lsum) < (thres / 4)) {
                    useScPred = (firstH < 0);
                }
            }
 
            bi->usedScPred = useScPred;
            if (useScPred) {
                pred_taken = scPred;
                bi->scPred = scPred;
            }
        }
    }
 
    return pred_taken;
}
 
void
StatisticalCorrector::scHistoryUpdate(Addr branch_pc,
        const StaticInstPtr &inst, bool taken, BranchInfo * tage_bi,
        Addr corrTarget)
{
    int brtype = inst->isDirectCtrl() ? 0 : 2;
    if (! inst->isUncondCtrl()) {
        ++brtype;
    }
    // Non speculative SC histories update
    if (brtype & 1) {
        if (corrTarget < branch_pc) {
            //This branch corresponds to a loop
            if (!taken) {
                //exit of the "loop"
                scHistory->imliCount = 0;
            } else {
                if (scHistory->imliCount < ((1 << im[0]) - 1)) {
                    scHistory->imliCount++;
                }
            }
        }
 
        scHistory->bwHist = (scHistory->bwHist << 1) +
                                (taken & (corrTarget < branch_pc));
        scHistory->updateLocalHistory(1, branch_pc, taken);
    }
}
 
void
StatisticalCorrector::condBranchUpdate(ThreadID tid, Addr branch_pc,
        bool taken, BranchInfo *bi, Addr corrTarget, bool b, int hitBank,
        int altBank, int64_t phist)
{
    bool scPred = (bi->lsum >= 0);
 
    if (bi->predBeforeSC != scPred) {
        if (abs(bi->lsum) < bi->thres) {
            if (bi->highConf) {
                if ((abs(bi->lsum) < bi->thres / 2)) {
                    if ((abs(bi->lsum) >= bi->thres / 4)) {
                        ctrUpdate(secondH, (bi->predBeforeSC == taken),
                                  chooserConfWidth);
                    }
                }
            }
        }
        if (bi->medConf) {
            if ((abs(bi->lsum) < bi->thres / 4)) {
                ctrUpdate(firstH, (bi->predBeforeSC == taken),
                          chooserConfWidth);
            }
        }
    }
 
    if ((scPred != taken) || ((abs(bi->lsum) < bi->thres))) {
        ctrUpdate(updateThreshold, (scPred != taken), updateThresholdWidth);
        ctrUpdate(pUpdateThreshold[getIndUpd(branch_pc)], (scPred != taken),
                  pUpdateThresholdWidth);
 
        unsigned indUpds = getIndUpds(branch_pc);
        unsigned indBias = getIndBias(branch_pc, bi, b);
        unsigned indBiasSK = getIndBiasSK(branch_pc, bi);
        unsigned indBiasBank = getIndBiasBank(branch_pc, bi, hitBank, altBank);
 
        int xsum = bi->lsum -
                      ((wb[indUpds] >= 0) * ((2 * bias[indBias] + 1) +
                          (2 * biasSK[indBiasSK] + 1) +
                          (2 * biasBank[indBiasBank] + 1)));
 
        if ((xsum + ((2 * bias[indBias] + 1) + (2 * biasSK[indBiasSK] + 1) +
            (2 * biasBank[indBiasBank] + 1)) >= 0) != (xsum >= 0))
        {
            ctrUpdate(wb[indUpds],
                      (((2 * bias[indBias] + 1) +
                        (2 * biasSK[indBiasSK] + 1) +
                        (2 * biasBank[indBiasBank] + 1) >= 0) == taken),
                      extraWeightsWidth);
        }
 
        ctrUpdate(bias[indBias], taken, scCountersWidth);
        ctrUpdate(biasSK[indBiasSK], taken, scCountersWidth);
        ctrUpdate(biasBank[indBiasBank], taken, scCountersWidth);
 
        gUpdates(tid, branch_pc, taken, bi, phist);
    }
}
 
void
StatisticalCorrector::updateStats(bool taken, BranchInfo *bi)
{
    if (taken == bi->scPred) {
        stats.correct++;
    } else {
        stats.wrong++;
    }
}
 
void
StatisticalCorrector::init()
{
    scHistory = makeThreadHistory();
    initBias();
}
 
size_t
StatisticalCorrector::getSizeInBits() const
{
    // Not implemented
    return 0;
}
 
StatisticalCorrector::StatisticalCorrectorStats::StatisticalCorrectorStats(
    Stats::Group *parent)
    : Stats::Group(parent),
      ADD_STAT(correct, "Number of time the SC predictor is the"
          " provider and the prediction is correct"),
      ADD_STAT(wrong, "Number of time the SC predictor is the"
          " provider and the prediction is wrong")
{
}