From 59320121c6dcb95ae7be8173796e62fe3c00c756 Mon Sep 17 00:00:00 2001 From: leekillough <15950023+leekillough@users.noreply.github.com> Date: Mon, 27 Nov 2023 20:41:38 -0600 Subject: [PATCH 1/6] preliminary, to be merged --- common/include/RevCommon.h | 46 ++++++++++++++----------- include/RevInstHelpers.h | 70 ++++++++++++++++++-------------------- include/RevProc.h | 12 +++---- include/insns/RV32A.h | 46 +++++++++++-------------- include/insns/RV64A.h | 6 ++-- src/RevCPU.cc | 4 ++- src/RevExt.cc | 3 +- src/RevFeature.cc | 3 +- src/RevLoader.cc | 4 ++- src/RevMem.cc | 12 ++++--- src/RevMemCtrl.cc | 8 ++--- src/RevOpts.cc | 3 +- src/RevPrefetcher.cc | 16 +++++---- src/RevSysCalls.cc | 24 +++++++------ src/RevTracer.cc | 4 ++- 15 files changed, 137 insertions(+), 124 deletions(-) diff --git a/common/include/RevCommon.h b/common/include/RevCommon.h index deeea7c8c..690464345 100644 --- a/common/include/RevCommon.h +++ b/common/include/RevCommon.h @@ -85,42 +85,50 @@ enum class MemOp : uint8_t { std::ostream& operator<<(std::ostream& os, MemOp op); -inline uint64_t make_lsq_hash(uint16_t destReg, RevRegClass regType, unsigned HartID){ - return static_cast(regType) << (16 + 8) | static_cast(destReg) << 16 | HartID; -}; +constexpr uint64_t LSQHash(RevReg DestReg, RevRegClass RegType, unsigned Hart){ + return static_cast(RegType) << (16 + 8) | static_cast(DestReg) << 16 | Hart; +} struct MemReq{ MemReq() = default; MemReq(const MemReq&) = default; + MemReq(MemReq&&) = default; MemReq& operator=(const MemReq&) = default; + MemReq& operator=(MemReq&&) = default; ~MemReq() = default; - MemReq(uint64_t addr, uint16_t dest, RevRegClass regclass, - unsigned hart, MemOp req, bool outstanding, std::function func) : - Addr(addr), DestReg(dest), RegType(regclass), Hart(hart), - ReqType(req), isOutstanding(outstanding), MarkLoadComplete(std::move(func)) - { + MemReq(uint64_t Addr, + RevReg DestReg, + RevRegClass RegType, + unsigned Hart, + MemOp ReqType, + bool isOutstanding, + std::function MarkLoadCompleteFunc) : + Addr(Addr), + DestReg(DestReg), + RegType(RegType), + Hart(Hart), + ReqType(ReqType), + isOutstanding(isOutstanding), + MarkLoadCompleteFunc(std::move(MarkLoadCompleteFunc)){} + + void MarkLoadComplete() const { + MarkLoadCompleteFunc(*this); } - void Set(uint64_t addr, uint16_t dest, RevRegClass regclass, unsigned hart, - MemOp req, bool outstanding, std::function func) - { - Addr = addr; DestReg = dest; RegType = regclass; Hart = hart; - ReqType = req; isOutstanding = outstanding; MarkLoadComplete = std::move(func); + auto LSQHashPair() const { + return std::make_pair( LSQHash(DestReg, RegType, Hart), *this ); } +private: uint64_t Addr = _INVALID_ADDR_; - uint16_t DestReg = 0; + RevReg DestReg = RevReg::zero; RevRegClass RegType = RevRegClass::RegUNKNOWN; unsigned Hart = _REV_INVALID_HART_ID_; MemOp ReqType = MemOp::MemOpCUSTOM; bool isOutstanding = false; - std::function MarkLoadComplete = nullptr; - - //std::shared_ptr> LSQueue; - // std::function) SetComplete; - // add lambda that clears the dependency bit directly so we don't need to search the hash + std::function MarkLoadCompleteFunc = nullptr; };//struct MemReq // Enum for tracking the state of a RevThread. diff --git a/include/RevInstHelpers.h b/include/RevInstHelpers.h index fd34c85a1..4fb62cbd0 100644 --- a/include/RevInstHelpers.h +++ b/include/RevInstHelpers.h @@ -66,22 +66,21 @@ unsigned fclass(T val, bool quietNaN = true) { /// Load template template bool load(RevFeature *F, RevRegFile *R, RevMem *M, RevInst Inst) { - MemReq req{}; if( sizeof(T) < sizeof(int64_t) && R->IsRV32 ){ static constexpr RevFlag flags = sizeof(T) < sizeof(int32_t) ? std::is_signed_v ? RevFlag::F_SEXT32 : RevFlag::F_ZEXT32 : RevFlag::F_NONE; uint64_t rs1 = R->GetX(Inst.rs1); // read once for tracer - req.Set(rs1 + Inst.ImmSignExt(12), - Inst.rd, RevRegClass::RegGPR, - F->GetHartToExecID(), - MemOp::MemOpREAD, - true, - R->GetMarkLoadComplete()); - R->LSQueue->insert({make_lsq_hash(Inst.rd, RevRegClass::RegGPR, F->GetHartToExecID()), req}); + MemReq req(rs1 + Inst.ImmSignExt(12), + Inst.rd, RevRegClass::RegGPR, + F->GetHartToExecID(), + MemOp::MemOpREAD, + true, + R->GetMarkLoadComplete()); + R->LSQueue->insert(req.LSQHashPair()); M->ReadVal(F->GetHartToExecID(), rs1 + Inst.ImmSignExt(12), reinterpret_cast*>(&R->RV32[Inst.rd]), - req, + std::move(req), flags); R->SetX(Inst.rd, static_cast(R->RV32[Inst.rd])); @@ -89,17 +88,17 @@ bool load(RevFeature *F, RevRegFile *R, RevMem *M, RevInst Inst) { static constexpr RevFlag flags = sizeof(T) < sizeof(int64_t) ? std::is_signed_v ? RevFlag::F_SEXT64 : RevFlag::F_ZEXT64 : RevFlag::F_NONE; uint64_t rs1 = R->GetX(Inst.rs1); - req.Set(rs1 + Inst.ImmSignExt(12), - Inst.rd, RevRegClass::RegGPR, - F->GetHartToExecID(), - MemOp::MemOpREAD, - true, - R->GetMarkLoadComplete()); - R->LSQueue->insert({make_lsq_hash(Inst.rd, RevRegClass::RegGPR, F->GetHartToExecID()), req}); + MemReq req(rs1 + Inst.ImmSignExt(12), + Inst.rd, RevRegClass::RegGPR, + F->GetHartToExecID(), + MemOp::MemOpREAD, + true, + R->GetMarkLoadComplete()); + R->LSQueue->insert(req.LSQHashPair()); M->ReadVal(F->GetHartToExecID(), rs1 + Inst.ImmSignExt(12), reinterpret_cast*>(&R->RV64[Inst.rd]), - req, + std::move(req), flags); R->SetX(Inst.rd, static_cast(R->RV64[Inst.rd])); //std::cout << "RMT: Load Issued for address: " << std::hex << req.Addr << " Data: " << static_cast(R->RV64[Inst.rd]) << std::dec << " Dest Reg: " << req.DestReg << std::endl; @@ -125,24 +124,23 @@ bool store(RevFeature *F, RevRegFile *R, RevMem *M, RevInst Inst) { /// Floating-point load template template bool fload(RevFeature *F, RevRegFile *R, RevMem *M, RevInst Inst) { - MemReq req{}; if(std::is_same_v || F->HasD()){ static constexpr RevFlag flags = sizeof(T) < sizeof(double) ? RevFlag::F_BOXNAN : RevFlag::F_NONE; uint64_t rs1 = R->GetX(Inst.rs1); - req.Set(rs1 + Inst.ImmSignExt(12), - Inst.rd, - RevRegClass::RegFLOAT, - F->GetHartToExecID(), - MemOp::MemOpREAD, - true, - R->GetMarkLoadComplete()); - R->LSQueue->insert({make_lsq_hash(Inst.rd, RevRegClass::RegFLOAT, F->GetHartToExecID()), req}); + MemReq req(rs1 + Inst.ImmSignExt(12), + Inst.rd, + RevRegClass::RegFLOAT, + F->GetHartToExecID(), + MemOp::MemOpREAD, + true, + R->GetMarkLoadComplete()); + R->LSQueue->insert(req.LSQHashPair()); M->ReadVal(F->GetHartToExecID(), rs1 + Inst.ImmSignExt(12), reinterpret_cast(&R->DPF[Inst.rd]), - req, + std::move(req), flags); // Box float value into 64-bit FP register @@ -153,18 +151,18 @@ bool fload(RevFeature *F, RevRegFile *R, RevMem *M, RevInst Inst) { } }else{ uint64_t rs1 = R->GetX(Inst.rs1); - req.Set(rs1 + Inst.ImmSignExt(12), - Inst.rd, - RevRegClass::RegFLOAT, - F->GetHartToExecID(), - MemOp::MemOpREAD, - true, - R->GetMarkLoadComplete()); - R->LSQueue->insert({make_lsq_hash(Inst.rd, RevRegClass::RegFLOAT, F->GetHartToExecID()), req}); + MemReq req(rs1 + Inst.ImmSignExt(12), + Inst.rd, + RevRegClass::RegFLOAT, + F->GetHartToExecID(), + MemOp::MemOpREAD, + true, + R->GetMarkLoadComplete()); + R->LSQueue->insert(req.LSQHashPair()); M->ReadVal(F->GetHartToExecID(), rs1 + Inst.ImmSignExt(12), &R->SPF[Inst.rd], - req, + std::move(req), RevFlag::F_NONE); } // update the cost diff --git a/include/RevProc.h b/include/RevProc.h index 43e04ebc8..5829eb5d3 100644 --- a/include/RevProc.h +++ b/include/RevProc.h @@ -758,22 +758,20 @@ class RevProc{ } /// RevProc: Set or clear scoreboard based on register number and floating point. - void DependencySet(unsigned HartID, uint16_t RegNum, - bool isFloat, bool value = true){ - if( RegNum < _REV_NUM_REGS_ || RegNum != 0 ){ return; } + void DependencySet(unsigned HartID, RevReg RegNum, bool isFloat, bool value = true){ + if( size_t(RegNum) < _REV_NUM_REGS_ || RegNum != RevReg::zero ){ return; } RevRegFile* regFile = GetRegFile(HartID); if(isFloat){ - regFile->FP_Scoreboard[RegNum] = value; + regFile->FP_Scoreboard[size_t(RegNum)] = value; } else{ - regFile->RV_Scoreboard[RegNum] = value; + regFile->RV_Scoreboard[size_t(RegNum)] = value; } return; } - /// RevProc: Clear scoreboard on instruction retirement - void DependencyClear(unsigned HartID, uint16_t RegNum, bool isFloat){ + void DependencyClear(unsigned HartID, RevReg RegNum, bool isFloat){ DependencySet(HartID, RegNum, isFloat, false); } diff --git a/include/insns/RV32A.h b/include/insns/RV32A.h index 88fd94cd7..b144748d1 100644 --- a/include/insns/RV32A.h +++ b/include/insns/RV32A.h @@ -21,17 +21,16 @@ namespace SST::RevCPU{ class RV32A : public RevExt { static bool lrw(RevFeature *F, RevRegFile *R, RevMem *M, RevInst Inst) { - MemReq req; if( R->IsRV32 ){ - req.Set(uint64_t(R->RV32[Inst.rs1]), Inst.rd, RevRegClass::RegGPR, F->GetHartToExecID(), MemOp::MemOpAMO, true, R->GetMarkLoadComplete()); - R->LSQueue->insert({make_lsq_hash(req.DestReg, req.RegType, req.Hart), req}); + MemReq req(uint64_t(R->RV32[Inst.rs1]), Inst.rd, RevRegClass::RegGPR, F->GetHartToExecID(), MemOp::MemOpAMO, true, R->GetMarkLoadComplete()); + R->LSQueue->insert( req.LSQHashPair() ); M->LR(F->GetHartToExecID(), uint64_t(R->RV32[Inst.rs1]), &R->RV32[Inst.rd], Inst.aq, Inst.rl, req, RevFlag::F_SEXT32); }else{ - req.Set(R->RV64[Inst.rs1], Inst.rd, RevRegClass::RegGPR, F->GetHartToExecID(), MemOp::MemOpAMO, true, R->GetMarkLoadComplete()); - R->LSQueue->insert({make_lsq_hash(req.DestReg, req.RegType, req.Hart), req}); + MemReq req(R->RV64[Inst.rs1], Inst.rd, RevRegClass::RegGPR, F->GetHartToExecID(), MemOp::MemOpAMO, true, R->GetMarkLoadComplete()); + R->LSQueue->insert( req.LSQHashPair() ); M->LR(F->GetHartToExecID(), R->RV64[Inst.rs1], reinterpret_cast(&R->RV64[Inst.rd]), Inst.aq, Inst.rl, req, @@ -72,18 +71,15 @@ class RV32A : public RevExt { flags |= uint32_t(RevFlag::F_RL); } - MemReq req; if( R->IsRV32 ){ - req.Set(R->RV32[Inst.rs1], - Inst.rd, - RevRegClass::RegGPR, - F->GetHartToExecID(), - MemOp::MemOpAMO, - true, - R->GetMarkLoadComplete()); - R->LSQueue->insert({make_lsq_hash(Inst.rd, - RevRegClass::RegGPR, - F->GetHartToExecID()), req}); + MemReq req(R->RV32[Inst.rs1], + Inst.rd, + RevRegClass::RegGPR, + F->GetHartToExecID(), + MemOp::MemOpAMO, + true, + R->GetMarkLoadComplete()); + R->LSQueue->insert( req.LSQHashPair() ); M->AMOVal(F->GetHartToExecID(), R->RV32[Inst.rs1], &R->RV32[Inst.rs2], @@ -92,16 +88,14 @@ class RV32A : public RevExt { RevFlag{flags}); }else{ flags |= uint32_t(RevFlag::F_SEXT64); - req.Set(R->RV64[Inst.rs1], - Inst.rd, - RevRegClass::RegGPR, - F->GetHartToExecID(), - MemOp::MemOpAMO, - true, - R->GetMarkLoadComplete()); - R->LSQueue->insert({make_lsq_hash(Inst.rd, - RevRegClass::RegGPR, - F->GetHartToExecID()), req}); + MemReq req(R->RV64[Inst.rs1], + Inst.rd, + RevRegClass::RegGPR, + F->GetHartToExecID(), + MemOp::MemOpAMO, + true, + R->GetMarkLoadComplete()); + R->LSQueue->insert( req.LSQHashPair() ); M->AMOVal(F->GetHartToExecID(), R->RV64[Inst.rs1], reinterpret_cast(&R->RV64[Inst.rs2]), diff --git a/include/insns/RV64A.h b/include/insns/RV64A.h index 9b6be9a35..b5b69aac0 100644 --- a/include/insns/RV64A.h +++ b/include/insns/RV64A.h @@ -22,7 +22,7 @@ class RV64A : public RevExt { static bool lrd(RevFeature *F, RevRegFile *R, RevMem *M, RevInst Inst) { MemReq req(R->RV64[Inst.rs1], Inst.rd, RevRegClass::RegGPR, F->GetHartToExecID(), MemOp::MemOpAMO, true, R->GetMarkLoadComplete() ); - R->LSQueue->insert({make_lsq_hash(req.DestReg, req.RegType, req.Hart), req}); + R->LSQueue->insert( req.LSQHashPair() ); M->LR(F->GetHartToExecID(), R->RV64[Inst.rs1], &R->RV64[Inst.rd], @@ -63,9 +63,7 @@ class RV64A : public RevExt { MemOp::MemOpAMO, true, R->GetMarkLoadComplete()); - R->LSQueue->insert({make_lsq_hash(Inst.rd, - RevRegClass::RegGPR, - F->GetHartToExecID()), req}); + R->LSQueue->insert( req.LSQHashPair() ); M->AMOVal(F->GetHartToExecID(), R->RV64[Inst.rs1], &R->RV64[Inst.rs2], diff --git a/src/RevCPU.cc b/src/RevCPU.cc index 3e6d7c108..924127a99 100644 --- a/src/RevCPU.cc +++ b/src/RevCPU.cc @@ -14,7 +14,8 @@ #include #include -using namespace SST::RevCPU; +namespace SST::RevCPU{ + using MemSegment = RevMem::MemSegment; const char splash_msg[] = "\ @@ -846,4 +847,5 @@ void RevCPU::InitMainThread(uint32_t MainThreadID, const uint64_t StartAddr){ ReadyThreads.emplace_back(std::move(MainThread)); } +} // namespace SST::RevCPU // EOF diff --git a/src/RevExt.cc b/src/RevExt.cc index a153525ea..59730361b 100644 --- a/src/RevExt.cc +++ b/src/RevExt.cc @@ -9,7 +9,7 @@ // #include "RevExt.h" -using namespace SST::RevCPU; +namespace SST::RevCPU{ /// Change the FP environment auto RevExt::SetFPEnv(unsigned Inst, const RevInst& payload, uint16_t HartID, RevRegFile* regFile){ @@ -82,4 +82,5 @@ bool RevExt::Execute(unsigned Inst, const RevInst& payload, uint16_t HartID, Rev return ret; } +} // namespace SST::RevCPU // EOF diff --git a/src/RevFeature.cc b/src/RevFeature.cc index 04aa37a4d..3b28c93a0 100644 --- a/src/RevFeature.cc +++ b/src/RevFeature.cc @@ -13,7 +13,7 @@ #include #include -using namespace SST::RevCPU; +namespace SST::RevCPU{ RevFeature::RevFeature( std::string Machine, SST::Output *Output, @@ -101,4 +101,5 @@ bool RevFeature::ParseMachineModel(){ return false; } +} // namespace SST::RevCPU // EOF diff --git a/src/RevLoader.cc b/src/RevLoader.cc index bd34dcd93..9b791032a 100644 --- a/src/RevLoader.cc +++ b/src/RevLoader.cc @@ -11,7 +11,8 @@ #include "RevLoader.h" #include "RevMem.h" -using namespace SST::RevCPU; +namespace SST::RevCPU{ + using MemSegment = RevMem::MemSegment; RevLoader::RevLoader( std::string Exe, std::string Args, @@ -648,4 +649,5 @@ std::map *SST::RevCPU::RevLoader::GetTraceSymbols() return &tracer_symbols; } +} // namespace SST::RevCPU // EOF diff --git a/src/RevMem.cc b/src/RevMem.cc index 794822707..684396a64 100644 --- a/src/RevMem.cc +++ b/src/RevMem.cc @@ -17,7 +17,8 @@ #include #include -using namespace SST::RevCPU; +namespace SST::RevCPU{ + using MemSegment = RevMem::MemSegment; RevMem::RevMem( uint64_t MemSize, RevOpts *Opts, RevMemCtrl *Ctrl, SST::Output *Output ) @@ -147,7 +148,7 @@ bool RevMem::LRBase(unsigned Hart, uint64_t Addr, size_t Len, }else{ memcpy(DataMem, BaseMem, Len); // clear the hazard - req.MarkLoadComplete(req); + req.MarkLoadComplete(); } return true; @@ -582,7 +583,7 @@ bool RevMem::AMOMem(unsigned Hart, uint64_t Addr, size_t Len, } // clear the hazard - req.MarkLoadComplete(req); + req.MarkLoadComplete(); delete[] TmpD; delete[] TmpT; } @@ -833,7 +834,7 @@ bool RevMem::ReadMem(unsigned Hart, uint64_t Addr, size_t Len, void *Target, } // clear the hazard - if this was an AMO operation then we will clear outside of this function in AMOMem() if(MemOp::MemOpAMO != req.ReqType){ - req.MarkLoadComplete(req); + req.MarkLoadComplete(); } } #ifdef _REV_DEBUG_ @@ -848,7 +849,7 @@ bool RevMem::ReadMem(unsigned Hart, uint64_t Addr, size_t Len, void *Target, } // clear the hazard- if this was an AMO operation then we will clear outside of this function in AMOMem() if(MemOp::MemOpAMO != req.ReqType){ - req.MarkLoadComplete(req); + req.MarkLoadComplete(); } TRACE_MEM_READ(Addr, Len, DataMem); } @@ -1003,4 +1004,5 @@ uint64_t RevMem::ExpandHeap(uint64_t Size){ return heapend; } +} // namespace SST::RevCPU // EOF diff --git a/src/RevMemCtrl.cc b/src/RevMemCtrl.cc index 95d108bb4..6723ed829 100644 --- a/src/RevMemCtrl.cc +++ b/src/RevMemCtrl.cc @@ -1315,7 +1315,7 @@ void RevBasicMemCtrl::handleReadResp(StandardMem::ReadResp* ev){ } const MemReq& r = op->getMemReq(); if( !isAMO ){ - r.MarkLoadComplete(r); + r.MarkLoadComplete(); } delete op; } @@ -1339,7 +1339,7 @@ void RevBasicMemCtrl::handleReadResp(StandardMem::ReadResp* ev){ const MemReq& r = op->getMemReq(); if( !isAMO ){ - r.MarkLoadComplete(r); + r.MarkLoadComplete(); } delete op; outstanding.erase(ev->getID()); @@ -1469,7 +1469,7 @@ void RevBasicMemCtrl::handleWriteResp(StandardMem::WriteResp* ev){ // this was the last request to service, delete the op const MemReq& r = op->getMemReq(); if( isAMO ){ - r.MarkLoadComplete(r); + r.MarkLoadComplete(); } delete op; } @@ -1485,7 +1485,7 @@ void RevBasicMemCtrl::handleWriteResp(StandardMem::WriteResp* ev){ if( isAMO ){ // write the target std::vector tempT = op->getTempT(); - r.MarkLoadComplete(r); + r.MarkLoadComplete(); } delete op; outstanding.erase(ev->getID()); diff --git a/src/RevOpts.cc b/src/RevOpts.cc index 9d9af536c..77cf5deea 100644 --- a/src/RevOpts.cc +++ b/src/RevOpts.cc @@ -9,7 +9,7 @@ // #include "RevOpts.h" -using namespace SST::RevCPU; +namespace SST::RevCPU{ RevOpts::RevOpts( unsigned NumCores, unsigned NumHarts, const int Verbosity ) : numCores(NumCores), numHarts(NumHarts), verbosity(Verbosity) { @@ -273,4 +273,5 @@ bool RevOpts::GetMemCost( unsigned Core, unsigned &Min, unsigned &Max ){ return true; } +} // namespace SST::RevCPU // EOF diff --git a/src/RevPrefetcher.cc b/src/RevPrefetcher.cc index a197851f4..21d34e238 100644 --- a/src/RevPrefetcher.cc +++ b/src/RevPrefetcher.cc @@ -9,7 +9,8 @@ // #include "RevPrefetcher.h" -using namespace SST::RevCPU; + +namespace SST::RevCPU{ /*RevPrefetcher::~RevPrefetcher(){ // delete all the existing streams @@ -169,12 +170,14 @@ void RevPrefetcher::Fill(uint64_t Addr){ // now fill it for( size_t y=0; yGetHartToExecID(), MemOp::MemOpREAD, true, MarkLoadAsComplete); - LSQueue->insert({make_lsq_hash(0, RevRegClass::RegGPR, feature->GetHartToExecID()), req}); + MemReq req( Addr+(y*4), RevReg::zero, RevRegClass::RegGPR, + feature->GetHartToExecID(), MemOp::MemOpREAD, true, + MarkLoadAsComplete ); + LSQueue->insert( req.LSQHashPair() ); mem->ReadVal( feature->GetHartToExecID(), Addr+(y*4), - &iStack[x][y], - req, - RevFlag::F_NONE ); + &iStack[x][y], + req, + RevFlag::F_NONE ); } } @@ -186,4 +189,5 @@ void RevPrefetcher::DeleteStream(size_t i){ } } +} // namespace SST::RevCPU // EOF diff --git a/src/RevSysCalls.cc b/src/RevSysCalls.cc index 13e40d6c7..de2751dae 100644 --- a/src/RevSysCalls.cc +++ b/src/RevSysCalls.cc @@ -6,7 +6,7 @@ #include #include -using namespace SST::RevCPU; +namespace SST::RevCPU{ /// Parse a string for an ECALL starting at address straddr, updating the state /// as characters are read, and call action() when the end of string is reached. @@ -16,7 +16,7 @@ EcallStatus RevProc::EcallLoadAndParseString(RevInst& inst, auto rtval = EcallStatus::ERROR; auto& EcallState = Harts.at(HartToExecID)->GetEcallState(); - if( RegFile->GetLSQueue()->count(make_lsq_hash(10, RevRegClass::RegGPR, HartToExecID)) > 0 ){ + if( RegFile->GetLSQueue()->count(LSQHash(RevReg::a0, RevRegClass::RegGPR, HartToExecID)) > 0 ){ rtval = EcallStatus::CONTINUE; } else { // we don't know how long the path string is so read a byte (char) @@ -39,21 +39,21 @@ EcallStatus RevProc::EcallLoadAndParseString(RevInst& inst, EcallState.string.clear(); //reset the ECALL buffers EcallState.bytesRead = 0; - DependencyClear(HartToExecID, 10, false); + DependencyClear(HartToExecID, RevReg::a0, false); rtval = EcallStatus::SUCCESS; }else{ //We are in the middle of the string - read one byte - MemReq req{straddr + EcallState.string.size(), 10, + MemReq req{straddr + EcallState.string.size(), RevReg::a0, RevRegClass::RegGPR, HartToExecID, MemOp::MemOpREAD, true, [=](const MemReq& req){this->MarkLoadComplete(req);}}; - LSQueue->insert({make_lsq_hash(req.DestReg, req.RegType, req.Hart), req}); + LSQueue->insert(req.LSQHashPair()); mem->ReadVal(HartToExecID, straddr + EcallState.string.size(), EcallState.buf.data(), req, RevFlag::F_NONE); EcallState.bytesRead = 1; - DependencySet(HartToExecID, 10, false); + DependencySet(HartToExecID, RevReg::a0, false); rtval = EcallStatus::CONTINUE; } } @@ -739,7 +739,7 @@ EcallStatus RevProc::ECALL_write(RevInst& inst){ auto addr = RegFile->GetX(RevReg::a1); auto nbytes = RegFile->GetX(RevReg::a2); - auto lsq_hash = make_lsq_hash(10, RevRegClass::RegGPR, HartToExecID); // Cached hash value + auto lsq_hash = LSQHash(RevReg::a0, RevRegClass::RegGPR, HartToExecID); // Cached hash value if(EcallState.bytesRead && LSQueue->count(lsq_hash) == 0){ EcallState.string += std::string_view(EcallState.buf.data(), EcallState.bytesRead); @@ -751,14 +751,14 @@ EcallStatus RevProc::ECALL_write(RevInst& inst){ int rc = write(fd, EcallState.string.data(), EcallState.string.size()); RegFile->SetX(RevReg::a0, rc); EcallState.clear(); - DependencyClear(HartToExecID, 10, false); + DependencyClear(HartToExecID, RevReg::a0, false); return EcallStatus::SUCCESS; } if (LSQueue->count(lsq_hash) == 0) { - MemReq req (addr + EcallState.string.size(), 10, RevRegClass::RegGPR, + MemReq req (addr + EcallState.string.size(), RevReg::a0, RevRegClass::RegGPR, HartToExecID, MemOp::MemOpREAD, true, RegFile->GetMarkLoadComplete()); - LSQueue->insert({lsq_hash, req}); + LSQueue->insert(req.LSQHashPair()); if(nleft >= 8){ mem->ReadVal(HartToExecID, addr+EcallState.string.size(), @@ -782,7 +782,7 @@ EcallStatus RevProc::ECALL_write(RevInst& inst){ EcallState.bytesRead = 1; } - DependencySet(HartToExecID, 10, false); + DependencySet(HartToExecID, RevReg::a0, false); return EcallStatus::CONTINUE; } @@ -3201,3 +3201,5 @@ EcallStatus RevProc::ECALL_pthread_join(RevInst& inst){ } return rtval; } + +} // namespace SST::RevCPU diff --git a/src/RevTracer.cc b/src/RevTracer.cc index 176e85ac4..5ce05030f 100644 --- a/src/RevTracer.cc +++ b/src/RevTracer.cc @@ -15,7 +15,7 @@ #include "RevTracer.h" -using namespace SST::RevCPU; +namespace SST::RevCPU{ RevTracer::RevTracer(std::string Name, SST::Output *o): name(Name), pOutput(o) { @@ -332,3 +332,5 @@ void RevTracer::fmt_data(unsigned len, uint64_t d, std::stringstream &s) s << std::setw(len * 2) << (d & mask); } } + +} // namespace SST::RevCPU From 1f80291516abb4da82c99818d90a23a1ad78c76b Mon Sep 17 00:00:00 2001 From: leekillough <15950023+leekillough@users.noreply.github.com> Date: Mon, 27 Nov 2023 21:23:19 -0600 Subject: [PATCH 2/6] fix builds --- common/include/RevCommon.h | 20 +++++++++++++++----- include/RevProc.h | 18 ++++++++++-------- src/RevPrefetcher.cc | 2 +- src/RevProc.cc | 13 ++++++++----- 4 files changed, 34 insertions(+), 19 deletions(-) diff --git a/common/include/RevCommon.h b/common/include/RevCommon.h index 690464345..b566409cc 100644 --- a/common/include/RevCommon.h +++ b/common/include/RevCommon.h @@ -85,7 +85,8 @@ enum class MemOp : uint8_t { std::ostream& operator<<(std::ostream& os, MemOp op); -constexpr uint64_t LSQHash(RevReg DestReg, RevRegClass RegType, unsigned Hart){ +template +constexpr uint64_t LSQHash(T DestReg, RevRegClass RegType, unsigned Hart){ return static_cast(RegType) << (16 + 8) | static_cast(DestReg) << 16 | Hart; } @@ -97,15 +98,16 @@ struct MemReq{ MemReq& operator=(MemReq&&) = default; ~MemReq() = default; + template MemReq(uint64_t Addr, - RevReg DestReg, + T DestReg, RevRegClass RegType, unsigned Hart, MemOp ReqType, bool isOutstanding, std::function MarkLoadCompleteFunc) : Addr(Addr), - DestReg(DestReg), + DestReg(uint16_t(DestReg)), RegType(RegType), Hart(Hart), ReqType(ReqType), @@ -116,19 +118,27 @@ struct MemReq{ MarkLoadCompleteFunc(*this); } + auto LSQHash() const { + return SST::RevCPU::LSQHash(DestReg, RegType, Hart); + } + auto LSQHashPair() const { - return std::make_pair( LSQHash(DestReg, RegType, Hart), *this ); + return std::make_pair( LSQHash(), *this ); } private: uint64_t Addr = _INVALID_ADDR_; - RevReg DestReg = RevReg::zero; + uint16_t DestReg = 0; RevRegClass RegType = RevRegClass::RegUNKNOWN; unsigned Hart = _REV_INVALID_HART_ID_; MemOp ReqType = MemOp::MemOpCUSTOM; bool isOutstanding = false; std::function MarkLoadCompleteFunc = nullptr; + + friend class RevTracer; + friend class RevMem; + friend class RevProc; };//struct MemReq // Enum for tracking the state of a RevThread. diff --git a/include/RevProc.h b/include/RevProc.h index a2dcc071e..d36af93af 100644 --- a/include/RevProc.h +++ b/include/RevProc.h @@ -746,7 +746,7 @@ class RevProc{ bool LSQCheck(unsigned HartID, const RevRegFile* regFile, uint16_t reg, RevRegClass regClass) const { return (reg != 0 || regClass != RevRegClass::RegGPR) && - regFile->GetLSQueue()->count(make_lsq_hash(reg, regClass, HartID)) > 0; + regFile->GetLSQueue()->count(LSQHash(reg, regClass, HartID)) > 0; } /// RevProc: Check scoreboard for a source register dependency @@ -780,21 +780,23 @@ class RevProc{ } /// RevProc: Set or clear scoreboard based on register number and floating point. - void DependencySet(unsigned HartID, uint16_t RegNum, + template + void DependencySet(unsigned HartID, T RegNum, bool isFloat, bool value = true){ - if( RegNum < _REV_NUM_REGS_ ){ + if( size_t(RegNum) < _REV_NUM_REGS_ ){ RevRegFile* regFile = GetRegFile(HartID); if(isFloat){ - regFile->FP_Scoreboard[RegNum] = value; - }else if( RegNum != 0 ){ - regFile->RV_Scoreboard[RegNum] = value; + regFile->FP_Scoreboard[size_t(RegNum)] = value; + }else if( size_t(RegNum) != 0 ){ + regFile->RV_Scoreboard[size_t(RegNum)] = value; } } } /// RevProc: Clear scoreboard on instruction retirement - void DependencyClear(unsigned HartID, RevReg RegNum, bool isFloat){ - DependencySet(HartID, RegNum, isFloat, false); + template + void DependencyClear(unsigned HartID, T RegNum, bool isFloat){ + DependencySet(HartID, uint16_t(RegNum), isFloat, false); } }; // class RevProc diff --git a/src/RevPrefetcher.cc b/src/RevPrefetcher.cc index 21d34e238..9f028f09e 100644 --- a/src/RevPrefetcher.cc +++ b/src/RevPrefetcher.cc @@ -170,7 +170,7 @@ void RevPrefetcher::Fill(uint64_t Addr){ // now fill it for( size_t y=0; yGetHartToExecID(), MemOp::MemOpREAD, true, MarkLoadAsComplete ); LSQueue->insert( req.LSQHashPair() ); diff --git a/src/RevProc.cc b/src/RevProc.cc index 962bce8e9..1eb8749b3 100644 --- a/src/RevProc.cc +++ b/src/RevProc.cc @@ -1638,7 +1638,7 @@ unsigned RevProc::GetNextHartToDecodeID() const { void RevProc::MarkLoadComplete(const MemReq& req){ - auto it = LSQueue->find(make_lsq_hash(req.DestReg, req.RegType, req.Hart)); + auto it = LSQueue->find(req.LSQHash()); if( it != LSQueue->end()){ DependencyClear(it->second.Hart, it->second.DestReg, (it->second.RegType == RevRegClass::RegFLOAT)); LSQueue->erase(it); @@ -1871,9 +1871,9 @@ bool RevProc::ClockTick( SST::Cycle_t currentCycle ){ Retired++; // Only clear the dependency if there is no outstanding load - if((RegFile->GetLSQueue()->count(make_lsq_hash(Pipeline.front().second.rd, - InstTable[Pipeline.front().second.entry].rdClass, - HartID))) == 0){ + if((RegFile->GetLSQueue()->count(LSQHash(Pipeline.front().second.rd, + InstTable[Pipeline.front().second.entry].rdClass, + HartID))) == 0){ DependencyClear(HartID, &(Pipeline.front().second)); } Pipeline.pop_front(); @@ -1908,10 +1908,13 @@ bool RevProc::ClockTick( SST::Cycle_t currentCycle ){ AddThreadsThatChangedState(std::move(ActiveThread)); } } - #ifndef REV_TRACER + + #ifndef NO_REV_TRACER // Dump trace state if (Tracer) Tracer->Render(currentCycle); #endif + + return rtn; } std::unique_ptr RevProc::PopThreadFromHart(unsigned HartID){ From f4a23b26135432bea08f348d1c7b64f55ba0a390 Mon Sep 17 00:00:00 2001 From: leekillough <15950023+leekillough@users.noreply.github.com> Date: Wed, 29 Nov 2023 16:54:27 -0600 Subject: [PATCH 3/6] clean up register number usage --- include/RevPrefetcher.h | 1 + include/RevProc.h | 2 +- include/RevRegFile.h | 2 +- src/RevPrefetcher.cc | 2 +- 4 files changed, 4 insertions(+), 3 deletions(-) diff --git a/include/RevPrefetcher.h b/include/RevPrefetcher.h index 668e1ebab..96ee16bef 100644 --- a/include/RevPrefetcher.h +++ b/include/RevPrefetcher.h @@ -19,6 +19,7 @@ #include "RevMem.h" #include "RevFeature.h" +#include "RevRegFile.h" namespace SST::RevCPU{ diff --git a/include/RevProc.h b/include/RevProc.h index d36af93af..9414ff51e 100644 --- a/include/RevProc.h +++ b/include/RevProc.h @@ -796,7 +796,7 @@ class RevProc{ /// RevProc: Clear scoreboard on instruction retirement template void DependencyClear(unsigned HartID, T RegNum, bool isFloat){ - DependencySet(HartID, uint16_t(RegNum), isFloat, false); + DependencySet(HartID, RegNum, isFloat, false); } }; // class RevProc diff --git a/include/RevRegFile.h b/include/RevRegFile.h index 793347844..8a257af21 100644 --- a/include/RevRegFile.h +++ b/include/RevRegFile.h @@ -40,7 +40,7 @@ inline void BoxNaN(double* dest, const void* value){ } /// RISC-V Register Mneumonics -enum class RevReg { +enum class RevReg : uint16_t { zero = 0, ra = 1, sp = 2, gp = 3, tp = 4, t0 = 5, t1 = 6, t2 = 7, s0 = 8, s1 = 9, a0 = 10, a1 = 11, a2 = 12, a3 = 13, a4 = 14, a5 = 15, a6 = 16, a7 = 17, s2 = 18, s3 = 19, s4 = 20, s5 = 21, s6 = 22, s7 = 23, diff --git a/src/RevPrefetcher.cc b/src/RevPrefetcher.cc index 9f028f09e..21d34e238 100644 --- a/src/RevPrefetcher.cc +++ b/src/RevPrefetcher.cc @@ -170,7 +170,7 @@ void RevPrefetcher::Fill(uint64_t Addr){ // now fill it for( size_t y=0; yGetHartToExecID(), MemOp::MemOpREAD, true, MarkLoadAsComplete ); LSQueue->insert( req.LSQHashPair() ); From d555df22ddab8291c3c2adf7e59dfeab6b98c5fd Mon Sep 17 00:00:00 2001 From: leekillough <15950023+leekillough@users.noreply.github.com> Date: Wed, 29 Nov 2023 19:02:54 -0600 Subject: [PATCH 4/6] set rd = rs1 in same assignments --- src/RevProc.cc | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/src/RevProc.cc b/src/RevProc.cc index 7f8b4bd08..a03a483c3 100644 --- a/src/RevProc.cc +++ b/src/RevProc.cc @@ -416,8 +416,7 @@ RevInst RevProc::DecodeCRInst(uint16_t Inst, unsigned Entry) const { CompInst.funct4 = InstTable[Entry].funct4; // registers - CompInst.rd = DECODE_RD(Inst); - CompInst.rs1 = DECODE_RD(Inst); + CompInst.rd = CompInst.rs1 = DECODE_RD(Inst); CompInst.rs2 = DECODE_LOWER_CRS2(Inst); CompInst.imm = 0x00; @@ -443,8 +442,7 @@ RevInst RevProc::DecodeCIInst(uint16_t Inst, unsigned Entry) const { CompInst.funct3 = InstTable[Entry].funct3; // registers - CompInst.rd = DECODE_RD(Inst); - CompInst.rs1 = DECODE_RD(Inst); + CompInst.rd = CompInst.rs1 = DECODE_RD(Inst); CompInst.imm = DECODE_LOWER_CRS2(Inst); CompInst.imm |= ((Inst & 0b1000000000000)>>7); @@ -752,8 +750,7 @@ RevInst RevProc::DecodeCAInst(uint16_t Inst, unsigned Entry) const { // registers CompInst.rs2 = ((Inst & 0b11100) >> 2); - CompInst.rs1 = ((Inst & 0b1110000000) >> 7); - CompInst.rd = ((Inst & 0b1110000000) >> 7); + CompInst.rd = CompInst.rs1 = ((Inst & 0b1110000000) >> 7); //Adjust registers for compressed offset CompInst.rs2 = CRegIdx(CompInst.rs2); @@ -777,7 +774,7 @@ RevInst RevProc::DecodeCBInst(uint16_t Inst, unsigned Entry) const { CompInst.funct3 = InstTable[Entry].funct3; // registers - CompInst.rs1 = ((Inst & 0b1110000000) >> 7); + CompInst.rd = CompInst.rs1 = ((Inst & 0b1110000000) >> 7); CompInst.offset = ((Inst & 0b1111100) >> 2); CompInst.offset |= ((Inst & 0b1110000000000) >> 5); From cebd2ad807acd4cda91a782613d311bd6bef1a85 Mon Sep 17 00:00:00 2001 From: leekillough <15950023+leekillough@users.noreply.github.com> Date: Wed, 29 Nov 2023 21:28:08 -0600 Subject: [PATCH 5/6] Revert "Fixing decode issue" This reverts commit 1d693169fb6616c42161b25789cece4234c31882. --- src/RevProc.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/RevProc.cc b/src/RevProc.cc index 9186d2f27..3a027ca78 100644 --- a/src/RevProc.cc +++ b/src/RevProc.cc @@ -421,7 +421,7 @@ RevInst RevProc::DecodeCRInst(uint16_t Inst, unsigned Entry) const { CompInst.imm = 0x00; //if c.mv force rs1 to x0 - if((0b10 == CompInst.opcode) && (0b1000 == CompInst.funct4) && (0 != CompInst.rs2)){ + if((0b10 == CompInst.opcode) && (0b1000 == CompInst.funct4)){ CompInst.rs1 = 0; } From 0d2cdc7ada75bdf18e28f2d3a40a0ed368d4739b Mon Sep 17 00:00:00 2001 From: David Donofrio Date: Wed, 29 Nov 2023 11:23:03 -0800 Subject: [PATCH 6/6] Fixing decode issue --- src/RevProc.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/RevProc.cc b/src/RevProc.cc index 3a027ca78..9186d2f27 100644 --- a/src/RevProc.cc +++ b/src/RevProc.cc @@ -421,7 +421,7 @@ RevInst RevProc::DecodeCRInst(uint16_t Inst, unsigned Entry) const { CompInst.imm = 0x00; //if c.mv force rs1 to x0 - if((0b10 == CompInst.opcode) && (0b1000 == CompInst.funct4)){ + if((0b10 == CompInst.opcode) && (0b1000 == CompInst.funct4) && (0 != CompInst.rs2)){ CompInst.rs1 = 0; }