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

std::pair to std::tuple for new command multiplexer.

Browse Source
This commit is contained in:
Lukas Steiner
2020-07-29 14:58:26 +02:00
parent 4ce4611b9c
commit f23ea816c3
20 changed files with 65 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
DRAMSys/library/src/controller/BankMachine.cpp
View File

@@ -44,12 +44,12 @@ BankMachine::BankMachine(SchedulerIF *scheduler, CheckerIF *checker, Bank bank)
bankgroup = BankGroup(bank.ID() / memSpec->banksPerGroup);
}
std::pair<Command, tlm_generic_payload *> BankMachine::getNextCommand()
std::tuple<Command, tlm_generic_payload *> BankMachine::getNextCommand()
{
if (sc_time_stamp() == timeToSchedule)
return std::pair<Command, tlm_generic_payload *>(nextCommand, currentPayload);
return std::tuple<Command, tlm_generic_payload *>(nextCommand, currentPayload);
else
return std::pair<Command, tlm_generic_payload *>(Command::NOP, nullptr);
return std::tuple<Command, tlm_generic_payload *>(Command::NOP, nullptr);
}
void BankMachine::updateState(Command command)

2
DRAMSys/library/src/controller/BankMachine.h
View File

@@ -58,7 +58,7 @@ class BankMachine
public:
virtual ~BankMachine() {}
virtual sc_time start() = 0;
std::pair<Command, tlm::tlm_generic_payload *> getNextCommand();
std::tuple<Command, tlm::tlm_generic_payload *> getNextCommand();
void updateState(Command);
void block();

52
DRAMSys/library/src/controller/Controller.cpp
View File

@@ -239,28 +239,28 @@ void Controller::controllerMethod()
it->start();
// (5) Choose one request and send it to DRAM
std::pair<Command, tlm_generic_payload *> commandPair;
std::vector<std::pair<Command, tlm_generic_payload *>> readyCommands;
std::tuple<Command, tlm_generic_payload *> commandTuple;
std::vector<std::tuple<Command, tlm_generic_payload *>> readyCommands;
// (5.1) Check for power-down commands (PDEA/PDEP/SREFEN or PDXA/PDXP/SREFEX)
for (unsigned rankID = 0; rankID < memSpec->numberOfRanks; rankID++)
{
commandPair = powerDownManagers[rankID]->getNextCommand();
if (commandPair.second != nullptr)
readyCommands.push_back(commandPair);
commandTuple = powerDownManagers[rankID]->getNextCommand();
if (std::get<1>(commandTuple) != nullptr)
readyCommands.push_back(commandTuple);
else
{
// (5.2) Check for refresh commands (PREA/PRE or REFA/REFB)
commandPair = refreshManagers[rankID]->getNextCommand();
if (commandPair.second != nullptr)
readyCommands.push_back(commandPair);
commandTuple = refreshManagers[rankID]->getNextCommand();
if (std::get<1>(commandTuple) != nullptr)
readyCommands.push_back(commandTuple);
else
{
// (5.3) Check for bank commands (PRE, ACT, RD/RDA or WR/WRA)
for (auto it : bankMachinesOnRank[rankID])
{
commandPair = it->getNextCommand();
if (commandPair.second != nullptr)
readyCommands.push_back(commandPair);
commandTuple = it->getNextCommand();
if (std::get<1>(commandTuple) != nullptr)
readyCommands.push_back(commandTuple);
}
}
}
@@ -269,29 +269,29 @@ void Controller::controllerMethod()
bool readyCmdBlocked = false;
if (!readyCommands.empty())
{
commandPair = cmdMux->selectCommand(readyCommands);
if (commandPair.second != nullptr) // can happen with FIFO strict
commandTuple = cmdMux->selectCommand(readyCommands);
if (std::get<1>(commandTuple) != nullptr) // can happen with FIFO strict
{
Rank rank = DramExtension::getRank(commandPair.second);
BankGroup bankgroup = DramExtension::getBankGroup(commandPair.second);
Bank bank = DramExtension::getBank(commandPair.second);
Rank rank = DramExtension::getRank(std::get<1>(commandTuple));
BankGroup bankgroup = DramExtension::getBankGroup(std::get<1>(commandTuple));
Bank bank = DramExtension::getBank(std::get<1>(commandTuple));
if (isRankCommand(commandPair.first))
if (isRankCommand(std::get<0>(commandTuple)))
{
for (auto it : bankMachinesOnRank[rank.ID()])
it->updateState(commandPair.first);
it->updateState(std::get<0>(commandTuple));
}
else
bankMachines[bank.ID()]->updateState(commandPair.first);
bankMachines[bank.ID()]->updateState(std::get<0>(commandTuple));
refreshManagers[rank.ID()]->updateState(commandPair.first);
powerDownManagers[rank.ID()]->updateState(commandPair.first);
checker->insert(commandPair.first, rank, bankgroup, bank);
refreshManagers[rank.ID()]->updateState(std::get<0>(commandTuple));
powerDownManagers[rank.ID()]->updateState(std::get<0>(commandTuple));
checker->insert(std::get<0>(commandTuple), rank, bankgroup, bank);
if (isCasCommand(commandPair.first))
if (isCasCommand(std::get<0>(commandTuple)))
{
scheduler->removeRequest(commandPair.second);
respQueue->insertPayload(commandPair.second, memSpec->getIntervalOnDataStrobe(commandPair.first).end);
scheduler->removeRequest(std::get<1>(commandTuple));
respQueue->insertPayload(std::get<1>(commandTuple), memSpec->getIntervalOnDataStrobe(std::get<0>(commandTuple)).end);
sc_time triggerTime = respQueue->getTriggerTime();
if (triggerTime != sc_max_time())
@@ -302,7 +302,7 @@ void Controller::controllerMethod()
if (ranksNumberOfPayloads[rank.ID()] == 0)
powerDownManagers[rank.ID()]->triggerEntry();
sendToDram(commandPair.first, commandPair.second);
sendToDram(std::get<0>(commandTuple), std::get<1>(commandTuple));
}
else
readyCmdBlocked = true;

4
DRAMSys/library/src/controller/cmdmux/CmdMuxIF.h
View File

@@ -44,8 +44,8 @@ class CmdMuxIF
{
public:
virtual ~CmdMuxIF() {}
virtual std::pair<Command, tlm::tlm_generic_payload *>
selectCommand(std::vector<std::pair<Command, tlm::tlm_generic_payload *>> &) = 0;
virtual std::tuple<Command, tlm::tlm_generic_payload *>
selectCommand(std::vector<std::tuple<Command, tlm::tlm_generic_payload *>> &) = 0;
};
#endif // CMDMUXIF_H

8
DRAMSys/library/src/controller/cmdmux/CmdMuxOldest.cpp
View File

@@ -38,17 +38,17 @@
using namespace tlm;
std::pair<Command, tlm_generic_payload *>
CmdMuxOldest::selectCommand(std::vector<std::pair<Command, tlm_generic_payload *>> &readyCommands)
std::tuple<Command, tlm_generic_payload *>
CmdMuxOldest::selectCommand(std::vector<std::tuple<Command, tlm_generic_payload *>> &readyCommands)
{
auto it = readyCommands.begin();
auto result = it;
unsigned lastPayloadID = DramExtension::getPayloadID(it->second);
uint64_t lastPayloadID = DramExtension::getPayloadID(std::get<1>(*it));
it++;
while (it != readyCommands.end())
{
unsigned newPayloadID = DramExtension::getPayloadID(it->second);
uint64_t newPayloadID = DramExtension::getPayloadID(std::get<1>(*it));
if (newPayloadID < lastPayloadID)
{
lastPayloadID = newPayloadID;

4
DRAMSys/library/src/controller/cmdmux/CmdMuxOldest.h
View File

@@ -40,8 +40,8 @@
class CmdMuxOldest : public CmdMuxIF
{
public:
std::pair<Command, tlm::tlm_generic_payload *>
selectCommand(std::vector<std::pair<Command, tlm::tlm_generic_payload *>> &);
std::tuple<Command, tlm::tlm_generic_payload *>
selectCommand(std::vector<std::tuple<Command, tlm::tlm_generic_payload *>> &);
};
#endif // CMDMUXOLDEST_H

10
DRAMSys/library/src/controller/cmdmux/CmdMuxStrict.cpp
View File

@@ -38,14 +38,14 @@
using namespace tlm;
std::pair<Command, tlm_generic_payload *>
CmdMuxStrict::selectCommand(std::vector<std::pair<Command, tlm_generic_payload *>> &readyCommands)
std::tuple<Command, tlm_generic_payload *>
CmdMuxStrict::selectCommand(std::vector<std::tuple<Command, tlm_generic_payload *>> &readyCommands)
{
for (auto it : readyCommands)
{
if (isCasCommand(it.first))
if (isCasCommand(std::get<0>(it)))
{
if (DramExtension::getPayloadID(it.second) == nextPayloadID)
if (DramExtension::getPayloadID(std::get<1>(it)) == nextPayloadID)
{
nextPayloadID++;
return it;
@@ -54,7 +54,7 @@ CmdMuxStrict::selectCommand(std::vector<std::pair<Command, tlm_generic_payload *
}
for (auto it : readyCommands)
{
if (isRasCommand(it.first))
if (isRasCommand(std::get<0>(it)))
return it;
}
return std::pair<Command, tlm_generic_payload *>(Command::NOP, nullptr);

4
DRAMSys/library/src/controller/cmdmux/CmdMuxStrict.h
View File

@@ -40,8 +40,8 @@
class CmdMuxStrict : public CmdMuxIF
{
public:
std::pair<Command, tlm::tlm_generic_payload *>
selectCommand(std::vector<std::pair<Command, tlm::tlm_generic_payload *>> &);
std::tuple<Command, tlm::tlm_generic_payload *>
selectCommand(std::vector<std::tuple<Command, tlm::tlm_generic_payload *>> &);
private:
uint64_t nextPayloadID = 0;

4
DRAMSys/library/src/controller/powerdown/PowerDownManagerDummy.cpp
View File

@@ -36,9 +36,9 @@
using namespace tlm;
std::pair<Command, tlm_generic_payload *> PowerDownManagerDummy::getNextCommand()
std::tuple<Command, tlm_generic_payload *> PowerDownManagerDummy::getNextCommand()
{
return std::pair<Command, tlm_generic_payload *>(Command::NOP, nullptr);
return std::tuple<Command, tlm_generic_payload *>(Command::NOP, nullptr);
}
sc_time PowerDownManagerDummy::start()

2
DRAMSys/library/src/controller/powerdown/PowerDownManagerDummy.h
View File

@@ -46,7 +46,7 @@ public:
virtual void triggerExit() override {}
virtual void triggerInterruption() override {}
virtual std::pair<Command, tlm::tlm_generic_payload *> getNextCommand() override;
virtual std::tuple<Command, tlm::tlm_generic_payload *> getNextCommand() override;
virtual void updateState(Command) override {}
virtual sc_time start() override;
};

2
DRAMSys/library/src/controller/powerdown/PowerDownManagerIF.h
View File

@@ -49,7 +49,7 @@ public:
virtual void triggerExit() = 0;
virtual void triggerInterruption() = 0;
virtual std::pair<Command, tlm::tlm_generic_payload *> getNextCommand() = 0;
virtual std::tuple<Command, tlm::tlm_generic_payload *> getNextCommand() = 0;
virtual void updateState(Command) = 0;
virtual sc_time start() = 0;
};

6
DRAMSys/library/src/controller/powerdown/PowerDownManagerStaggered.cpp
View File

@@ -69,12 +69,12 @@ void PowerDownManagerStaggered::triggerInterruption()
exitTriggered = true;
}
std::pair<Command, tlm_generic_payload *> PowerDownManagerStaggered::getNextCommand()
std::tuple<Command, tlm_generic_payload *> PowerDownManagerStaggered::getNextCommand()
{
if (sc_time_stamp() == timeToSchedule)
return std::pair<Command, tlm_generic_payload *>(nextCommand, &powerDownPayload);
return std::tuple<Command, tlm_generic_payload *>(nextCommand, &powerDownPayload);
else
return std::pair<Command, tlm_generic_payload *>(Command::NOP, nullptr);
return std::tuple<Command, tlm_generic_payload *>(Command::NOP, nullptr);
}
sc_time PowerDownManagerStaggered::start()

2
DRAMSys/library/src/controller/powerdown/PowerDownManagerStaggered.h
View File

@@ -48,7 +48,7 @@ public:
virtual void triggerExit() override;
virtual void triggerInterruption() override;
virtual std::pair<Command, tlm::tlm_generic_payload *> getNextCommand() override;
virtual std::tuple<Command, tlm::tlm_generic_payload *> getNextCommand() override;
virtual void updateState(Command) override;
virtual sc_time start() override;

6
DRAMSys/library/src/controller/refresh/RefreshManagerBankwise.cpp
View File

@@ -59,13 +59,13 @@ RefreshManagerBankwise::RefreshManagerBankwise(std::vector<BankMachine *> &bankM
maxPulledin = -(config.refreshMaxPulledin * memSpec->banksPerRank);
}
std::pair<Command, tlm_generic_payload *> RefreshManagerBankwise::getNextCommand()
std::tuple<Command, tlm_generic_payload *> RefreshManagerBankwise::getNextCommand()
{
if (sc_time_stamp() == timeToSchedule)
return std::pair<Command, tlm_generic_payload *>
return std::tuple<Command, tlm_generic_payload *>
(nextCommand, &refreshPayloads[currentBankMachine->getBank().ID() % memSpec->banksPerRank]);
else
return std::pair<Command, tlm_generic_payload *>(Command::NOP, nullptr);
return std::tuple<Command, tlm_generic_payload *>(Command::NOP, nullptr);
}
sc_time RefreshManagerBankwise::start()

2
DRAMSys/library/src/controller/refresh/RefreshManagerBankwise.h
View File

@@ -48,7 +48,7 @@ class RefreshManagerBankwise final : public RefreshManagerIF
public:
RefreshManagerBankwise(std::vector<BankMachine *> &, PowerDownManagerIF *, Rank, CheckerIF *);
virtual std::pair<Command, tlm::tlm_generic_payload *> getNextCommand() override;
virtual std::tuple<Command, tlm::tlm_generic_payload *> getNextCommand() override;
virtual sc_time start() override;
virtual void updateState(Command) override;

4
DRAMSys/library/src/controller/refresh/RefreshManagerDummy.cpp
View File

@@ -36,9 +36,9 @@
using namespace tlm;
std::pair<Command, tlm_generic_payload *> RefreshManagerDummy::getNextCommand()
std::tuple<Command, tlm_generic_payload *> RefreshManagerDummy::getNextCommand()
{
return std::pair<Command, tlm_generic_payload *>(Command::NOP, nullptr);
return std::tuple<Command, tlm_generic_payload *>(Command::NOP, nullptr);
}
sc_time RefreshManagerDummy::start()

2
DRAMSys/library/src/controller/refresh/RefreshManagerDummy.h
View File

@@ -44,7 +44,7 @@
class RefreshManagerDummy final : public RefreshManagerIF
{
public:
virtual std::pair<Command, tlm::tlm_generic_payload *> getNextCommand() override;
virtual std::tuple<Command, tlm::tlm_generic_payload *> getNextCommand() override;
virtual sc_time start() override;
virtual void updateState(Command) override {}
};

2
DRAMSys/library/src/controller/refresh/RefreshManagerIF.h
View File

@@ -45,7 +45,7 @@ class RefreshManagerIF
public:
virtual ~RefreshManagerIF() {}
virtual std::pair<Command, tlm::tlm_generic_payload *> getNextCommand() = 0;
virtual std::tuple<Command, tlm::tlm_generic_payload *> getNextCommand() = 0;
virtual sc_time start() = 0;
virtual void updateState(Command) = 0;
};

6
DRAMSys/library/src/controller/refresh/RefreshManagerRankwise.cpp
View File

@@ -52,12 +52,12 @@ RefreshManagerRankwise::RefreshManagerRankwise(std::vector<BankMachine *> &bankM
maxPulledin = -config.refreshMaxPulledin;
}
std::pair<Command, tlm_generic_payload *> RefreshManagerRankwise::getNextCommand()
std::tuple<Command, tlm_generic_payload *> RefreshManagerRankwise::getNextCommand()
{
if (sc_time_stamp() == timeToSchedule)
return std::pair<Command, tlm_generic_payload *>(nextCommand, &refreshPayload);
return std::tuple<Command, tlm_generic_payload *>(nextCommand, &refreshPayload);
else
return std::pair<Command, tlm_generic_payload *>(Command::NOP, nullptr);
return std::tuple<Command, tlm_generic_payload *>(Command::NOP, nullptr);
}
sc_time RefreshManagerRankwise::start()

2
DRAMSys/library/src/controller/refresh/RefreshManagerRankwise.h
View File

@@ -46,7 +46,7 @@ class RefreshManagerRankwise final : public RefreshManagerIF
public:
RefreshManagerRankwise(std::vector<BankMachine *> &, PowerDownManagerIF *, Rank, CheckerIF *);
virtual std::pair<Command, tlm::tlm_generic_payload *> getNextCommand() override;
virtual std::tuple<Command, tlm::tlm_generic_payload *> getNextCommand() override;
virtual sc_time start() override;
virtual void updateState(Command) override;