1/*************************************************************************************** 2* Copyright (c) 2020-2021 Institute of Computing Technology, Chinese Academy of Sciences 3* Copyright (c) 2020-2021 Peng Cheng Laboratory 4* 5* XiangShan is licensed under Mulan PSL v2. 6* You can use this software according to the terms and conditions of the Mulan PSL v2. 7* You may obtain a copy of Mulan PSL v2 at: 8* http://license.coscl.org.cn/MulanPSL2 9* 10* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, 11* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, 12* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. 13* 14* See the Mulan PSL v2 for more details. 15***************************************************************************************/ 16 17package xiangshan.frontend.icache 18 19import chisel3._ 20import chisel3.util._ 21import freechips.rocketchip.diplomacy.{IdRange, LazyModule, LazyModuleImp} 22import freechips.rocketchip.tilelink._ 23import freechips.rocketchip.util.BundleFieldBase 24import huancun.{AliasField, PrefetchField} 25import org.chipsalliance.cde.config.Parameters 26import utility._ 27import utils._ 28import xiangshan._ 29import xiangshan.cache._ 30import xiangshan.cache.mmu.TlbRequestIO 31import xiangshan.frontend._ 32import firrtl.ir.Block 33 34case class ICacheParameters( 35 nSets: Int = 256, 36 nWays: Int = 4, 37 rowBits: Int = 64, 38 nTLBEntries: Int = 32, 39 tagECC: Option[String] = None, 40 dataECC: Option[String] = None, 41 replacer: Option[String] = Some("random"), 42 nMissEntries: Int = 2, 43 nReleaseEntries: Int = 1, 44 nProbeEntries: Int = 2, 45 // fdip default config 46 enableICachePrefetch: Boolean = true, 47 prefetchToL1: Boolean = false, 48 prefetchPipeNum: Int = 1, 49 nPrefetchEntries: Int = 12, 50 nPrefBufferEntries: Int = 32, 51 maxIPFMoveConf: Int = 1, // temporary use small value to cause more "move" operation 52 minRangeFromIFUptr: Int = 2, 53 maxRangeFromIFUptr: Int = 32, 54 55 nMMIOs: Int = 1, 56 blockBytes: Int = 64 57)extends L1CacheParameters { 58 59 val setBytes = nSets * blockBytes 60 val aliasBitsOpt = DCacheParameters().aliasBitsOpt //if(setBytes > pageSize) Some(log2Ceil(setBytes / pageSize)) else None 61 val reqFields: Seq[BundleFieldBase] = Seq( 62 PrefetchField(), 63 ReqSourceField() 64 ) ++ aliasBitsOpt.map(AliasField) 65 val echoFields: Seq[BundleFieldBase] = Nil 66 def tagCode: Code = Code.fromString(tagECC) 67 def dataCode: Code = Code.fromString(dataECC) 68 def replacement = ReplacementPolicy.fromString(replacer,nWays,nSets) 69} 70 71trait HasICacheParameters extends HasL1CacheParameters with HasInstrMMIOConst with HasIFUConst{ 72 val cacheParams = icacheParameters 73 val dataCodeUnit = 16 74 val dataCodeUnitNum = blockBits/2/dataCodeUnit 75 76 def highestIdxBit = log2Ceil(nSets) - 1 77 def encDataUnitBits = cacheParams.dataCode.width(dataCodeUnit) 78 def dataCodeBits = encDataUnitBits - dataCodeUnit 79 def dataCodeEntryBits = dataCodeBits * dataCodeUnitNum 80 81 val ICacheSets = cacheParams.nSets 82 val ICacheWays = cacheParams.nWays 83 84 val ICacheSameVPAddrLength = 12 85 val ReplaceIdWid = 5 86 87 val ICacheWordOffset = 0 88 val ICacheSetOffset = ICacheWordOffset + log2Up(blockBytes) 89 val ICacheAboveIndexOffset = ICacheSetOffset + log2Up(ICacheSets) 90 val ICacheTagOffset = ICacheAboveIndexOffset min ICacheSameVPAddrLength 91 92 def PortNumber = 2 93 94 def partWayNum = 4 95 def pWay = nWays/partWayNum 96 97 def enableICachePrefetch = cacheParams.enableICachePrefetch 98 def prefetchToL1 = cacheParams.prefetchToL1 99 def prefetchPipeNum = cacheParams.prefetchPipeNum 100 def nPrefetchEntries = cacheParams.nPrefetchEntries 101 def nPrefBufferEntries = cacheParams.nPrefBufferEntries 102 def maxIPFMoveConf = cacheParams.maxIPFMoveConf 103 def minRangeFromIFUptr = cacheParams.minRangeFromIFUptr 104 def maxRangeFromIFUptr = cacheParams.maxRangeFromIFUptr 105 106 def getBits(num: Int) = log2Ceil(num).W 107 108 109 def generatePipeControl(lastFire: Bool, thisFire: Bool, thisFlush: Bool, lastFlush: Bool): Bool = { 110 val valid = RegInit(false.B) 111 when(thisFlush) {valid := false.B} 112 .elsewhen(lastFire && !lastFlush) {valid := true.B} 113 .elsewhen(thisFire) {valid := false.B} 114 valid 115 } 116 117 def ResultHoldBypass[T<:Data](data: T, valid: Bool): T = { 118 Mux(valid, data, RegEnable(data, valid)) 119 } 120 121 def holdReleaseLatch(valid: Bool, release: Bool, flush: Bool): Bool ={ 122 val bit = RegInit(false.B) 123 when(flush) { bit := false.B } 124 .elsewhen(valid && !release) { bit := true.B } 125 .elsewhen(release) { bit := false.B } 126 bit || valid 127 } 128 129 def blockCounter(block: Bool, flush: Bool, threshold: Int): Bool = { 130 val counter = RegInit(0.U(log2Up(threshold + 1).W)) 131 when (block) { counter := counter + 1.U } 132 when (flush) { counter := 0.U} 133 counter > threshold.U 134 } 135 136 def InitQueue[T <: Data](entry: T, size: Int): Vec[T] ={ 137 return RegInit(VecInit(Seq.fill(size)(0.U.asTypeOf(entry.cloneType)))) 138 } 139 140 def getBlkAddr(addr: UInt) = addr >> log2Ceil(blockBytes) 141 142 require(isPow2(nSets), s"nSets($nSets) must be pow2") 143 require(isPow2(nWays), s"nWays($nWays) must be pow2") 144} 145 146abstract class ICacheBundle(implicit p: Parameters) extends XSBundle 147 with HasICacheParameters 148 149abstract class ICacheModule(implicit p: Parameters) extends XSModule 150 with HasICacheParameters 151 152abstract class ICacheArray(implicit p: Parameters) extends XSModule 153 with HasICacheParameters 154 155class ICacheMetadata(implicit p: Parameters) extends ICacheBundle { 156 val tag = UInt(tagBits.W) 157} 158 159object ICacheMetadata { 160 def apply(tag: Bits)(implicit p: Parameters) = { 161 val meta = Wire(new ICacheMetadata) 162 meta.tag := tag 163 meta 164 } 165} 166 167 168class ICacheMetaArray()(implicit p: Parameters) extends ICacheArray 169{ 170 def onReset = ICacheMetadata(0.U) 171 val metaBits = onReset.getWidth 172 val metaEntryBits = cacheParams.tagCode.width(metaBits) 173 174 val io=IO{new Bundle{ 175 val write = Flipped(DecoupledIO(new ICacheMetaWriteBundle)) 176 val read = Flipped(DecoupledIO(new ICacheReadBundle)) 177 val readResp = Output(new ICacheMetaRespBundle) 178 val cacheOp = Flipped(new L1CacheInnerOpIO) // customized cache op port 179 val fencei = Input(Bool()) 180 }} 181 182 io.read.ready := !io.write.valid 183 184 val port_0_read_0 = io.read.valid && !io.read.bits.vSetIdx(0)(0) 185 val port_0_read_1 = io.read.valid && io.read.bits.vSetIdx(0)(0) 186 val port_1_read_1 = io.read.valid && io.read.bits.vSetIdx(1)(0) && io.read.bits.isDoubleLine 187 val port_1_read_0 = io.read.valid && !io.read.bits.vSetIdx(1)(0) && io.read.bits.isDoubleLine 188 189 val port_0_read_0_reg = RegEnable(port_0_read_0, io.read.fire) 190 val port_0_read_1_reg = RegEnable(port_0_read_1, io.read.fire) 191 val port_1_read_1_reg = RegEnable(port_1_read_1, io.read.fire) 192 val port_1_read_0_reg = RegEnable(port_1_read_0, io.read.fire) 193 194 val bank_0_idx = Mux(port_0_read_0, io.read.bits.vSetIdx(0), io.read.bits.vSetIdx(1)) 195 val bank_1_idx = Mux(port_0_read_1, io.read.bits.vSetIdx(0), io.read.bits.vSetIdx(1)) 196 val bank_idx = Seq(bank_0_idx, bank_1_idx) 197 198 val write_bank_0 = io.write.valid && !io.write.bits.bankIdx 199 val write_bank_1 = io.write.valid && io.write.bits.bankIdx 200 201 val write_meta_bits = Wire(UInt(metaEntryBits.W)) 202 203 val tagArrays = (0 until 2) map { bank => 204 val tagArray = Module(new SRAMTemplate( 205 UInt(metaEntryBits.W), 206 set=nSets/2, 207 way=nWays, 208 shouldReset = true, 209 holdRead = true, 210 singlePort = true 211 )) 212 213 //meta connection 214 if(bank == 0) { 215 tagArray.io.r.req.valid := port_0_read_0 || port_1_read_0 216 tagArray.io.r.req.bits.apply(setIdx=bank_0_idx(highestIdxBit,1)) 217 tagArray.io.w.req.valid := write_bank_0 218 tagArray.io.w.req.bits.apply(data=write_meta_bits, setIdx=io.write.bits.virIdx(highestIdxBit,1), waymask=io.write.bits.waymask) 219 } 220 else { 221 tagArray.io.r.req.valid := port_0_read_1 || port_1_read_1 222 tagArray.io.r.req.bits.apply(setIdx=bank_1_idx(highestIdxBit,1)) 223 tagArray.io.w.req.valid := write_bank_1 224 tagArray.io.w.req.bits.apply(data=write_meta_bits, setIdx=io.write.bits.virIdx(highestIdxBit,1), waymask=io.write.bits.waymask) 225 } 226 227 tagArray 228 } 229 230 val read_set_idx_next = RegEnable(io.read.bits.vSetIdx, io.read.fire) 231 val valid_array = RegInit(VecInit(Seq.fill(nWays)(0.U(nSets.W)))) 232 val valid_metas = Wire(Vec(PortNumber, Vec(nWays, Bool()))) 233 // valid read 234 (0 until PortNumber).foreach( i => 235 (0 until nWays).foreach( way => 236 valid_metas(i)(way) := valid_array(way)(read_set_idx_next(i)) 237 )) 238 io.readResp.entryValid := valid_metas 239 240 io.read.ready := !io.write.valid && !io.fencei && tagArrays.map(_.io.r.req.ready).reduce(_&&_) 241 242 //Parity Decode 243 val read_fire_delay1 = RegNext(io.read.fire, init = false.B) 244 val read_fire_delay2 = RegNext(read_fire_delay1, init = false.B) 245 val read_metas = Wire(Vec(2,Vec(nWays,new ICacheMetadata()))) 246 for((tagArray,i) <- tagArrays.zipWithIndex){ 247 val read_meta_bits = tagArray.io.r.resp.asTypeOf(Vec(nWays,UInt(metaEntryBits.W))) 248 val read_meta_decoded = read_meta_bits.map{ way_bits => cacheParams.tagCode.decode(way_bits)} 249 val read_meta_wrong = read_meta_decoded.map{ way_bits_decoded => way_bits_decoded.error} 250 val read_meta_corrected = VecInit(read_meta_decoded.map{ way_bits_decoded => way_bits_decoded.corrected}) 251 read_metas(i) := read_meta_corrected.asTypeOf(Vec(nWays,new ICacheMetadata())) 252 (0 until nWays).foreach{ w => io.readResp.errors(i)(w) := RegEnable(read_meta_wrong(w), read_fire_delay1) && read_fire_delay2} 253 } 254 255 //Parity Encode 256 val write = io.write.bits 257 write_meta_bits := cacheParams.tagCode.encode(ICacheMetadata(tag = write.phyTag).asUInt) 258 259 // valid write 260 val way_num = OHToUInt(io.write.bits.waymask) 261 when (io.write.valid) { 262 valid_array(way_num) := valid_array(way_num).bitSet(io.write.bits.virIdx, true.B) 263 } 264 265 XSPerfAccumulate("meta_refill_num", io.write.valid) 266 267 io.readResp.metaData <> DontCare 268 when(port_0_read_0_reg){ 269 io.readResp.metaData(0) := read_metas(0) 270 }.elsewhen(port_0_read_1_reg){ 271 io.readResp.metaData(0) := read_metas(1) 272 } 273 274 when(port_1_read_0_reg){ 275 io.readResp.metaData(1) := read_metas(0) 276 }.elsewhen(port_1_read_1_reg){ 277 io.readResp.metaData(1) := read_metas(1) 278 } 279 280 281 io.write.ready := true.B // TODO : has bug ? should be !io.cacheOp.req.valid 282 // deal with customized cache op 283 require(nWays <= 32) 284 io.cacheOp.resp.bits := DontCare 285 val cacheOpShouldResp = WireInit(false.B) 286 when(io.cacheOp.req.valid){ 287 when( 288 CacheInstrucion.isReadTag(io.cacheOp.req.bits.opCode) || 289 CacheInstrucion.isReadTagECC(io.cacheOp.req.bits.opCode) 290 ){ 291 for (i <- 0 until 2) { 292 tagArrays(i).io.r.req.valid := true.B 293 tagArrays(i).io.r.req.bits.apply(setIdx = io.cacheOp.req.bits.index) 294 } 295 cacheOpShouldResp := true.B 296 } 297 when(CacheInstrucion.isWriteTag(io.cacheOp.req.bits.opCode)){ 298 for (i <- 0 until 2) { 299 tagArrays(i).io.w.req.valid := true.B 300 tagArrays(i).io.w.req.bits.apply( 301 data = io.cacheOp.req.bits.write_tag_low, 302 setIdx = io.cacheOp.req.bits.index, 303 waymask = UIntToOH(io.cacheOp.req.bits.wayNum(log2Ceil(nWays) - 1, 0)) 304 ) 305 } 306 cacheOpShouldResp := true.B 307 } 308 // TODO 309 // when(CacheInstrucion.isWriteTagECC(io.cacheOp.req.bits.opCode)){ 310 // for (i <- 0 until readPorts) { 311 // array(i).io.ecc_write.valid := true.B 312 // array(i).io.ecc_write.bits.idx := io.cacheOp.req.bits.index 313 // array(i).io.ecc_write.bits.way_en := UIntToOH(io.cacheOp.req.bits.wayNum(4, 0)) 314 // array(i).io.ecc_write.bits.ecc := io.cacheOp.req.bits.write_tag_ecc 315 // } 316 // cacheOpShouldResp := true.B 317 // } 318 } 319 io.cacheOp.resp.valid := RegNext(io.cacheOp.req.valid && cacheOpShouldResp) 320 io.cacheOp.resp.bits.read_tag_low := Mux(io.cacheOp.resp.valid, 321 tagArrays(0).io.r.resp.asTypeOf(Vec(nWays, UInt(tagBits.W)))(io.cacheOp.req.bits.wayNum), 322 0.U 323 ) 324 io.cacheOp.resp.bits.read_tag_ecc := DontCare // TODO 325 // TODO: deal with duplicated array 326 327 // fencei logic : reset valid_array 328 when (io.fencei) { 329 (0 until nWays).foreach( way => 330 valid_array(way) := 0.U 331 ) 332 } 333} 334 335 336 337class ICacheDataArray(implicit p: Parameters) extends ICacheArray 338{ 339 340 def getECCFromEncUnit(encUnit: UInt) = { 341 require(encUnit.getWidth == encDataUnitBits) 342 if (encDataUnitBits == dataCodeUnit) { 343 0.U.asTypeOf(UInt(1.W)) 344 } else { 345 encUnit(encDataUnitBits - 1, dataCodeUnit) 346 } 347 } 348 349 def getECCFromBlock(cacheblock: UInt) = { 350 // require(cacheblock.getWidth == blockBits) 351 VecInit((0 until dataCodeUnitNum).map { w => 352 val unit = cacheblock(dataCodeUnit * (w + 1) - 1, dataCodeUnit * w) 353 getECCFromEncUnit(cacheParams.dataCode.encode(unit)) 354 }) 355 } 356 357 val halfBlockBits = blockBits / 2 358 val codeBits = dataCodeEntryBits 359 360 val io=IO{new Bundle{ 361 val write = Flipped(DecoupledIO(new ICacheDataWriteBundle)) 362 val read = Flipped(DecoupledIO(Vec(partWayNum, new ICacheReadBundle))) 363 val readResp = Output(new ICacheDataRespBundle) 364 val cacheOp = Flipped(new L1CacheInnerOpIO) // customized cache op port 365 }} 366 io.cacheOp := DontCare 367 /** 368 ****************************************************************************** 369 * data array 370 ****************************************************************************** 371 */ 372 val write_data_bits = io.write.bits.data.asTypeOf(Vec(2, UInt(halfBlockBits.W))) 373 val dataArrays = (0 until partWayNum).map{ bank => 374 (0 until 2).map { i => 375 val sramBank = Module(new SRAMTemplate( 376 UInt(halfBlockBits.W), 377 set=nSets, 378 way=pWay, 379 shouldReset = true, 380 holdRead = true, 381 singlePort = true 382 )) 383 // SRAM read logic 384 sramBank.io.r.req.valid := io.read.valid 385 if (i == 1) { 386 sramBank.io.r.req.bits.apply(setIdx= io.read.bits(bank).vSetIdx(0)) 387 } else { 388 // read low of startline if cross cacheline 389 val setIdx = Mux(io.read.bits(bank).isDoubleLine, io.read.bits(bank).vSetIdx(1), io.read.bits(bank).vSetIdx(0)) 390 sramBank.io.r.req.bits.apply(setIdx= setIdx) 391 } 392 393 // SRAM write logic 394 val waymask = io.write.bits.waymask.asTypeOf(Vec(partWayNum, Vec(pWay, Bool())))(bank) 395 // waymask is invalid when way of SRAMTemplate is 1 396 sramBank.io.w.req.valid := io.write.valid && waymask.asUInt.orR 397 sramBank.io.w.req.bits.apply( 398 data = write_data_bits(i), 399 setIdx = io.write.bits.virIdx, 400 waymask = waymask.asUInt 401 ) 402 sramBank 403 } 404 } 405 406 /** 407 ****************************************************************************** 408 * data code array 409 ****************************************************************************** 410 */ 411 val write_code_bits = write_data_bits.map(getECCFromBlock(_).asUInt) 412 val codeArrays = (0 until 2) map { i => 413 val codeArray = Module(new SRAMTemplate( 414 UInt(codeBits.W), 415 set=nSets, 416 way=nWays, 417 shouldReset = true, 418 holdRead = true, 419 singlePort = true 420 )) 421 // SRAM read logic 422 codeArray.io.r.req.valid := io.read.valid 423 if (i == 1) { 424 codeArray.io.r.req.bits.apply(setIdx= io.read.bits.last.vSetIdx(0)) 425 } else { 426 val setIdx = Mux(io.read.bits.last.isDoubleLine, io.read.bits.last.vSetIdx(1), io.read.bits.last.vSetIdx(0)) 427 codeArray.io.r.req.bits.apply(setIdx= setIdx) 428 } 429 // SRAM write logic 430 codeArray.io.w.req.valid := io.write.valid 431 codeArray.io.w.req.bits.apply( 432 data = write_code_bits(i), 433 setIdx = io.write.bits.virIdx, 434 waymask = io.write.bits.waymask 435 ) 436 codeArray 437 } 438 439 /** 440 ****************************************************************************** 441 * read logic 442 ****************************************************************************** 443 */ 444 val isDoubleLineReg = RegEnable(io.read.bits.last.isDoubleLine, io.read.fire) 445 val read_data_bits = Wire(Vec(2,Vec(nWays,UInt(halfBlockBits.W)))) 446 val read_code_bits = Wire(Vec(2,Vec(nWays,UInt(codeBits.W)))) 447 448 (0 until nWays).map { w => 449 // first data 450 read_data_bits(0)(w) := Mux(isDoubleLineReg, 451 dataArrays(w/pWay)(1).io.r.resp.asTypeOf(Vec(pWay, UInt(halfBlockBits.W)))(w%pWay), 452 dataArrays(w/pWay)(0).io.r.resp.asTypeOf(Vec(pWay, UInt(halfBlockBits.W)))(w%pWay)) 453 // second data 454 read_data_bits(1)(w) := Mux(isDoubleLineReg, 455 dataArrays(w/pWay)(0).io.r.resp.asTypeOf(Vec(pWay, UInt(halfBlockBits.W)))(w%pWay), 456 dataArrays(w/pWay)(1).io.r.resp.asTypeOf(Vec(pWay, UInt(halfBlockBits.W)))(w%pWay)) 457 } 458 // first data code 459 read_code_bits(0) := Mux(isDoubleLineReg, 460 codeArrays(1).io.r.resp.asTypeOf(Vec(nWays, UInt(codeBits.W))), 461 codeArrays(0).io.r.resp.asTypeOf(Vec(nWays, UInt(codeBits.W)))) 462 // second data code 463 read_code_bits(1) := Mux(isDoubleLineReg, 464 codeArrays(0).io.r.resp.asTypeOf(Vec(nWays, UInt(codeBits.W))), 465 codeArrays(1).io.r.resp.asTypeOf(Vec(nWays, UInt(codeBits.W)))) 466 467 if (ICacheECCForceError) { 468 read_code_bits.foreach(_.foreach(_ := 0.U)) // force ecc to fail 469 } 470 471 /** 472 ****************************************************************************** 473 * IO 474 ****************************************************************************** 475 */ 476 io.readResp.datas := read_data_bits 477 io.readResp.codes := read_code_bits 478 io.write.ready := true.B 479 io.read.ready := !io.write.valid && 480 dataArrays.map(_.map(_.io.r.req.ready).reduce(_&&_)).reduce(_&&_) && 481 codeArrays.map(_.io.r.req.ready).reduce(_&&_) 482} 483 484 485class ICacheIO(implicit p: Parameters) extends ICacheBundle 486{ 487 val hartId = Input(UInt(hartIdLen.W)) 488 val prefetch = Flipped(new FtqPrefechBundle) 489 val stop = Input(Bool()) 490 val fetch = new ICacheMainPipeBundle 491 val toIFU = Output(Bool()) 492 val pmp = Vec(PortNumber + prefetchPipeNum, new ICachePMPBundle) 493 val itlb = Vec(PortNumber + prefetchPipeNum, new TlbRequestIO) 494 val perfInfo = Output(new ICachePerfInfo) 495 val error = ValidIO(new L1CacheErrorInfo) 496 /* Cache Instruction */ 497 val csr = new L1CacheToCsrIO 498 /* CSR control signal */ 499 val csr_pf_enable = Input(Bool()) 500 val csr_parity_enable = Input(Bool()) 501 val fencei = Input(Bool()) 502} 503 504class ICache()(implicit p: Parameters) extends LazyModule with HasICacheParameters { 505 override def shouldBeInlined: Boolean = false 506 507 val clientParameters = TLMasterPortParameters.v1( 508 Seq(TLMasterParameters.v1( 509 name = "icache", 510 sourceId = IdRange(0, cacheParams.nMissEntries + 1), 511 )), 512 requestFields = cacheParams.reqFields, 513 echoFields = cacheParams.echoFields 514 ) 515 516 val clientNode = TLClientNode(Seq(clientParameters)) 517 518 lazy val module = new ICacheImp(this) 519} 520 521class ICacheImp(outer: ICache) extends LazyModuleImp(outer) with HasICacheParameters with HasPerfEvents { 522 val io = IO(new ICacheIO) 523 524 println("ICache:") 525 println(" ICacheSets: " + cacheParams.nSets) 526 println(" ICacheWays: " + cacheParams.nWays) 527 println(" ICacheBanks: " + PortNumber) 528 529 println(" enableICachePrefetch: " + cacheParams.enableICachePrefetch) 530 println(" prefetchToL1: " + cacheParams.prefetchToL1) 531 println(" prefetchPipeNum: " + cacheParams.prefetchPipeNum) 532 println(" nPrefetchEntries: " + cacheParams.nPrefetchEntries) 533 println(" nPrefBufferEntries: " + cacheParams.nPrefBufferEntries) 534 println(" maxIPFMoveConf: " + cacheParams.maxIPFMoveConf) 535 536 val (bus, edge) = outer.clientNode.out.head 537 538 val metaArray = Module(new ICacheMetaArray) 539 val dataArray = Module(new ICacheDataArray) 540 val prefetchMetaArray = Module(new ICacheMetaArrayNoBanked) 541 val mainPipe = Module(new ICacheMainPipe) 542 val missUnit = Module(new ICacheMissUnit(edge)) 543 val fdipPrefetch = Module(new FDIPPrefetch(edge)) 544 545 fdipPrefetch.io.hartId := io.hartId 546 fdipPrefetch.io.fencei := io.fencei 547 fdipPrefetch.io.ftqReq <> io.prefetch 548 fdipPrefetch.io.metaReadReq <> prefetchMetaArray.io.read 549 fdipPrefetch.io.metaReadResp <> prefetchMetaArray.io.readResp 550 fdipPrefetch.io.ICacheMissUnitInfo <> missUnit.io.ICacheMissUnitInfo 551 fdipPrefetch.io.ICacheMainPipeInfo <> mainPipe.io.ICacheMainPipeInfo 552 fdipPrefetch.io.IPFBufferRead <> mainPipe.io.IPFBufferRead 553 fdipPrefetch.io.IPFReplacer <> mainPipe.io.IPFReplacer 554 fdipPrefetch.io.PIQRead <> mainPipe.io.PIQRead 555 fdipPrefetch.io.metaWrite <> DontCare 556 fdipPrefetch.io.dataWrite <> DontCare 557 558 // Meta Array. Priority: missUnit > fdipPrefetch 559 if (prefetchToL1) { 560 val meta_write_arb = Module(new Arbiter(new ICacheMetaWriteBundle(), 2)) 561 meta_write_arb.io.in(0) <> missUnit.io.meta_write 562 meta_write_arb.io.in(1) <> fdipPrefetch.io.metaWrite 563 meta_write_arb.io.out <> metaArray.io.write 564 // prefetch Meta Array. Connect meta_write_arb to ensure the data is same as metaArray 565 prefetchMetaArray.io.write <> meta_write_arb.io.out 566 } else { 567 missUnit.io.meta_write <> metaArray.io.write 568 missUnit.io.meta_write <> prefetchMetaArray.io.write 569 // ensure together wirte to metaArray and prefetchMetaArray 570 missUnit.io.meta_write.ready := metaArray.io.write.ready && prefetchMetaArray.io.write.ready 571 } 572 573 // Data Array. Priority: missUnit > fdipPrefetch 574 if (prefetchToL1) { 575 val data_write_arb = Module(new Arbiter(new ICacheDataWriteBundle(), 2)) 576 data_write_arb.io.in(0) <> missUnit.io.data_write 577 data_write_arb.io.in(1) <> fdipPrefetch.io.dataWrite 578 data_write_arb.io.out <> dataArray.io.write 579 } else { 580 missUnit.io.data_write <> dataArray.io.write 581 } 582 583 mainPipe.io.dataArray.toIData <> dataArray.io.read 584 mainPipe.io.dataArray.fromIData <> dataArray.io.readResp 585 mainPipe.io.metaArray.toIMeta <> metaArray.io.read 586 mainPipe.io.metaArray.fromIMeta <> metaArray.io.readResp 587 mainPipe.io.metaArray.fromIMeta <> metaArray.io.readResp 588 mainPipe.io.respStall := io.stop 589 mainPipe.io.csr_parity_enable := io.csr_parity_enable 590 mainPipe.io.hartId := io.hartId 591 592 io.pmp(0) <> mainPipe.io.pmp(0) 593 io.pmp(1) <> mainPipe.io.pmp(1) 594 io.pmp(2) <> fdipPrefetch.io.pmp 595 596 io.itlb(0) <> mainPipe.io.itlb(0) 597 io.itlb(1) <> mainPipe.io.itlb(1) 598 io.itlb(2) <> fdipPrefetch.io.iTLBInter 599 600 //notify IFU that Icache pipeline is available 601 io.toIFU := mainPipe.io.fetch.req.ready 602 io.perfInfo := mainPipe.io.perfInfo 603 604 io.fetch.resp <> mainPipe.io.fetch.resp 605 io.fetch.topdownIcacheMiss := mainPipe.io.fetch.topdownIcacheMiss 606 io.fetch.topdownItlbMiss := mainPipe.io.fetch.topdownItlbMiss 607 608 for(i <- 0 until PortNumber){ 609 missUnit.io.req(i) <> mainPipe.io.mshr(i).toMSHR 610 mainPipe.io.mshr(i).fromMSHR <> missUnit.io.resp(i) 611 } 612 613 missUnit.io.hartId := io.hartId 614 missUnit.io.fencei := io.fencei 615 missUnit.io.fdip_acquire <> fdipPrefetch.io.mem_acquire 616 missUnit.io.fdip_grant <> fdipPrefetch.io.mem_grant 617 618 bus.b.ready := false.B 619 bus.c.valid := false.B 620 bus.c.bits := DontCare 621 bus.e.valid := false.B 622 bus.e.bits := DontCare 623 624 bus.a <> missUnit.io.mem_acquire 625 626 // connect bus d 627 missUnit.io.mem_grant.valid := false.B 628 missUnit.io.mem_grant.bits := DontCare 629 630 //Parity error port 631 val errors = mainPipe.io.errors 632 io.error.bits <> RegEnable(Mux1H(errors.map(e => e.valid -> e.bits)),errors.map(e => e.valid).reduce(_|_)) 633 io.error.valid := RegNext(errors.map(e => e.valid).reduce(_|_),init = false.B) 634 635 636 mainPipe.io.fetch.req <> io.fetch.req 637 bus.d.ready := false.B 638 missUnit.io.mem_grant <> bus.d 639 640 // fencei connect 641 metaArray.io.fencei := io.fencei 642 prefetchMetaArray.io.fencei := io.fencei 643 644 val perfEvents = Seq( 645 ("icache_miss_cnt ", false.B), 646 ("icache_miss_penalty", BoolStopWatch(start = false.B, stop = false.B || false.B, startHighPriority = true)), 647 ) 648 generatePerfEvent() 649 650 // Customized csr cache op support 651 val cacheOpDecoder = Module(new CSRCacheOpDecoder("icache", CacheInstrucion.COP_ID_ICACHE)) 652 cacheOpDecoder.io.csr <> io.csr 653 dataArray.io.cacheOp.req := cacheOpDecoder.io.cache.req 654 metaArray.io.cacheOp.req := cacheOpDecoder.io.cache.req 655 prefetchMetaArray.io.cacheOp.req := cacheOpDecoder.io.cache.req 656 cacheOpDecoder.io.cache.resp.valid := 657 dataArray.io.cacheOp.resp.valid || 658 metaArray.io.cacheOp.resp.valid 659 cacheOpDecoder.io.cache.resp.bits := Mux1H(List( 660 dataArray.io.cacheOp.resp.valid -> dataArray.io.cacheOp.resp.bits, 661 metaArray.io.cacheOp.resp.valid -> metaArray.io.cacheOp.resp.bits, 662 )) 663 cacheOpDecoder.io.error := io.error 664 assert(!((dataArray.io.cacheOp.resp.valid +& metaArray.io.cacheOp.resp.valid) > 1.U)) 665} 666 667class ICachePartWayReadBundle[T <: Data](gen: T, pWay: Int)(implicit p: Parameters) 668 extends ICacheBundle 669{ 670 val req = Flipped(Vec(PortNumber, Decoupled(new Bundle{ 671 val ridx = UInt((log2Ceil(nSets) - 1).W) 672 }))) 673 val resp = Output(new Bundle{ 674 val rdata = Vec(PortNumber,Vec(pWay, gen)) 675 }) 676} 677 678class ICacheWriteBundle[T <: Data](gen: T, pWay: Int)(implicit p: Parameters) 679 extends ICacheBundle 680{ 681 val wdata = gen 682 val widx = UInt((log2Ceil(nSets) - 1).W) 683 val wbankidx = Bool() 684 val wmask = Vec(pWay, Bool()) 685} 686 687class ICachePartWayArray[T <: Data](gen: T, pWay: Int)(implicit p: Parameters) extends ICacheArray 688{ 689 690 //including part way data 691 val io = IO{new Bundle { 692 val read = new ICachePartWayReadBundle(gen,pWay) 693 val write = Flipped(ValidIO(new ICacheWriteBundle(gen, pWay))) 694 }} 695 696 io.read.req.map(_.ready := !io.write.valid) 697 698 val srams = (0 until PortNumber) map { bank => 699 val sramBank = Module(new SRAMTemplate( 700 gen, 701 set=nSets/2, 702 way=pWay, 703 shouldReset = true, 704 holdRead = true, 705 singlePort = true 706 )) 707 708 sramBank.io.r.req.valid := io.read.req(bank).valid 709 sramBank.io.r.req.bits.apply(setIdx= io.read.req(bank).bits.ridx) 710 711 if(bank == 0) sramBank.io.w.req.valid := io.write.valid && !io.write.bits.wbankidx 712 else sramBank.io.w.req.valid := io.write.valid && io.write.bits.wbankidx 713 sramBank.io.w.req.bits.apply(data=io.write.bits.wdata, setIdx=io.write.bits.widx, waymask=io.write.bits.wmask.asUInt) 714 715 sramBank 716 } 717 718 io.read.req.map(_.ready := !io.write.valid && srams.map(_.io.r.req.ready).reduce(_&&_)) 719 720 io.read.resp.rdata := VecInit(srams.map(bank => bank.io.r.resp.asTypeOf(Vec(pWay,gen)))) 721 722} 723