derek/DRAMSys
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use type safe index vectors in remaining controller.

Browse Source
This commit is contained in:
Lukas Steiner
2023-06-21 14:51:15 +02:00
parent ba3f367676
commit c833471480
13 changed files with 86 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
src/libdramsys/DRAMSys/common/dramExtensions.h
View File

@@ -202,7 +202,7 @@ private:
};
template<typename IndexType, typename ValueType>
struct ControllerVector
class ControllerVector
{
private:
std::vector<ValueType> baseVector;
@@ -229,6 +229,21 @@ public:
{
return baseVector[index.ID()];
}
void push_back(ValueType&& value)
{
baseVector.push_back(std::move(value));
}
typename std::vector<ValueType>::iterator begin()
{
return baseVector.begin();
}
typename std::vector<ValueType>::iterator end()
{
return baseVector.end();
}
};
class ArbiterExtension : public tlm::tlm_extension<ArbiterExtension>

81
src/libdramsys/DRAMSys/controller/Controller.cpp
View File

@@ -90,7 +90,7 @@ Controller::Controller(const sc_module_name& name, const Configuration& config,
SC_METHOD(controllerMethod);
sensitive << beginReqEvent << endRespEvent << controllerEvent << dataResponseEvent;
ranksNumberOfPayloads = std::vector<unsigned>(memSpec.ranksPerChannel);
ranksNumberOfPayloads = ControllerVector<Rank, unsigned>(memSpec.ranksPerChannel);
// reserve buffer for command tuples
readyCommands.reserve(memSpec.banksPerChannel);
@@ -166,47 +166,48 @@ Controller::Controller(const sc_module_name& name, const Configuration& config,
if (config.pagePolicy == Configuration::PagePolicy::Open)
{
for (unsigned bankID = 0; bankID < memSpec.banksPerChannel; bankID++)
bankMachines.emplace_back(std::make_unique<BankMachineOpen>
bankMachines.push_back(std::make_unique<BankMachineOpen>
(config, *scheduler, Bank(bankID)));
}
else if (config.pagePolicy == Configuration::PagePolicy::OpenAdaptive)
{
for (unsigned bankID = 0; bankID < memSpec.banksPerChannel; bankID++)
bankMachines.emplace_back(std::make_unique<BankMachineOpenAdaptive>
bankMachines.push_back(std::make_unique<BankMachineOpenAdaptive>
(config, *scheduler, Bank(bankID)));
}
else if (config.pagePolicy == Configuration::PagePolicy::Closed)
{
for (unsigned bankID = 0; bankID < memSpec.banksPerChannel; bankID++)
bankMachines.emplace_back(std::make_unique<BankMachineClosed>
bankMachines.push_back(std::make_unique<BankMachineClosed>
(config, *scheduler, Bank(bankID)));
}
else if (config.pagePolicy == Configuration::PagePolicy::ClosedAdaptive)
{
for (unsigned bankID = 0; bankID < memSpec.banksPerChannel; bankID++)
bankMachines.emplace_back(std::make_unique<BankMachineClosedAdaptive>
bankMachines.push_back(std::make_unique<BankMachineClosedAdaptive>
(config, *scheduler, Bank(bankID)));
}
bankMachinesOnRank = std::vector<std::vector<BankMachine*>>(memSpec.ranksPerChannel,
std::vector<BankMachine*>(memSpec.banksPerRank));
bankMachinesOnRank = ControllerVector<Rank, ControllerVector<Bank, BankMachine*>>(memSpec.ranksPerChannel,
ControllerVector<Bank, BankMachine*>(memSpec.banksPerRank));
for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
{
for (unsigned bankID = 0; bankID < memSpec.banksPerRank; bankID++)
bankMachinesOnRank[rankID][bankID] = bankMachines[rankID * memSpec.banksPerRank + bankID].get();
bankMachinesOnRank[Rank(rankID)][Bank(bankID)]
= bankMachines[Bank(rankID * memSpec.banksPerRank + bankID)].get();
}
// instantiate power-down managers (one per rank)
if (config.powerDownPolicy == Configuration::PowerDownPolicy::NoPowerDown)
{
for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
powerDownManagers.emplace_back(std::make_unique<PowerDownManagerDummy>());
powerDownManagers.push_back(std::make_unique<PowerDownManagerDummy>());
}
else if (config.powerDownPolicy == Configuration::PowerDownPolicy::Staggered)
{
for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
{
powerDownManagers.emplace_back(std::make_unique<PowerDownManagerStaggered>(bankMachinesOnRank[rankID],
powerDownManagers.push_back(std::make_unique<PowerDownManagerStaggered>(bankMachinesOnRank[Rank(rankID)],
Rank(rankID), *checker));
}
}
@@ -215,22 +216,22 @@ Controller::Controller(const sc_module_name& name, const Configuration& config,
if (config.refreshPolicy == Configuration::RefreshPolicy::NoRefresh)
{
for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
refreshManagers.emplace_back(std::make_unique<RefreshManagerDummy>());
refreshManagers.push_back(std::make_unique<RefreshManagerDummy>());
}
else if (config.refreshPolicy == Configuration::RefreshPolicy::AllBank)
{
for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
{
refreshManagers.emplace_back(std::make_unique<RefreshManagerAllBank>
(config, bankMachinesOnRank[rankID], *powerDownManagers[rankID].get(), Rank(rankID)));
refreshManagers.push_back(std::make_unique<RefreshManagerAllBank>
(config, bankMachinesOnRank[Rank(rankID)], *powerDownManagers[Rank(rankID)], Rank(rankID)));
}
}
else if (config.refreshPolicy == Configuration::RefreshPolicy::SameBank)
{
for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
{
refreshManagers.emplace_back(std::make_unique<RefreshManagerSameBank>
(config, bankMachinesOnRank[rankID], *powerDownManagers[rankID].get(), Rank(rankID)));
refreshManagers.push_back(std::make_unique<RefreshManagerSameBank>
(config, bankMachinesOnRank[Rank(rankID)], *powerDownManagers[Rank(rankID)], Rank(rankID)));
}
}
else if (config.refreshPolicy == Configuration::RefreshPolicy::PerBank)
@@ -238,8 +239,8 @@ Controller::Controller(const sc_module_name& name, const Configuration& config,
for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
{
// TODO: remove bankMachines in constructor
refreshManagers.emplace_back(std::make_unique<RefreshManagerPerBank>
(config, bankMachinesOnRank[rankID], *powerDownManagers[rankID], Rank(rankID)));
refreshManagers.push_back(std::make_unique<RefreshManagerPerBank>
(config, bankMachinesOnRank[Rank(rankID)], *powerDownManagers[Rank(rankID)], Rank(rankID)));
}
}
else if (config.refreshPolicy == Configuration::RefreshPolicy::Per2Bank)
@@ -247,8 +248,8 @@ Controller::Controller(const sc_module_name& name, const Configuration& config,
for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
{
// TODO: remove bankMachines in constructor
refreshManagers.emplace_back(std::make_unique<RefreshManagerPer2Bank>
(config, bankMachinesOnRank[rankID], *powerDownManagers[rankID], Rank(rankID)));
refreshManagers.push_back(std::make_unique<RefreshManagerPer2Bank>
(config, bankMachinesOnRank[Rank(rankID)], *powerDownManagers[Rank(rankID)], Rank(rankID)));
}
}
else
@@ -280,18 +281,18 @@ void Controller::controllerMethod()
for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
{
// (4.1) Check for power-down commands (PDEA/PDEP/SREFEN or PDXA/PDXP/SREFEX)
commandTuple = powerDownManagers[rankID]->getNextCommand();
commandTuple = powerDownManagers[Rank(rankID)]->getNextCommand();
if (std::get<CommandTuple::Command>(commandTuple) != Command::NOP)
readyCommands.emplace_back(commandTuple);
else
{
// (4.2) Check for refresh commands (PREXX or REFXX)
commandTuple = refreshManagers[rankID]->getNextCommand();
commandTuple = refreshManagers[Rank(rankID)]->getNextCommand();
if (std::get<CommandTuple::Command>(commandTuple) != Command::NOP)
readyCommands.emplace_back(commandTuple);
// (4.3) Check for bank commands (PREPB, ACT, RD/RDA or WR/WRA)
for (auto it : bankMachinesOnRank[rankID])
for (auto it : bankMachinesOnRank[Rank(rankID)])
{
commandTuple = it->getNextCommand();
if (std::get<CommandTuple::Command>(commandTuple) != Command::NOP)
@@ -320,25 +321,25 @@ void Controller::controllerMethod()
if (command.isRankCommand())
{
for (auto it : bankMachinesOnRank[rank.ID()])
for (auto it : bankMachinesOnRank[rank])
it->update(command);
}
else if (command.isGroupCommand())
{
for (unsigned bankID = (bank.ID() % memSpec.banksPerGroup);
bankID < memSpec.banksPerRank; bankID += memSpec.banksPerGroup)
bankMachinesOnRank[rank.ID()][bankID]->update(command);
bankMachinesOnRank[rank][Bank(bankID)]->update(command);
}
else if (command.is2BankCommand())
{
bankMachines[bank.ID()]->update(command);
bankMachines[bank.ID() + memSpec.getPer2BankOffset()]->update(command);
bankMachines[bank]->update(command);
bankMachines[Bank(bank.ID() + memSpec.getPer2BankOffset())]->update(command);
}
else // if (isBankCommand(command))
bankMachines[bank.ID()]->update(command);
bankMachines[bank]->update(command);
refreshManagers[rank.ID()]->update(command);
powerDownManagers[rank.ID()]->update(command);
refreshManagers[rank]->update(command);
powerDownManagers[rank]->update(command);
checker->insert(command, *trans);
if (command.isCasCommand())
@@ -354,10 +355,10 @@ void Controller::controllerMethod()
if (triggerTime != scMaxTime)
dataResponseEvent.notify(triggerTime - sc_time_stamp());
ranksNumberOfPayloads[rank.ID()]--; // TODO: move to a different place?
ranksNumberOfPayloads[rank]--; // TODO: move to a different place?
}
if (ranksNumberOfPayloads[rank.ID()] == 0)
powerDownManagers[rank.ID()]->triggerEntry();
if (ranksNumberOfPayloads[rank] == 0)
powerDownManagers[rank]->triggerEntry();
sc_time fwDelay = thinkDelayFw + phyDelayFw;
tlm_phase phase = command.toPhase();
@@ -487,13 +488,13 @@ void Controller::manageRequests(const sc_time& delay)
transToAcquire.payload->get_data_length() / memSpec.bytesPerBeat);
Rank rank = Rank(decodedAddress.rank);
if (ranksNumberOfPayloads[rank.ID()] == 0)
powerDownManagers[rank.ID()]->triggerExit();
ranksNumberOfPayloads[rank.ID()]++;
if (ranksNumberOfPayloads[rank] == 0)
powerDownManagers[rank]->triggerExit();
ranksNumberOfPayloads[rank]++;
scheduler->storeRequest(*transToAcquire.payload);
Bank bank = Bank(decodedAddress.bank);
bankMachines[bank.ID()]->evaluate();
bankMachines[bank]->evaluate();
}
else
{
@@ -503,13 +504,13 @@ void Controller::manageRequests(const sc_time& delay)
for (auto* childTrans : childTranses)
{
Rank rank = ControllerExtension::getRank(*childTrans);
if (ranksNumberOfPayloads[rank.ID()] == 0)
powerDownManagers[rank.ID()]->triggerExit();
ranksNumberOfPayloads[rank.ID()]++;
if (ranksNumberOfPayloads[rank] == 0)
powerDownManagers[rank]->triggerExit();
ranksNumberOfPayloads[rank]++;
scheduler->storeRequest(*childTrans);
Bank bank = ControllerExtension::getBank(*childTrans);
bankMachines[bank.ID()]->evaluate();
bankMachines[bank]->evaluate();
}
}

10
src/libdramsys/DRAMSys/controller/Controller.h
View File

@@ -83,16 +83,16 @@ protected:
private:
unsigned totalNumberOfPayloads = 0;
std::vector<unsigned> ranksNumberOfPayloads;
ControllerVector<Rank, unsigned> ranksNumberOfPayloads;
ReadyCommands readyCommands;
std::vector<std::unique_ptr<BankMachine>> bankMachines;
std::vector<std::vector<BankMachine*>> bankMachinesOnRank;
ControllerVector<Bank, std::unique_ptr<BankMachine>> bankMachines;
ControllerVector<Rank, ControllerVector<Bank, BankMachine*>> bankMachinesOnRank;
std::unique_ptr<CmdMuxIF> cmdMux;
std::unique_ptr<CheckerIF> checker;
std::unique_ptr<RespQueueIF> respQueue;
std::vector<std::unique_ptr<RefreshManagerIF>> refreshManagers;
std::vector<std::unique_ptr<PowerDownManagerIF>> powerDownManagers;
ControllerVector<Rank, std::unique_ptr<RefreshManagerIF>> refreshManagers;
ControllerVector<Rank, std::unique_ptr<PowerDownManagerIF>> powerDownManagers;
const AddressDecoder& addressDecoder;
uint64_t nextChannelPayloadIDToAppend = 1;

2
src/libdramsys/DRAMSys/controller/powerdown/PowerDownManagerStaggered.cpp
View File

@@ -42,7 +42,7 @@ using namespace tlm;
namespace DRAMSys
{
PowerDownManagerStaggered::PowerDownManagerStaggered(std::vector<BankMachine*>& bankMachinesOnRank,
PowerDownManagerStaggered::PowerDownManagerStaggered(ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
Rank rank, CheckerIF& checker)
: bankMachinesOnRank(bankMachinesOnRank)
{

4
src/libdramsys/DRAMSys/controller/powerdown/PowerDownManagerStaggered.h
View File

@@ -49,7 +49,7 @@ class BankMachine;
class PowerDownManagerStaggered final : public PowerDownManagerIF
{
public:
PowerDownManagerStaggered(std::vector<BankMachine*>& bankMachinesOnRank,
PowerDownManagerStaggered(ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
Rank rank, CheckerIF& checker);
void triggerEntry() override;
@@ -63,7 +63,7 @@ public:
private:
enum class State {Idle, ActivePdn, PrechargePdn, SelfRefresh, ExtraRefresh} state = State::Idle;
tlm::tlm_generic_payload powerDownPayload;
std::vector<BankMachine*>& bankMachinesOnRank;
ControllerVector<Bank, BankMachine*>& bankMachinesOnRank;
Command nextCommand = Command::NOP;
bool controllerIdle = true;

3
src/libdramsys/DRAMSys/controller/refresh/RefreshManagerAllBank.cpp
View File

@@ -44,7 +44,8 @@ using namespace tlm;
namespace DRAMSys
{
RefreshManagerAllBank::RefreshManagerAllBank(const Configuration& config, std::vector<BankMachine*>& bankMachinesOnRank,
RefreshManagerAllBank::RefreshManagerAllBank(const Configuration& config,
ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
PowerDownManagerIF& powerDownManager, Rank rank)
: bankMachinesOnRank(bankMachinesOnRank), powerDownManager(powerDownManager),
memSpec(*config.memSpec), maxPostponed(static_cast<int>(config.refreshMaxPostponed)),

4
src/libdramsys/DRAMSys/controller/refresh/RefreshManagerAllBank.h
View File

@@ -53,7 +53,7 @@ class PowerDownManagerIF;
class RefreshManagerAllBank final : public RefreshManagerIF
{
public:
RefreshManagerAllBank(const Configuration& config, std::vector<BankMachine*>& bankMachinesOnRank,
RefreshManagerAllBank(const Configuration& config, ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
PowerDownManagerIF& powerDownManager, Rank rank);
CommandTuple::Type getNextCommand() override;
@@ -64,7 +64,7 @@ public:
private:
enum class State {Regular, Pulledin} state = State::Regular;
const MemSpec& memSpec;
std::vector<BankMachine*>& bankMachinesOnRank;
ControllerVector<Bank, BankMachine*>& bankMachinesOnRank;
PowerDownManagerIF& powerDownManager;
tlm::tlm_generic_payload refreshPayload;
sc_core::sc_time timeForNextTrigger = sc_core::sc_max_time();

15
src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPer2Bank.cpp
View File

@@ -44,7 +44,7 @@ namespace DRAMSys
{
RefreshManagerPer2Bank::RefreshManagerPer2Bank(const Configuration& config,
std::vector<BankMachine*>& bankMachinesOnRank,
ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
PowerDownManagerIF& powerDownManager, Rank rank)
: powerDownManager(powerDownManager), memSpec(*config.memSpec),
maxPostponed(static_cast<int>(config.refreshMaxPostponed * memSpec.banksPerRank / 2)),
@@ -58,12 +58,13 @@ RefreshManagerPer2Bank::RefreshManagerPer2Bank(const Configuration& config,
{
for (unsigned bankID = outerID; bankID < (outerID + memSpec.getPer2BankOffset()); bankID++)
{
unsigned bankID2 = bankID + memSpec.getPer2BankOffset();
setUpDummy(refreshPayloads[bankMachinesOnRank[bankID]], 0, rank,
bankMachinesOnRank[bankID]->getBankGroup(), bankMachinesOnRank[bankID]->getBank());
setUpDummy(refreshPayloads[bankMachinesOnRank[bankID2]], 0, rank,
bankMachinesOnRank[bankID2]->getBankGroup(), bankMachinesOnRank[bankID2]->getBank());
allBankMachines.push_back({bankMachinesOnRank[bankID], bankMachinesOnRank[bankID2]});
Bank firstBank(bankID);
Bank secondBank(bankID + memSpec.getPer2BankOffset());
setUpDummy(refreshPayloads[bankMachinesOnRank[firstBank]], 0, rank,
bankMachinesOnRank[firstBank]->getBankGroup(), bankMachinesOnRank[firstBank]->getBank());
setUpDummy(refreshPayloads[bankMachinesOnRank[secondBank]], 0, rank,
bankMachinesOnRank[secondBank]->getBankGroup(), bankMachinesOnRank[secondBank]->getBank());
allBankMachines.push_back({bankMachinesOnRank[firstBank], bankMachinesOnRank[secondBank]});
}
}

2
src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPer2Bank.h
View File

@@ -55,7 +55,7 @@ class PowerDownManagerIF;
class RefreshManagerPer2Bank final : public RefreshManagerIF
{
public:
RefreshManagerPer2Bank(const Configuration& config, std::vector<BankMachine*>& bankMachinesOnRank,
RefreshManagerPer2Bank(const Configuration& config, ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
PowerDownManagerIF& powerDownManager, Rank rank);
CommandTuple::Type getNextCommand() override;

3
src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPerBank.cpp
View File

@@ -43,7 +43,8 @@ using namespace tlm;
namespace DRAMSys
{
RefreshManagerPerBank::RefreshManagerPerBank(const Configuration& config, std::vector<BankMachine*>& bankMachinesOnRank,
RefreshManagerPerBank::RefreshManagerPerBank(const Configuration& config,
ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
PowerDownManagerIF& powerDownManager, Rank rank)
: powerDownManager(powerDownManager), memSpec(*config.memSpec),
maxPostponed(static_cast<int>(config.refreshMaxPostponed * memSpec.banksPerRank)),

2
src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPerBank.h
View File

@@ -55,7 +55,7 @@ class PowerDownManagerIF;
class RefreshManagerPerBank final : public RefreshManagerIF
{
public:
RefreshManagerPerBank(const Configuration& config, std::vector<BankMachine *>& bankMachinesOnRank,
RefreshManagerPerBank(const Configuration& config, ControllerVector<Bank, BankMachine *>& bankMachinesOnRank,
PowerDownManagerIF& powerDownManager, Rank rank);
CommandTuple::Type getNextCommand() override;

8
src/libdramsys/DRAMSys/controller/refresh/RefreshManagerSameBank.cpp
View File

@@ -44,7 +44,7 @@ namespace DRAMSys
{
RefreshManagerSameBank::RefreshManagerSameBank(const Configuration& config,
std::vector<BankMachine*>& bankMachinesOnRank,
ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
PowerDownManagerIF& powerDownManager, Rank rank)
: powerDownManager(powerDownManager), memSpec(*config.memSpec),
maxPostponed(static_cast<int>(config.refreshMaxPostponed * memSpec.banksPerGroup)),
@@ -59,8 +59,8 @@ RefreshManagerSameBank::RefreshManagerSameBank(const Configuration& config,
for (unsigned bankID = 0; bankID < memSpec.banksPerGroup; bankID++)
{
// rank 0: bank group 0, bank 0 - 3; rank 1: bank group 8, bank 32 - 35
setUpDummy(refreshPayloads[bankID], 0, rank, bankMachinesOnRank[bankID]->getBankGroup(),
bankMachinesOnRank[bankID]->getBank());
setUpDummy(refreshPayloads[bankID], 0, rank, bankMachinesOnRank[Bank(bankID)]->getBankGroup(),
bankMachinesOnRank[Bank(bankID)]->getBank());
allBankMachines.emplace_back(std::vector<BankMachine *>(memSpec.groupsPerRank));
}
@@ -69,7 +69,7 @@ RefreshManagerSameBank::RefreshManagerSameBank(const Configuration& config,
for (unsigned bankID = 0; bankID < memSpec.banksPerGroup; bankID++)
{
for (unsigned groupID = 0; groupID < memSpec.groupsPerRank; groupID++)
(*it)[groupID] = bankMachinesOnRank[groupID * memSpec.banksPerGroup + bankID];
(*it)[groupID] = bankMachinesOnRank[Bank(groupID * memSpec.banksPerGroup + bankID)];
it++;
}

2
src/libdramsys/DRAMSys/controller/refresh/RefreshManagerSameBank.h
View File

@@ -54,7 +54,7 @@ class PowerDownManagerIF;
class RefreshManagerSameBank final : public RefreshManagerIF
{
public:
RefreshManagerSameBank(const Configuration& config, std::vector<BankMachine *>& bankMachinesOnRank,
RefreshManagerSameBank(const Configuration& config, ControllerVector<Bank, BankMachine *>& bankMachinesOnRank,
PowerDownManagerIF& powerDownManager, Rank rank);
CommandTuple::Type getNextCommand() override;