1/*
2 * Copyright (c) 2014 The University of Wisconsin
3 *
4 * Copyright (c) 2006 INRIA (Institut National de Recherche en
5 * Informatique et en Automatique / French National Research Institute
6 * for Computer Science and Applied Mathematics)
7 *
8 * All rights reserved.

--- 154 unchanged lines hidden (view full) ---

163 if (bi->loopPredValid) {
164 if (taken != bi->loopPred) {
165 // free the entry
166 ltable[idx].numIter = 0;
167 ltable[idx].age = 0;
168 ltable[idx].confidence = 0;
169 ltable[idx].currentIter = 0;
170 return;
171 } else if (bi->loopPred != bi->tageBranchInfo->tagePred) {
172 DPRINTF(LTage, "Loop Prediction success:%lx\n",pc);
173 TAGEBase::unsignedCtrUpdate(ltable[idx].age, true,
174 loopTableAgeBits);
175 }
176 }
177
178 ltable[idx].currentIter =
179 (ltable[idx].currentIter + 1) & loopNumIterMask;
180 if (ltable[idx].currentIter > ltable[idx].numIter) {
181 ltable[idx].confidence = 0;
182 if (ltable[idx].numIter != 0) {
183 // free the entry
184 ltable[idx].numIter = 0;
185 ltable[idx].age = 0;
186 ltable[idx].confidence = 0;
187 }
188 }
189
190 if (taken != (useDirectionBit ? ltable[idx].dir : true)) {
191 if (ltable[idx].currentIter == ltable[idx].numIter) {
192 DPRINTF(LTage, "Loop End predicted successfully:%lx\n", pc);
193
194 TAGEBase::unsignedCtrUpdate(ltable[idx].confidence, true,
195 loopTableConfidenceBits);
196 //just do not predict when the loop count is 1 or 2
197 if (ltable[idx].numIter < 3) {
198 // free the entry
199 ltable[idx].dir = taken; // ignored if no useDirectionBit
200 ltable[idx].numIter = 0;
201 ltable[idx].age = 0;
202 ltable[idx].confidence = 0;

--- 11 unchanged lines hidden (view full) ---

214 ltable[idx].age = 0;
215 ltable[idx].confidence = 0;
216 }
217 }
218 ltable[idx].currentIter = 0;
219 }
220
221 } else if (useDirectionBit ?
222 ((bi->loopPredValid ?
223 bi->loopPred : bi->tageBranchInfo->tagePred) != taken) :
224 taken) {
225 //try to allocate an entry on taken branch
226 int nrand = TAGEBase::getRandom();
227 for (int i = 0; i < (1 << logLoopTableAssoc); i++) {
228 int loop_hit = (nrand + i) & ((1 << logLoopTableAssoc) - 1);
229 idx = bi->loopIndex + loop_hit;
230 if (ltable[idx].age == 0) {
231 DPRINTF(LTage, "Allocating loop pred entry for branch %lx\n",
232 pc);
233 ltable[idx].dir = !taken; // ignored if no useDirectionBit
234 ltable[idx].tag = bi->loopTag;

--- 10 unchanged lines hidden (view full) ---

245 }
246
247}
248
249//prediction
250bool
251LTAGE::predict(ThreadID tid, Addr branch_pc, bool cond_branch, void* &b)
252{
253 LTageBranchInfo *bi = new LTageBranchInfo(*tage);
254 b = (void*)(bi);
255
256 bool pred_taken = tage->tagePredict(tid, branch_pc, cond_branch,
257 bi->tageBranchInfo);
258
259 if (cond_branch) {
260 // loop prediction
261 bi->loopPred = getLoop(branch_pc, bi, useSpeculation);
262
263 if ((loopUseCounter >= 0) && bi->loopPredValid) {
264 pred_taken = bi->loopPred;
265 bi->tageBranchInfo->provider = LOOP;
266 }
267 DPRINTF(LTage, "Predict for %lx: taken?:%d, loopTaken?:%d, "
268 "loopValid?:%d, loopUseCounter:%d, tagePred:%d, altPred:%d\n",
269 branch_pc, pred_taken, bi->loopPred, bi->loopPredValid,
270 loopUseCounter, bi->tageBranchInfo->tagePred,
271 bi->tageBranchInfo->altTaken);
272
273 if (useSpeculation) {
274 specLoopUpdate(pred_taken, bi);
275 }
276 }
277
278 return pred_taken;
279}
280
281void
282LTAGE::update(ThreadID tid, Addr branch_pc, bool taken, void* bp_history,
283 bool squashed, const StaticInstPtr & inst, Addr corrTarget)
284{
285 assert(bp_history);
286
287 LTageBranchInfo* bi = static_cast<LTageBranchInfo*>(bp_history);
288
289 if (squashed) {
290 if (tage->isSpeculativeUpdateEnabled()) {
291 // This restores the global history, then update it
292 // and recomputes the folded histories.
293 tage->squash(tid, taken, bi->tageBranchInfo, corrTarget);
294 squashLoop(bi);
295 }
296 return;
297 }
298
299 int nrand = TAGEBase::getRandom() & 3;
300 if (bi->tageBranchInfo->condBranch) {
301 DPRINTF(LTage, "Updating tables for branch:%lx; taken?:%d\n",
302 branch_pc, taken);
303 tage->updateStats(taken, bi->tageBranchInfo);
304 // update stats
305 if (bi->tageBranchInfo->provider == LOOP) {
306 if (taken == bi->loopPred) {
307 loopPredictorCorrect++;
308 } else {
309 loopPredictorWrong++;
310 }
311 }
312 // cond Branch Update
313 if (useSpeculation) {
314 // recalculate loop prediction without speculation
315 // It is ok to overwrite the loop prediction fields in bi
316 // as the stats have already been updated with the previous
317 // values
318 bi->loopPred = getLoop(branch_pc, bi, false);
319 }
320 if (bi->loopPredValid) {
321 if (bi->tageBranchInfo->tagePred != bi->loopPred) {
322 TAGEBase::ctrUpdate(loopUseCounter,
323 (bi->loopPred == taken),
324 withLoopBits);
325 }
326 }
327
328 loopUpdate(branch_pc, taken, bi);
329
330 tage->condBranchUpdate(tid, branch_pc, taken, bi->tageBranchInfo,
331 nrand, corrTarget);
332 }
333
334 tage->updateHistories(tid, branch_pc, taken, bi->tageBranchInfo, false,
335 inst, corrTarget);
336
337 delete bi;
338}
339
340void
341LTAGE::squashLoop(LTageBranchInfo* bi)
342{
343 if (bi->tageBranchInfo->condBranch) {
344 if (bi->loopHit >= 0) {
345 int idx = finallindex(bi->loopIndex,
346 bi->loopLowPcBits,
347 bi->loopHit);
348 ltable[idx].currentIterSpec = bi->currentIter;
349 }
350 }
351}
352
353void
354LTAGE::squash(ThreadID tid, void *bp_history)
355{
356 LTageBranchInfo* bi = (LTageBranchInfo*)(bp_history);
357
358 if (bi->tageBranchInfo->condBranch) {
359 squashLoop(bi);
360 }
361
362 TAGE::squash(tid, bp_history);
363}
364
365void
366LTAGE::regStats()
367{
368 TAGE::regStats();
369
370 loopPredictorCorrect
371 .name(name() + ".loopPredictorCorrect")
372 .desc("Number of times the loop predictor is the provider and "
373 "the prediction is correct");

--- 14 unchanged lines hidden ---