feat: add branch predictor modules

Author: maksyuki

rtl/tc_l2/src/main/scala/core/if/BPU.scala

@@ -0,0 +1,45 @@
+package treecorel2
+
+import chisel3._
+import chisel3.util._
+
+import treecorel2.common.ConstVal
+
+class BPU extends Module {
+  // 2BP 2BC
+  // Two-level adaptive predictor
+  val io = IO(new Bundle {
+    val branchInfo = Flipped(new BRANCHIO)
+    // predictor interface
+    val lookupPc  = Input(UInt(ConstVal.AddrLen.W))
+    val predTaken = Output(Bool())
+    val predTgt   = Output(UInt(ConstVal.AddrLen.W))
+    val predIdx   = Output(UInt(ConstVal.GHRLen.W))
+  })
+
+  protected val ghr = Module(new GHR)
+  protected val pht = Module(new PHT)
+  protected val btb = Module(new BTB)
+
+  ghr.io.branch := io.branchInfo.branch
+  ghr.io.taken  := io.branchInfo.taken
+
+  // G-share
+  protected val idx = io.lookupPc(ConstVal.GHRLen + ConstVal.AddrAlignLen - 1, ConstVal.AddrAlignLen) ^ ghr.io.idx
+  pht.io.prevBranch := io.branchInfo.branch
+  pht.io.prevTaken  := io.branchInfo.taken
+  pht.io.prevIdx    := io.branchInfo.idx
+  pht.io.idx        := idx
+
+  // wire BTB
+  btb.io.branch   := io.branchInfo.branch
+  btb.io.jump     := io.branchInfo.jump
+  btb.io.pc       := io.branchInfo.pc
+  btb.io.tgt      := io.branchInfo.tgt
+  btb.io.lookupPc := io.lookupPc
+
+  // wire output signals
+  io.predTaken := btb.io.lookupBranch && (pht.io.taken || btb.io.lookupJump)
+  io.predTgt   := btb.io.lookupTgt
+  io.predIdx   := idx
+}

rtl/tc_l2/src/main/scala/core/if/BTB.scala

@@ -0,0 +1,53 @@
+package treecorel2
+
+import chisel3._
+import chisel3.util._
+
+import treecorel2.common.ConstVal
+
+class BTBLine extends Bundle {
+  val pc   = UInt(ConstVal.BTBPcLen.W)
+  val tgt  = UInt(ConstVal.BTBTgtLen.W)
+  val jump = Bool()
+}
+
+class BTB extends Module {
+  val io = IO(new Bundle {
+    // branch info (from idu)
+    val branch = Input(Bool())
+    val jump   = Input(Bool())
+    val pc     = Input(UInt(ConstVal.AddrLen.W))
+    val tgt    = Input(UInt(ConstVal.AddrLen.W))
+    // BTB lookup interface
+    val lookupBranch = Output(Bool())
+    val lookupJump   = Output(Bool())
+    val lookupPc     = Input(UInt(ConstVal.AddrLen.W))
+    val lookupTgt    = Output(UInt(ConstVal.AddrLen.W))
+  })
+
+  // definitions of BTB lines and valid bits
+  protected val valids = RegInit(VecInit(Seq.fill(ConstVal.BTBSize) { false.B }))
+  protected val lines  = Mem(ConstVal.BTBSize, new BTBLine)
+
+  // branch info for BTB lines
+  protected val idx    = io.pc(ConstVal.BTBIdxLen + ConstVal.AddrAlignLen - 1, ConstVal.AddrAlignLen)
+  protected val linePc = io.pc(ConstVal.AddrLen - 1, ConstVal.BTBIdxLen + ConstVal.AddrAlignLen)
+
+  // write to BTB lines
+  when(io.branch) {
+    valids(idx)     := true.B
+    lines(idx).jump := io.jump
+    lines(idx).pc   := linePc
+    lines(idx).tgt  := io.tgt(ConstVal.AddrLen - 1, ConstVal.AddrAlignLen)
+  }
+
+  // signals about BTB lookup
+  val lookupIdx   = io.lookupPc(ConstVal.BTBIdxLen + ConstVal.AddrAlignLen - 1, ConstVal.AddrAlignLen)
+  val lookupPcSel = io.lookupPc(ConstVal.AddrLen - 1, ConstVal.BTBIdxLen + ConstVal.AddrAlignLen)
+  val btbHit      = valids(lookupIdx) && lines(lookupIdx).pc === lookupPcSel
+
+  // BTB lookup
+  io.lookupBranch := btbHit
+  io.lookupJump   := Mux(btbHit, lines(lookupIdx).jump, false.B)
+  io.lookupTgt    := Cat(Mux(btbHit, lines(lookupIdx).tgt, 0.U), 0.U(ConstVal.AddrAlignLen.W))
+}

rtl/tc_l2/src/main/scala/core/if/GHR.scala

@@ -0,0 +1,22 @@
+package treecorel2
+
+import chisel3._
+import chisel3.util._
+
+import treecorel2.common.ConstVal
+
+class GHR extends Module {
+  val io = IO(new Bundle {
+    val branch = Input(Bool())
+    val taken  = Input(Bool())
+    val idx    = Output(UInt(ConstVal.GHRLen.W))
+  })
+
+  protected val ghr = Reg(UInt(ConstVal.GHRLen.W))
+
+  when(io.branch) {
+    ghr := Cat(ghr(ConstVal.GHRLen - 2, 0), io.taken)
+  }
+
+  io.idx := ghr
+}

rtl/tc_l2/src/main/scala/core/if/PHT.scala

@@ -0,0 +1,43 @@
+package treecorel2
+
+import chisel3._
+import chisel3.util._
+
+import treecorel2.common.ConstVal
+
+class PHT extends Module {
+  val io = IO(new Bundle {
+    // branch info (from idu)
+    val prevBranch = Input(Bool())
+    val prevTaken  = Input(Bool())
+    val prevIdx    = Input(UInt(ConstVal.GHRLen.W))
+    // index for looking up counter table
+    val idx = Input(UInt(ConstVal.GHRLen.W))
+    // prediction result
+    val taken = Output(Bool())
+  })
+
+  protected val init     = Seq.fill(ConstVal.PHTSize) { "b10".U(2.W) }
+  protected val counters = RegInit(VecInit(init))
+
+  // update counter
+  when(io.prevBranch) {
+    when(counters(io.prevIdx) === "b11".U) {
+      when(!io.prevTaken) {
+        counters(io.prevIdx) := counters(io.prevIdx) - 1.U
+      }
+    }.elsewhen(counters(io.prevIdx) === "b00".U) {
+      when(io.prevTaken) {
+        counters(io.prevIdx) := counters(io.prevIdx) + 1.U
+      }
+    }.otherwise {
+      when(!io.prevTaken) {
+        counters(io.prevIdx) := counters(io.prevIdx) - 1.U
+      }.otherwise {
+        counters(io.prevIdx) := counters(io.prevIdx) + 1.U
+      }
+    }
+  }
+
+  io.taken := counters(io.idx)(1)
+}