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.mem 18 19import org.chipsalliance.cde.config.Parameters 20import chisel3._ 21import chisel3.util._ 22import utils._ 23import utility._ 24import xiangshan._ 25import xiangshan.backend.rob.RobPtr 26import xiangshan.backend.Bundles._ 27import xiangshan.mem._ 28import xiangshan.backend.fu.vector.Bundles._ 29 30 31class VSplitPipeline(isVStore: Boolean = false)(implicit p: Parameters) extends VLSUModule{ 32 val io = IO(new VSplitPipelineIO(isVStore)) 33 // will be override later 34 def us_whole_reg(fuOpType: UInt): Bool = false.B 35 def us_mask(fuOpType: UInt): Bool = false.B 36 def us_fof(fuOpType: UInt): Bool = false.B 37 //TODO vdIdxReg should no longer be useful, don't delete it for now 38 val vdIdxReg = RegInit(0.U(3.W)) 39 40 val s1_ready = WireInit(false.B) 41 io.in.ready := s1_ready 42 43 /**----------------------------------------------------------- 44 * s0 stage 45 * decode and generate AlignedType, uop mask, preIsSplit 46 * ---------------------------------------------------------- 47 */ 48 val s0_vtype = io.in.bits.uop.vpu.vtype 49 val s0_sew = s0_vtype.vsew 50 val s0_eew = io.in.bits.uop.vpu.veew 51 val s0_lmul = s0_vtype.vlmul 52 // when load whole register or unit-stride masked , emul should be 1 53 val s0_fuOpType = io.in.bits.uop.fuOpType 54 val s0_mop = s0_fuOpType(6, 5) 55 val s0_nf = Mux(us_whole_reg(s0_fuOpType), 0.U, io.in.bits.uop.vpu.nf) 56 val s0_vm = io.in.bits.uop.vpu.vm 57 val s0_emul = Mux(us_whole_reg(s0_fuOpType) ,GenUSWholeEmul(io.in.bits.uop.vpu.nf), Mux(us_mask(s0_fuOpType), 0.U(mulBits.W), EewLog2(s0_eew) - s0_sew + s0_lmul)) 58 val s0_preIsSplit = !(isUnitStride(s0_mop) && !us_fof(s0_fuOpType)) 59 val s0_nfield = s0_nf +& 1.U 60 61 val s0_valid = Wire(Bool()) 62 val s0_kill = io.in.bits.uop.robIdx.needFlush(io.redirect) 63 val s0_can_go = s1_ready 64 val s0_fire = s0_valid && s0_can_go 65 val s0_out = Wire(new VLSBundle(isVStore)) 66 67 val isUsWholeReg = isUnitStride(s0_mop) && us_whole_reg(s0_fuOpType) 68 val isMaskReg = isUnitStride(s0_mop) && us_mask(s0_fuOpType) 69 val isSegment = s0_nf =/= 0.U && !us_whole_reg(s0_fuOpType) 70 val instType = Cat(isSegment, s0_mop) 71 val uopIdx = io.in.bits.uop.vpu.vuopIdx 72 val uopIdxInField = GenUopIdxInField(instType, s0_emul, s0_lmul, uopIdx) 73 val vdIdxInField = GenVdIdxInField(instType, s0_emul, s0_lmul, uopIdxInField) 74 val lmulLog2 = Mux(s0_lmul.asSInt >= 0.S, 0.U, s0_lmul) 75 val emulLog2 = Mux(s0_emul.asSInt >= 0.S, 0.U, s0_emul) 76 val numEewLog2 = emulLog2 - EewLog2(s0_eew) 77 val numSewLog2 = lmulLog2 - s0_sew 78 val numFlowsSameVdLog2 = Mux( 79 isIndexed(instType), 80 log2Up(VLENB).U - s0_sew(1,0), 81 log2Up(VLENB).U - s0_eew(1,0) 82 ) 83 // numUops = nf * max(lmul, emul) 84 val lmulLog2Pos = Mux(s0_lmul.asSInt < 0.S, 0.U, s0_lmul) 85 val emulLog2Pos = Mux(s0_emul.asSInt < 0.S, 0.U, s0_emul) 86 val numUops = Mux( 87 isIndexed(s0_mop) && s0_lmul.asSInt > s0_emul.asSInt, 88 (s0_nf +& 1.U) << lmulLog2Pos, 89 (s0_nf +& 1.U) << emulLog2Pos 90 ) 91 92 val vvl = io.in.bits.src_vl.asTypeOf(VConfig()).vl 93 val evl = Mux(isUsWholeReg, 94 GenUSWholeRegVL(io.in.bits.uop.vpu.nf +& 1.U, s0_eew), 95 Mux(isMaskReg, 96 GenUSMaskRegVL(vvl), 97 vvl)) 98 val vvstart = io.in.bits.uop.vpu.vstart 99 val alignedType = Mux(isIndexed(instType), s0_sew(1, 0), s0_eew(1, 0)) 100 val broadenAligendType = Mux(s0_preIsSplit, Cat("b0".U, alignedType), "b100".U) // if is unit-stride, use 128-bits memory access 101 val flowsLog2 = GenRealFlowLog2(instType, s0_emul, s0_lmul, s0_eew, s0_sew) 102 val flowsPrevThisUop = (uopIdxInField << flowsLog2).asUInt // # of flows before this uop in a field 103 val flowsPrevThisVd = (vdIdxInField << numFlowsSameVdLog2).asUInt // # of flows before this vd in a field 104 val flowsIncludeThisUop = ((uopIdxInField +& 1.U) << flowsLog2).asUInt // # of flows before this uop besides this uop 105 val flowNum = io.in.bits.flowNum.get 106 107 // For vectore indexed instructions: 108 // When emul is greater than lmul, multiple uop correspond to a Vd, e.g: 109 // vsetvli t1,t0,e8,m1,ta,ma lmul = 1 110 // vluxei16.v v2,(a0),v8 emul = 2 111 // In this case, we need to ensure the flownumis right shift by flowsPrevThisUop, However, the mask passed to mergebuff is right shift by flowsPrevThisVd e.g: 112 // vl = 9 113 // srcMask = 0x1FF 114 // uopIdxInField = 0 and vdIdxInField = 0, flowMask = 0x00FF, toMergeBuffMask = 0x01FF 115 // uopIdxInField = 1 and vdIdxInField = 0, flowMask = 0x0001, toMergeBuffMask = 0x01FF 116 // uopIdxInField = 0 and vdIdxInField = 0, flowMask = 0x0000, toMergeBuffMask = 0x0000 117 // uopIdxInField = 0 and vdIdxInField = 0, flowMask = 0x0000, toMergeBuffMask = 0x0000 118 val isSpecialIndexed = isIndexed(instType) && s0_emul.asSInt > s0_lmul.asSInt 119 120 val srcMask = GenFlowMask(Mux(s0_vm, Fill(VLEN, 1.U(1.W)), io.in.bits.src_mask), vvstart, evl, true) 121 val srcMaskShiftBits = Mux(isSpecialIndexed, flowsPrevThisUop, flowsPrevThisVd) 122 123 val flowMask = ((srcMask & 124 UIntToMask(flowsIncludeThisUop.asUInt, VLEN + 1) & 125 (~UIntToMask(flowsPrevThisUop.asUInt, VLEN)).asUInt 126 ) >> srcMaskShiftBits)(VLENB - 1, 0) 127 val indexedSrcMask = (srcMask >> flowsPrevThisVd).asUInt //only for index instructions 128 129 // Used to calculate the element index. 130 // See 'splitbuffer' for 'io.out.splitIdxOffset' and 'mergebuffer' for 'merge data' 131 val indexedSplitOffset = Mux(isSpecialIndexed, flowsPrevThisUop - flowsPrevThisVd, 0.U) // only for index instructions of emul > lmul 132 val vlmax = GenVLMAX(s0_lmul, s0_sew) 133 134 // connect 135 s0_out := DontCare 136 s0_out match {case x => 137 x.uop := io.in.bits.uop 138 x.uop.vpu.vl := evl 139 x.uop.uopIdx := uopIdx 140 x.uop.numUops := numUops 141 x.uop.lastUop := (uopIdx +& 1.U) === numUops 142 x.uop.vpu.nf := s0_nf 143 x.flowMask := flowMask 144 x.indexedSrcMask := indexedSrcMask // Only vector indexed instructions uses it 145 x.indexedSplitOffset := indexedSplitOffset 146 x.byteMask := GenUopByteMask(flowMask, Cat("b0".U, alignedType))(VLENB - 1, 0) 147 x.fof := isUnitStride(s0_mop) && us_fof(s0_fuOpType) 148 x.baseAddr := io.in.bits.src_rs1 149 x.stride := io.in.bits.src_stride 150 x.flowNum := flowNum 151 x.nfields := s0_nfield 152 x.vm := s0_vm 153 x.usWholeReg := isUsWholeReg 154 x.usMaskReg := isMaskReg 155 x.eew := s0_eew 156 x.sew := s0_sew 157 x.emul := s0_emul 158 x.lmul := s0_lmul 159 x.vlmax := Mux(isUsWholeReg, evl, vlmax) 160 x.instType := instType 161 x.data := io.in.bits.src_vs3 162 x.vdIdxInField := vdIdxInField 163 x.preIsSplit := s0_preIsSplit 164 x.alignedType := broadenAligendType 165 } 166 s0_valid := io.in.valid && !s0_kill 167 /**------------------------------------- 168 * s1 stage 169 * ------------------------------------ 170 * generate UopOffset 171 */ 172 val s1_valid = RegInit(false.B) 173 val s1_kill = Wire(Bool()) 174 val s1_in = Wire(new VLSBundle(isVStore)) 175 val s1_can_go = io.out.ready && io.toMergeBuffer.resp.valid 176 val s1_fire = s1_valid && !s1_kill && s1_can_go 177 178 s1_ready := s1_kill || !s1_valid || io.out.ready && io.toMergeBuffer.resp.valid 179 180 when(s0_fire){ 181 s1_valid := true.B 182 }.elsewhen(s1_fire){ 183 s1_valid := false.B 184 }.elsewhen(s1_kill){ 185 s1_valid := false.B 186 } 187 s1_in := RegEnable(s0_out, s0_fire) 188 189 val s1_flowNum = s1_in.flowNum 190 val s1_uopidx = s1_in.uop.vpu.vuopIdx 191 val s1_nf = s1_in.uop.vpu.nf 192 val s1_nfields = s1_in.nfields 193 val s1_eew = s1_in.eew 194 val s1_emul = s1_in.emul 195 val s1_lmul = s1_in.lmul 196 val s1_instType = s1_in.instType 197 val s1_stride = s1_in.stride 198 val s1_vmask = FillInterleaved(8, s1_in.byteMask)(VLEN-1, 0) 199 val s1_alignedType = s1_in.alignedType 200 val s1_isSpecialIndexed = isIndexed(s1_instType) && s1_emul.asSInt > s1_lmul.asSInt 201 val s1_mask = Mux(s1_isSpecialIndexed, s1_in.indexedSrcMask, s1_in.flowMask) 202 val s1_vdIdx = s1_in.vdIdxInField 203 val s1_fof = s1_in.fof 204 val s1_notIndexedStride = Mux( // stride for strided/unit-stride instruction 205 isStrided(s1_instType), 206 s1_stride(XLEN - 1, 0), // for strided load, stride = x[rs2] 207 s1_nfields << s1_eew(1, 0) // for unit-stride load, stride = eew * NFIELDS 208 ) 209 210 val stride = Mux(isIndexed(s1_instType), s1_stride, s1_notIndexedStride).asUInt // if is index instructions, get index when split 211 val uopOffset = genVUopOffset(s1_instType, s1_fof, s1_uopidx, s1_nf, s1_eew(1, 0), stride, s1_alignedType) 212 213 s1_kill := s1_in.uop.robIdx.needFlush(io.redirect) 214 215 // query mergeBuffer 216 io.toMergeBuffer.req.valid := s1_fire // only can_go will get MergeBuffer entry 217 io.toMergeBuffer.req.bits.flowNum := Mux(s1_in.preIsSplit, PopCount(s1_in.flowMask), s1_flowNum) 218 io.toMergeBuffer.req.bits.data := s1_in.data 219 io.toMergeBuffer.req.bits.uop := s1_in.uop 220 io.toMergeBuffer.req.bits.mask := s1_mask 221 io.toMergeBuffer.req.bits.vaddr := DontCare 222 io.toMergeBuffer.req.bits.vdIdx := s1_vdIdx //TODO vdIdxReg should no longer be useful, don't delete it for now 223 io.toMergeBuffer.req.bits.fof := s1_in.fof 224 io.toMergeBuffer.req.bits.vlmax := s1_in.vlmax 225// io.toMergeBuffer.req.bits.vdOffset := 226 227 //TODO vdIdxReg should no longer be useful, don't delete it for now 228// when (s1_in.uop.lastUop && s1_fire || s1_kill) { 229// vdIdxReg := 0.U 230// }.elsewhen(s1_fire) { 231// vdIdxReg := vdIdxReg + 1.U 232// XSError(vdIdxReg + 1.U === 0.U, s"Overflow! The number of vd should be less than 8\n") 233// } 234 // out connect 235 io.out.valid := s1_valid && io.toMergeBuffer.resp.valid 236 io.out.bits := s1_in 237 io.out.bits.uopOffset := uopOffset 238 io.out.bits.stride := stride 239 io.out.bits.mBIndex := io.toMergeBuffer.resp.bits.mBIndex 240 241 XSPerfAccumulate("split_out", io.out.fire) 242 XSPerfAccumulate("pipe_block", io.out.valid && !io.out.ready) 243 XSPerfAccumulate("mbuffer_block", s1_valid && io.out.ready && !io.toMergeBuffer.resp.valid) 244} 245 246abstract class VSplitBuffer(isVStore: Boolean = false)(implicit p: Parameters) extends VLSUModule{ 247 val io = IO(new VSplitBufferIO(isVStore)) 248 249 val bufferSize: Int 250 private val freeWidth = Seq(io.out).length 251 private val allocWidth = Seq(io.in).length 252 253 // freelist 254 val freeList = Module(new FreeList( 255 size = bufferSize, 256 allocWidth = allocWidth, 257 freeWidth = freeWidth, 258 enablePreAlloc = false, 259 moduleName = "VSplit Buffer freelist" 260 )) 261 262 val uopq = Reg(Vec(bufferSize, new VLSBundle(isVStore))) 263 val allocated = RegInit(VecInit(Seq.fill(bufferSize)(false.B))) 264 val allocatedWire = WireInit(VecInit(Seq.fill(bufferSize)(false.B))) // for back to back split, advance lower 265 val freeMask = WireInit(VecInit(Seq.fill(bufferSize)(false.B))) 266 val needCancel = WireInit(VecInit(Seq.fill(bufferSize)(false.B))) 267 val activeIssue = Wire(Bool()) 268 val inActiveIssue = Wire(Bool()) 269 270 // for split 271 val splitIdx = RegInit(0.U(flowIdxBits.W)) 272 val strideOffsetReg = RegInit(0.U(VLEN.W)) 273 274 /** 275 * Redirect 276 */ 277 val cancelEnq = io.in.bits.uop.robIdx.needFlush(io.redirect) 278 val canEnqueue = io.in.valid 279 val needEnqueue = canEnqueue && !cancelEnq 280 281 // enqueue 282 freeList.io.doAllocate.head := false.B 283 freeList.io.allocateReq.head := true.B 284 val offset = PopCount(needEnqueue) 285 val canAccept = freeList.io.canAllocate(offset) 286 val enqIndex = freeList.io.allocateSlot(offset) 287 io.in.ready := canAccept 288 val doEnqueue = canAccept && needEnqueue 289 290 when(doEnqueue){ 291 freeList.io.doAllocate.head := true.B 292 uopq(enqIndex) := io.in.bits 293 } 294 freeList.io.free := freeMask.asUInt 295 296 // select one uop 297 val selPolicy = SelectOne("circ", allocatedWire, freeWidth) // select one entry to split 298 val (selValid, selOHVec) = selPolicy.getNthOH(1) 299 val entryIdx = OHToUInt(selOHVec) 300 301 /* latch selentry, wait split or redirect*/ 302 val splitFinish = WireInit(false.B) 303 val selValidReg = RegInit(false.B) 304 val selIdxReg = Reg(UInt(entryIdx.getWidth.W)) 305 306 // 0 -> 1 307 when(selValid && !selValidReg){ 308 selValidReg := true.B 309 } 310 // 1 -> 0 311 when((uopq(selIdxReg).uop.robIdx.needFlush(io.redirect) || !selValid && splitFinish && (activeIssue || inActiveIssue)) && 312 selValidReg){ 313 314 selValidReg := false.B 315 } 316 // have new uop need to split and last uop is split finish 317 when((selValid && !selValidReg) || 318 (selValid && selValidReg && splitFinish && (activeIssue || inActiveIssue))){ 319 320 selIdxReg := entryIdx 321 } 322 323 //split uops 324 val issueValid = allocated(selIdxReg) && selValidReg 325 val issueEntry = uopq(selIdxReg) 326 val issueMbIndex = issueEntry.mBIndex 327 val issueFlowNum = issueEntry.flowNum 328 val issueBaseAddr = issueEntry.baseAddr 329 val issueUop = issueEntry.uop 330 val issueUopIdx = issueUop.vpu.vuopIdx 331 val issueInstType = issueEntry.instType 332 val issueUopOffset = issueEntry.uopOffset 333 val issueEew = issueEntry.eew 334 val issueSew = issueEntry.sew 335 val issueLmul = issueEntry.lmul 336 val issueEmul = issueEntry.emul 337 val issueAlignedType = issueEntry.alignedType 338 val issuePreIsSplit = issueEntry.preIsSplit 339 val issueByteMask = issueEntry.byteMask 340 val issueVLMAXMask = issueEntry.vlmax - 1.U 341 val issueIsWholeReg = issueEntry.usWholeReg 342 val issueVLMAXLog2 = GenVLMAXLog2(issueEntry.lmul, issueSew) 343 val elemIdx = GenElemIdx( 344 instType = issueInstType, 345 emul = issueEmul, 346 lmul = issueLmul, 347 eew = issueEew, 348 sew = issueSew, 349 uopIdx = issueUopIdx, 350 flowIdx = splitIdx 351 ) // elemIdx inside an inst, for exception 352 353 val splitIdxOffset = issueEntry.indexedSplitOffset + splitIdx 354 355 val elemIdxInsideField = elemIdx & issueVLMAXMask 356 val indexFlowInnerIdx = ((elemIdxInsideField << issueEew(1, 0))(vOffsetBits - 1, 0) >> issueEew(1, 0)).asUInt 357 val nfIdx = Mux(issueIsWholeReg, 0.U, elemIdx >> issueVLMAXLog2) 358 val fieldOffset = nfIdx << issueAlignedType // field offset inside a segment 359 360 val indexedStride = IndexAddr( // index for indexed instruction 361 index = issueEntry.stride, 362 flow_inner_idx = indexFlowInnerIdx, 363 eew = issueEew 364 ) 365 val issueStride = Mux(isIndexed(issueInstType), indexedStride, strideOffsetReg) 366 val vaddr = issueBaseAddr + issueUopOffset + issueStride 367 val mask = genVWmask128(vaddr ,issueAlignedType) // scala maske for flow 368 val flowMask = issueEntry.flowMask 369 val vecActive = (flowMask & UIntToOH(splitIdx)).orR 370 /* 371 * Unit-Stride split to one flow or two flow. 372 * for Unit-Stride, if uop's addr is aligned with 128-bits, split it to one flow, otherwise split two 373 */ 374 375 val usAligned128 = (vaddr(3,0) === 0.U)// addr 128-bit aligned 376 val usSplitMask = genUSSplitMask(issueByteMask, splitIdx, vaddr(3,0)) 377 val usNoSplit = (usAligned128 || !(vaddr(3,0) +& PopCount(usSplitMask))(4)) && !issuePreIsSplit && (splitIdx === 0.U)// unit-stride uop don't need to split into two flow 378 val usSplitVaddr = genUSSplitAddr(vaddr, splitIdx) 379 val regOffset = vaddr(3,0) // offset in 256-bits vd 380 XSError((splitIdx > 1.U && usNoSplit) || (splitIdx > 1.U && !issuePreIsSplit) , "Unit-Stride addr split error!\n") 381 382 // data 383 io.out.bits match { case x => 384 x.uop := issueUop 385 x.vaddr := Mux(!issuePreIsSplit, usSplitVaddr, vaddr) 386 x.alignedType := issueAlignedType 387 x.isvec := true.B 388 x.mask := Mux(!issuePreIsSplit, usSplitMask, mask) 389 x.reg_offset := regOffset //for merge unit-stride data 390 x.vecActive := vecActive 391 x.is_first_ele := DontCare 392 x.usSecondInv := usNoSplit 393 x.elemIdx := elemIdx 394 x.elemIdxInsideVd := splitIdxOffset // if is Unit-Stride, elemIdx is the index of 2 splited mem request (for merge data) 395 x.uop_unit_stride_fof := DontCare 396 x.isFirstIssue := DontCare 397 x.mBIndex := issueMbIndex 398 } 399 400 // redirect 401 for (i <- 0 until bufferSize){ 402 needCancel(i) := uopq(i).uop.robIdx.needFlush(io.redirect) && allocated(i) 403 } 404 405 /* Execute logic */ 406 /** Issue to scala pipeline**/ 407 val allowIssue = io.out.ready 408 val issueCount = Mux(usNoSplit, 2.U, (PopCount(inActiveIssue) + PopCount(activeIssue))) // for dont need split unit-stride, issue two flow 409 splitFinish := splitIdx >= (issueFlowNum - issueCount) 410 411 // handshake 412 activeIssue := issueValid && allowIssue && (vecActive || !issuePreIsSplit) // active issue, current use in no unit-stride 413 inActiveIssue := issueValid && !vecActive && issuePreIsSplit 414 when (!issueEntry.uop.robIdx.needFlush(io.redirect)) { 415 when (!splitFinish) { 416 when (activeIssue || inActiveIssue) { 417 // The uop has not been entirly splited yet 418 splitIdx := splitIdx + issueCount 419 strideOffsetReg := Mux(!issuePreIsSplit, strideOffsetReg, strideOffsetReg + issueEntry.stride) // when normal unit-stride, don't use strideOffsetReg 420 } 421 }.otherwise { 422 when (activeIssue || inActiveIssue) { 423 // The uop is done spliting 424 splitIdx := 0.U(flowIdxBits.W) // initialize flowIdx 425 strideOffsetReg := 0.U 426 } 427 } 428 }.otherwise { 429 splitIdx := 0.U(flowIdxBits.W) // initialize flowIdx 430 strideOffsetReg := 0.U 431 } 432 // allocatedWire, only for freelist select next uop back-to-back 433 for (i <- 0 until bufferSize){ 434 when(needCancel(i)){ // redirect 435 allocatedWire(i) := false.B 436 }.elsewhen(splitFinish && (activeIssue || inActiveIssue) && (i.U === selIdxReg)){ // finish 437 allocatedWire(i) := false.B 438 }.otherwise{ 439 allocatedWire(i) := allocated(i) 440 } 441 } 442 // allocated 443 for (i <- 0 until bufferSize){ 444 when(needCancel(i)) { // redirect 445 allocated(i) := false.B 446 }.elsewhen(splitFinish && (activeIssue || inActiveIssue) && (i.U === selIdxReg)){ //dequeue 447 allocated(i) := false.B 448 }.elsewhen(doEnqueue && (i.U === enqIndex)){ 449 allocated(i) := true.B 450 } 451 } 452 // freeMask 453 for (i <- 0 until bufferSize){ 454 when(needCancel(i)) { // redirect 455 freeMask(i) := true.B 456 }.elsewhen(splitFinish && (activeIssue || inActiveIssue) && (i.U === selIdxReg)) { //dequeue 457 freeMask(i) := true.B 458 }.otherwise{ 459 freeMask(i) := false.B 460 } 461 } 462 463 // out connect 464 io.out.valid := issueValid && (vecActive || !issuePreIsSplit) // TODO: inactive unit-stride uop do not send to pipeline 465 466 XSError(!allocated(entryIdx) && selValid, "select invalid entry!") 467 468 XSPerfAccumulate("out_valid", io.out.valid) 469 XSPerfAccumulate("out_fire", io.out.fire) 470 XSPerfAccumulate("out_fire_unitstride", io.out.fire && !issuePreIsSplit) 471 XSPerfAccumulate("unitstride_vlenAlign", io.out.fire && !issuePreIsSplit && io.out.bits.vaddr(3, 0) === 0.U) 472 XSPerfAccumulate("unitstride_invalid", io.out.ready && issueValid && !issuePreIsSplit && PopCount(io.out.bits.mask).orR) 473 474 QueuePerf(bufferSize, freeList.io.validCount, freeList.io.validCount === 0.U) 475} 476 477class VSSplitBufferImp(implicit p: Parameters) extends VSplitBuffer(isVStore = true){ 478 override lazy val bufferSize = SplitBufferSize 479 // split data 480 val splitData = genVSData( 481 data = issueEntry.data.asUInt, 482 elemIdx = splitIdxOffset, 483 alignedType = issueAlignedType 484 ) 485 val flowData = genVWdata(splitData, issueAlignedType) 486 val usSplitData = genUSSplitData(issueEntry.data.asUInt, splitIdx, vaddr(3,0)) 487 488 val sqIdx = issueUop.sqIdx + splitIdx 489 io.out.bits.uop.sqIdx := sqIdx 490 491 // send data to sq 492 val vstd = io.vstd.get 493 vstd.valid := issueValid 494 vstd.bits.uop := issueUop 495 vstd.bits.uop.sqIdx := sqIdx 496 vstd.bits.data := Mux(!issuePreIsSplit, usSplitData, flowData) 497 vstd.bits.debug := DontCare 498 vstd.bits.vdIdx.get := DontCare 499 vstd.bits.vdIdxInField.get := DontCare 500 vstd.bits.mask.get := Mux(!issuePreIsSplit, usSplitMask, mask) 501 502} 503 504class VLSplitBufferImp(implicit p: Parameters) extends VSplitBuffer(isVStore = false){ 505 override lazy val bufferSize = SplitBufferSize 506 io.out.bits.uop.lqIdx := issueUop.lqIdx + splitIdx 507} 508 509class VSSplitPipelineImp(implicit p: Parameters) extends VSplitPipeline(isVStore = true){ 510 override def us_whole_reg(fuOpType: UInt): Bool = fuOpType === VstuType.vsr 511 override def us_mask(fuOpType: UInt): Bool = fuOpType === VstuType.vsm 512 override def us_fof(fuOpType: UInt): Bool = false.B // dont have vector fof store 513} 514 515class VLSplitPipelineImp(implicit p: Parameters) extends VSplitPipeline(isVStore = false){ 516 517 override def us_whole_reg(fuOpType: UInt): Bool = fuOpType === VlduType.vlr 518 override def us_mask(fuOpType: UInt): Bool = fuOpType === VlduType.vlm 519 override def us_fof(fuOpType: UInt): Bool = fuOpType === VlduType.vleff 520} 521 522class VLSplitImp(implicit p: Parameters) extends VLSUModule{ 523 val io = IO(new VSplitIO(isVStore=false)) 524 val splitPipeline = Module(new VLSplitPipelineImp()) 525 val splitBuffer = Module(new VLSplitBufferImp()) 526 // Split Pipeline 527 splitPipeline.io.in <> io.in 528 splitPipeline.io.redirect <> io.redirect 529 io.toMergeBuffer <> splitPipeline.io.toMergeBuffer 530 531 // Split Buffer 532 splitBuffer.io.in <> splitPipeline.io.out 533 splitBuffer.io.redirect <> io.redirect 534 io.out <> splitBuffer.io.out 535} 536 537class VSSplitImp(implicit p: Parameters) extends VLSUModule{ 538 val io = IO(new VSplitIO(isVStore=true)) 539 val splitPipeline = Module(new VSSplitPipelineImp()) 540 val splitBuffer = Module(new VSSplitBufferImp()) 541 // Split Pipeline 542 splitPipeline.io.in <> io.in 543 splitPipeline.io.redirect <> io.redirect 544 io.toMergeBuffer <> splitPipeline.io.toMergeBuffer 545 546 // Split Buffer 547 splitBuffer.io.in <> splitPipeline.io.out 548 splitBuffer.io.redirect <> io.redirect 549 io.out <> splitBuffer.io.out 550 io.vstd.get <> splitBuffer.io.vstd.get 551} 552 553