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

Merge develop

Browse Source
This commit is contained in:
Derek Christ
2023-08-21 10:01:08 +02:00
parent 1208d3e799 a8d15e35a5
commit a0f93a75e2
117 changed files with 3036 additions and 2858 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
extensions/apps/traceAnalyzer/CMakeLists.txt
View File

@@ -28,7 +28,7 @@
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Authors:
# Authors:
# Matthias Jung
# Lukas Steiner
# Derek Christ
@@ -94,10 +94,9 @@ target_link_libraries(TraceAnalyzer
set(DRAMSYS_TRACEANALYZER_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
target_compile_definitions(${PROJECT_NAME}
PUBLIC
target_compile_definitions(${PROJECT_NAME}
PUBLIC
DRAMSYS_TRACEANALYZER_DIR="${DRAMSYS_TRACEANALYZER_DIR}"
)
build_source_group()
diagnostics_print(${PROJECT_NAME})

30
extensions/apps/traceAnalyzer/data/tracedb.cpp
View File

@@ -290,11 +290,6 @@ ID TraceDB::getTransactionIDFromPhaseID(ID phaseID)
GeneralInfo TraceDB::getGeneralInfoFromDB()
{
QVariant parameter;
parameter = getParameterFromTable("NumberOfTransactions", "GeneralInfo");
uint64_t numberOfTransactions = parameter.isValid() ? parameter.toULongLong() : 0;
parameter = getParameterFromTable("TraceEnd", "GeneralInfo");
traceTime traceEnd = parameter.isValid() ? static_cast<traceTime>(parameter.toULongLong()) : 0;
parameter = getParameterFromTable("NumberOfRanks", "GeneralInfo");
unsigned numberOfRanks = parameter.isValid() ? parameter.toUInt() : 1;
parameter = getParameterFromTable("NumberOfBankgroups", "GeneralInfo");
unsigned numberOfBankGroups = parameter.isValid() ? parameter.toUInt() : numberOfRanks;
@@ -328,6 +323,8 @@ GeneralInfo TraceDB::getGeneralInfoFromDB()
bool pseudoChannelMode = parameter.isValid() && parameter.toBool();
uint64_t numberOfPhases = getNumberOfPhases();
uint64_t numberOfTransactions = getNumberOfTransactions();
auto traceEnd = static_cast<traceTime>(getTraceLength());
QString description = (traces + "\n");
description += mcconfig + "\n";
@@ -417,6 +414,26 @@ QVariant TraceDB::getParameterFromTable(const std::string& parameter, const std:
}
}
uint64_t TraceDB::getTraceLength()
{
QSqlQuery query(database);
query.prepare("SELECT MAX(PhaseEnd) FROM Phases");
executeQuery(query);
query.next();
return query.value(0).toULongLong();
}
uint64_t TraceDB::getNumberOfTransactions()
{
QSqlQuery query(database);
query.prepare("SELECT COUNT(ID) FROM Transactions");
executeQuery(query);
query.next();
return query.value(0).toULongLong();
}
uint64_t TraceDB::getNumberOfPhases()
{
QSqlQuery query(database);
@@ -480,7 +497,7 @@ DependencyInfos TraceDB::getDependencyInfos(DependencyInfos::Type infoType)
selectTimeDependencyPercentages = QSqlQuery(database);
if (!selectTimeDependencyPercentages.prepare(queryTexts.selectTimeDependencyPercentages))
qDebug() << database.lastError().text();
executeQuery(selectTimeDependencyPercentages);
return parseDependencyInfos(selectTimeDependencyPercentages, infoType);
}
@@ -714,4 +731,3 @@ void TraceDB::executeScriptFile(const QString& fileName)
}
}
}

5
extensions/apps/traceAnalyzer/data/tracedb.h
View File

@@ -145,6 +145,8 @@ private:
void executeScriptFile(const QString& fileName);
void dropAndCreateTables();
uint64_t getTraceLength();
uint64_t getNumberOfTransactions();
uint64_t getNumberOfPhases();
GeneralInfo getGeneralInfoFromDB();
CommandLengths getCommandLengthsFromDB();
@@ -174,6 +176,3 @@ public:
}
};
#endif // TRACEDB_H

16
extensions/apps/traceAnalyzer/simulationdialog.cpp
View File

@@ -246,7 +246,7 @@ void SimulationDialog::loadConfigurationFromTextFields()
MemSpec memSpec;
SimConfig simConfig;
std::string simulationId;
TraceSetup traceSetup;
std::vector<Initiator> traceSetup;
simulationId = ui->simulationIdLineEdit->text().toStdString();
@@ -266,12 +266,14 @@ void SimulationDialog::loadConfigurationFromTextFields()
return;
}
configuration = DRAMSys::Config::Configuration{addressMapping,
mcConfig,
memSpec,
simConfig,
simulationId,
std::make_optional<TraceSetup>(std::move(traceSetup))};
configuration = DRAMSys::Config::Configuration{
addressMapping,
mcConfig,
memSpec,
simConfig,
simulationId,
std::make_optional<std::vector<Initiator>>(std::move(traceSetup))
};
loadConfiguration();
}

435
extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.cpp
View File

File diff suppressed because it is too large Load Diff

28
extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.h
View File

@@ -57,28 +57,28 @@ public:
private:
const MemSpecDDR5 *memSpec;
std::vector<std::vector<sc_core::sc_time>> lastScheduledByCommandAndDimmRank;
std::vector<std::vector<sc_core::sc_time>> lastScheduledByCommandAndPhysicalRank;
std::vector<std::vector<sc_core::sc_time>> lastScheduledByCommandAndLogicalRank;
std::vector<std::vector<sc_core::sc_time>> lastScheduledByCommandAndBankGroup;
std::vector<std::vector<sc_core::sc_time>> lastScheduledByCommandAndBank;
std::vector<ControllerVector<DimmRank, sc_core::sc_time>> lastScheduledByCommandAndDimmRank;
std::vector<ControllerVector<PhysicalRank, sc_core::sc_time>> lastScheduledByCommandAndPhysicalRank;
std::vector<ControllerVector<LogicalRank, sc_core::sc_time>> lastScheduledByCommandAndLogicalRank;
std::vector<ControllerVector<BankGroup, sc_core::sc_time>> lastScheduledByCommandAndBankGroup;
std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
std::vector<sc_core::sc_time> lastScheduledByCommand;
sc_core::sc_time lastCommandOnBus;
TimeInterval dummyCommandOnBus;
std::vector<std::vector<sc_core::sc_time>> lastScheduledByCommandAndBankInGroup;
std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBankInGroup;
std::vector<std::queue<sc_core::sc_time>> last4ActivatesPhysical;
std::vector<std::queue<sc_core::sc_time>> last4ActivatesLogical;
ControllerVector<PhysicalRank, std::queue<sc_core::sc_time>> last4ActivatesPhysical;
ControllerVector<LogicalRank, std::queue<sc_core::sc_time>> last4ActivatesLogical;
std::vector<std::vector<uint8_t>> lastBurstLengthByCommandAndDimmRank;
std::vector<std::vector<uint8_t>> lastBurstLengthByCommandAndPhysicalRank;
std::vector<std::vector<uint8_t>> lastBurstLengthByCommandAndLogicalRank;
std::vector<std::vector<uint8_t>> lastBurstLengthByCommandAndBankGroup;
std::vector<std::vector<uint8_t>> lastBurstLengthByCommandAndBank;
std::vector<ControllerVector<DimmRank, uint8_t>> lastBurstLengthByCommandAndDimmRank;
std::vector<ControllerVector<PhysicalRank, uint8_t>> lastBurstLengthByCommandAndPhysicalRank;
std::vector<ControllerVector<LogicalRank, uint8_t>> lastBurstLengthByCommandAndLogicalRank;
std::vector<ControllerVector<BankGroup, uint8_t>> lastBurstLengthByCommandAndBankGroup;
std::vector<ControllerVector<Bank, uint8_t>> lastBurstLengthByCommandAndBank;
std::vector<uint8_t> lastBurstLengthByCommand;
std::vector<std::vector<uint8_t>> lastBurstLengthByCommandAndBankInGroup;
std::vector<ControllerVector<Bank, uint8_t>> lastBurstLengthByCommandAndBankInGroup;
// TODO: store BL of last RD and WR globally or for each hierarchy?

427
extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.cpp
View File

@@ -50,18 +50,18 @@ CheckerHBM3::CheckerHBM3(const Configuration &config)
if (memSpec == nullptr)
SC_REPORT_FATAL("CheckerHBM3", "Wrong MemSpec chosen");
lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>(
Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
lastScheduledByCommandAndBankGroup = std::vector<std::vector<sc_time>>(
Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>(
Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
Command::numberOfCommands(), ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
lastScheduledByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, sc_time>>(
Command::numberOfCommands(), ControllerVector<BankGroup, sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
Command::numberOfCommands(), ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
lastCommandOnRasBus = scMaxTime;
lastCommandOnCasBus = scMaxTime;
last4Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
bankwiseRefreshCounter = std::vector<unsigned>(memSpec->ranksPerChannel);
bankwiseRefreshCounter = ControllerVector<Rank, unsigned>(memSpec->ranksPerChannel);
tRDPDE = memSpec->tRL + memSpec->tPL + 2 * memSpec->tCK;
tRDSRE = memSpec->tRL + memSpec->tPL + 3 * memSpec->tCK;
@@ -83,682 +83,637 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
if (command == Command::PREPB)
{
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK / 2);
if (lastCommandOnRasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK / 2);
}
else if (command == Command::RD)
{
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL);
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL);
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
if (lastCommandOnCasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
}
else if (command == Command::WR)
{
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
if (lastCommandOnCasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
}
else if (command == Command::RDA)
{
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL + 2 * memSpec->tCK +
std::max(memSpec->tWR - memSpec->tRTP, memSpec->tWTRL));
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL);
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL);
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
if (lastCommandOnCasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
}
else if (command == Command::WRA)
{
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
if (lastCommandOnCasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
}
else if (command == Command::ACT)
{
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart =
std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart =
std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::REFPB][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::REFPB][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RFMPB][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS - memSpec->tCK);
if (last4Activates[rank.ID()].size() >= 4)
if (last4Activates[rank].size() >= 4)
earliestTimeToStart =
std::max(earliestTimeToStart, last4Activates[rank.ID()].front() + memSpec->tFAW);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
if (lastCommandOnRasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
}
else if (command == Command::REFAB)
{
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
if (lastCommandOnRasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
}
else if (command == Command::PREAB)
{
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK / 2);
if (lastCommandOnRasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK / 2);
}
else if (command == Command::REFPB)
{
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::REFPB][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RFMPB][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
if (lastCommandStart != scMaxTime)
{
if (bankwiseRefreshCounter[rank.ID()] == 0)
if (bankwiseRefreshCounter[rank] == 0)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
else
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
}
if (last4Activates[rank.ID()].size() >= 4)
if (last4Activates[rank].size() >= 4)
earliestTimeToStart =
std::max(earliestTimeToStart, last4Activates[rank.ID()].front() + memSpec->tFAW);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
if (lastCommandOnRasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
}
else if (command == Command::SREFEN)
{
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart =
std::max(earliestTimeToStart, lastCommandStart + std::max(memSpec->tRTP + memSpec->tRP, tRDSRE));
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
if (lastCommandOnRasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
}
else if (command == Command::RFMAB)
{
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
if (lastCommandOnRasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
}
else if (command == Command::RFMAB)
{
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::REFPB][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RFMPB][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank.ID()];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
if (lastCommandOnRasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
}
else if (command == Command::PDEA)
{
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE);
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE);
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDE);
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDE);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
if (lastCommandOnRasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
}
else if (command == Command::PDEP)
{
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE);
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE);
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDE);
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
if (lastCommandOnRasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
}
else if (command == Command::PDXP)
{
lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
if (lastCommandOnRasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
}
else if (command == Command::PDXA)
{
lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
if (lastCommandOnRasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
}
else if (command == Command::SREFEX)
{
lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
if (lastCommandOnRasBus != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
}
else
{
@@ -778,12 +733,12 @@ void CheckerHBM3::insert(Command command, const tlm_generic_payload &payload)
BankGroup bankGroup = ControllerExtension::getBankGroup(payload);
Bank bank = ControllerExtension::getBank(payload);
PRINTDEBUGMESSAGE("CheckerHBM3",
"Changing state on bank " + std::to_string(bank.ID()) + " command is " + command.toString());
PRINTDEBUGMESSAGE("CheckerHBM3", "Changing state on bank " + std::to_string(static_cast<std::size_t>(bank))
+ " command is " + command.toString());
lastScheduledByCommandAndBank[command][bank.ID()] = sc_time_stamp();
lastScheduledByCommandAndBankGroup[command][bankGroup.ID()] = sc_time_stamp();
lastScheduledByCommandAndRank[command][rank.ID()] = sc_time_stamp();
lastScheduledByCommandAndBank[command][bank] = sc_time_stamp();
lastScheduledByCommandAndBankGroup[command][bankGroup] = sc_time_stamp();
lastScheduledByCommandAndRank[command][rank] = sc_time_stamp();
lastScheduledByCommand[command] = sc_time_stamp();
if (command.isCasCommand())
@@ -795,13 +750,13 @@ void CheckerHBM3::insert(Command command, const tlm_generic_payload &payload)
if (command == Command::ACT || command == Command::REFPB)
{
if (last4Activates[rank.ID()].size() == 4)
last4Activates[rank.ID()].pop();
last4Activates[rank.ID()].push(lastCommandOnRasBus);
if (last4Activates[rank].size() == 4)
last4Activates[rank].pop();
last4Activates[rank].push(lastCommandOnRasBus);
}
if (command == Command::REFPB)
bankwiseRefreshCounter[rank.ID()] = (bankwiseRefreshCounter[rank.ID()] + 1) % memSpec->banksPerRank;
bankwiseRefreshCounter[rank] = (bankwiseRefreshCounter[rank] + 1) % memSpec->banksPerRank;
}
bool CheckerHBM3::isFullCycle(const sc_core::sc_time& time) const

10
extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.h
View File

@@ -60,17 +60,17 @@ private:
const MemSpecHBM3 *memSpec;
std::vector<std::vector<sc_core::sc_time>> lastScheduledByCommandAndBank;
std::vector<std::vector<sc_core::sc_time>> lastScheduledByCommandAndBankGroup;
std::vector<std::vector<sc_core::sc_time>> lastScheduledByCommandAndRank;
std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
std::vector<ControllerVector<BankGroup, sc_core::sc_time>> lastScheduledByCommandAndBankGroup;
std::vector<ControllerVector<Rank, sc_core::sc_time>> lastScheduledByCommandAndRank;
std::vector<sc_core::sc_time> lastScheduledByCommand;
sc_core::sc_time lastCommandOnRasBus;
sc_core::sc_time lastCommandOnCasBus;
// Four activate window
std::vector<std::queue<sc_core::sc_time>> last4Activates;
std::vector<unsigned> bankwiseRefreshCounter;
ControllerVector<Rank, std::queue<sc_core::sc_time>> last4Activates;
ControllerVector<Rank, unsigned> bankwiseRefreshCounter;
const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
sc_core::sc_time tRDPDE;

276
extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.cpp
View File

@@ -51,23 +51,24 @@ CheckerLPDDR5::CheckerLPDDR5(const Configuration& config)
SC_REPORT_FATAL("CheckerLPDDR5", "Wrong MemSpec chosen");
else
{
lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>
(Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
lastScheduledByCommandAndBankGroup = std::vector<std::vector<sc_time>>
(Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>
(Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>
(Command::numberOfCommands(), ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
lastScheduledByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, sc_time>>
(Command::numberOfCommands(),
ControllerVector<BankGroup, sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>
(Command::numberOfCommands(), ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
lastCommandOnBus = scMaxTime;
last4Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
lastBurstLengthByCommandAndRank = std::vector<std::vector<uint8_t>>
(Command::WRA + 1, std::vector<uint8_t>(memSpec->ranksPerChannel));
lastBurstLengthByCommandAndBankGroup = std::vector<std::vector<uint8_t>>
(Command::WRA + 1, std::vector<uint8_t>(memSpec->bankGroupsPerChannel));
lastBurstLengthByCommandAndBank = std::vector<std::vector<uint8_t>>
(Command::WRA + 1, std::vector<uint8_t>(memSpec->banksPerChannel));
lastBurstLengthByCommandAndRank = std::vector<ControllerVector<Rank, uint8_t>>
(Command::WRA + 1, ControllerVector<Rank, uint8_t>(memSpec->ranksPerChannel));
lastBurstLengthByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, uint8_t>>
(Command::WRA + 1, ControllerVector<BankGroup, uint8_t>(memSpec->bankGroupsPerChannel));
lastBurstLengthByCommandAndBank = std::vector<ControllerVector<Bank, uint8_t>>
(Command::WRA + 1, ControllerVector<Bank, uint8_t>(memSpec->banksPerChannel));
lastBurstLengthByCommand = std::vector<uint8_t>(Command::WRA + 1);
tBURST16 = 16 / memSpec->dataRate * memSpec->tCK;
@@ -92,23 +93,23 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
assert(!(memSpec->bankMode == MemSpecLPDDR5::BankMode::MBG) || (memSpec->dataRate == 8)); // BG mode -> 4:1 ratio
assert(burstLength <= memSpec->maxBurstLength);
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD_L + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBankGroup[Command::RD][bankGroup.ID()] == 32)
if (lastBurstLengthByCommandAndBankGroup[Command::RD][bankGroup] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_32);
else
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_16);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::RD][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::RD][rank] == 32)
{
// TODO: model BG mode BL32 interleaved burst, remove this fix
if (memSpec->bankMode == MemSpecLPDDR5::BankMode::MBG)
@@ -120,7 +121,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_S_16);
}
lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ?
lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank] ?
lastScheduledByCommand[Command::RD] : scMaxTime;
if (lastCommandStart != scMaxTime)
{
@@ -132,19 +133,19 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->tCK + memSpec->tRPST + memSpec->tRPRE);
}
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBankGroup[Command::RDA][bankGroup.ID()] == 32)
if (lastBurstLengthByCommandAndBankGroup[Command::RDA][bankGroup] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_32);
else
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_16);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::RDA][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::RDA][rank] == 32)
{
// TODO: model BG mode BL32 interleaved burst, remove this fix
if (memSpec->bankMode == MemSpecLPDDR5::BankMode::MBG)
@@ -156,7 +157,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_S_16);
}
lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ?
lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank] ?
lastScheduledByCommand[Command::RDA] : scMaxTime;
if (lastCommandStart != scMaxTime)
{
@@ -169,10 +170,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->tCK + memSpec->tRPST + memSpec->tRPRE);
}
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup.ID()] == 32)
if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
+ memSpec->BL_n_max_32 + memSpec->tWTR_L);
else
@@ -180,10 +181,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_max_16 + memSpec->tWTR_L);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::WR][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::WR][rank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
+ memSpec->BL_n_min_32 + memSpec->tWTR_S);
else
@@ -191,7 +192,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_min_16 + memSpec->tWTR_S);
}
lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ?
lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank] ?
lastScheduledByCommand[Command::WR] : scMaxTime;
if (lastCommandStart != scMaxTime)
{
@@ -204,10 +205,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->tWL + memSpec->BL_n_min_16 + memSpec->tCK - memSpec->tRL);
}
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup.ID()] == 32)
if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
+ memSpec->BL_n_max_32 + memSpec->tWTR_L);
else
@@ -215,10 +216,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_max_16 + memSpec->tWTR_L);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::WRA][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::WRA][rank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
+ memSpec->BL_n_min_32 + memSpec->tWTR_S);
else
@@ -226,7 +227,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_min_16 + memSpec->tWTR_S);
}
lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ?
lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank] ?
lastScheduledByCommand[Command::WRA] : scMaxTime;
if (lastCommandStart != scMaxTime)
{
@@ -246,14 +247,14 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
assert(!(memSpec->bankMode == MemSpecLPDDR5::BankMode::MBG) || (memSpec->dataRate == 8)); // BG mode -> 4:1 ratio
assert(burstLength <= memSpec->maxBurstLength);
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD_S + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBankGroup[Command::RD][bankGroup.ID()] == 32)
if (lastBurstLengthByCommandAndBankGroup[Command::RD][bankGroup] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRL
+ memSpec->BL_n_max_32 + memSpec->tWCK2DQO - memSpec->tWL);
else
@@ -261,10 +262,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_max_16 + memSpec->tWCK2DQO - memSpec->tWL);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::RD][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::RD][rank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRL
+ memSpec->BL_n_min_32 + memSpec->tWCK2DQO - memSpec->tWL);
else
@@ -272,7 +273,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_min_16 + memSpec->tWCK2DQO - memSpec->tWL);
}
lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ?
lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank] ?
lastScheduledByCommand[Command::RD] : scMaxTime;
if (lastCommandStart != scMaxTime)
{
@@ -285,10 +286,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->tRL + memSpec->BL_n_min_16 + memSpec->tWCK2DQO + memSpec->tRPST - memSpec->tWL);
}
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBankGroup[Command::RDA][bankGroup.ID()] == 32)
if (lastBurstLengthByCommandAndBankGroup[Command::RDA][bankGroup] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRL
+ memSpec->BL_n_max_32 + memSpec->tWCK2DQO - memSpec->tWL);
else
@@ -296,10 +297,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_max_16 + memSpec->tWCK2DQO - memSpec->tWL);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::RDA][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::RDA][rank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRL
+ memSpec->BL_n_min_32 + memSpec->tWCK2DQO - memSpec->tWL);
else
@@ -307,7 +308,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_min_16 + memSpec->tWCK2DQO - memSpec->tWL);
}
lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ?
lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank] ?
lastScheduledByCommand[Command::RDA] : scMaxTime;
if (lastCommandStart != scMaxTime)
{
@@ -320,19 +321,19 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->tRL + memSpec->BL_n_min_16 + memSpec->tWCK2DQO + memSpec->tRPST - memSpec->tWL);
}
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup.ID()] == 32)
if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_32);
else
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_16);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::WR][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::WR][rank] == 32)
{
// TODO: model BG mode BL32 interleaved burst, remove this fix
if (memSpec->bankMode == MemSpecLPDDR5::BankMode::MBG)
@@ -344,7 +345,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_S_16);
}
lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ?
lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank] ?
lastScheduledByCommand[Command::WR] : scMaxTime;
if (lastCommandStart != scMaxTime)
{
@@ -355,19 +356,19 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_16 + memSpec->tCK);
}
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup.ID()] == 32)
if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_32);
else
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_16);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::WRA][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::WRA][rank] == 32)
{
// TODO: model BG mode BL32 interleaved burst, remove this fix
if (memSpec->bankMode == MemSpecLPDDR5::BankMode::MBG)
@@ -379,7 +380,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_S_16);
}
lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ?
lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank] ?
lastScheduledByCommand[Command::WRA] : scMaxTime;
if (lastCommandStart != scMaxTime)
{
@@ -391,18 +392,18 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
}
else if (command == Command::ACT)
{
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBank[Command::RDA][bank.ID()] == 32)
if (lastBurstLengthByCommandAndBank[Command::RDA][bank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
+ memSpec->tRBTP + memSpec->tRPpb - memSpec->tCK);
else
@@ -410,10 +411,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->tRBTP + memSpec->tRPpb - memSpec->tCK);
}
lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBank[Command::RDA][bank.ID()] == 32)
if (lastBurstLengthByCommandAndBank[Command::RDA][bank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
+ memSpec->BL_n_min_32 + memSpec->tCK + memSpec->tWR + memSpec->tRPpb - memSpec->tCK);
else
@@ -421,47 +422,47 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_min_16 + memSpec->tCK + memSpec->tWR + memSpec->tRPpb - memSpec->tCK);
}
lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tpbR2act - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFP2B][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFP2B][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tpbR2act - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb - memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::REFP2B][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::REFP2B][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb - memSpec->tCK);
if (last4Activates[rank.ID()].size() >= 4)
earliestTimeToStart = std::max(earliestTimeToStart, last4Activates[rank.ID()].front() + memSpec->tFAW - memSpec->tCK);
if (last4Activates[rank].size() >= 4)
earliestTimeToStart = std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW - memSpec->tCK);
}
else if (command == Command::PREPB)
{
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBank[Command::RD][bank.ID()] == 32)
if (lastBurstLengthByCommandAndBank[Command::RD][bank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
+ memSpec->tRBTP);
else
@@ -469,10 +470,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->tRBTP);
}
lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBank[Command::WR][bank.ID()] == 32)
if (lastBurstLengthByCommandAndBank[Command::WR][bank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
+ memSpec->BL_n_min_32 + memSpec->tCK + memSpec->tWR);
else
@@ -480,20 +481,20 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_min_16 + memSpec->tCK + memSpec->tWR);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
}
else if (command == Command::PREAB)
{
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::RD][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::RD][rank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
+ memSpec->tRBTP);
else
@@ -501,10 +502,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->tRBTP);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::RDA][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::RDA][rank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
+ memSpec->tRBTP);
else
@@ -512,10 +513,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->tRBTP);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::WR][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::WR][rank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
+ memSpec->BL_n_min_32 + memSpec->tCK + memSpec->tWR);
else
@@ -523,10 +524,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_min_16 + memSpec->tCK + memSpec->tWR);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::WRA][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::WRA][rank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
+ memSpec->BL_n_min_32 + memSpec->tCK + memSpec->tWR);
else
@@ -534,20 +535,20 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_min_16 + memSpec->tCK + memSpec->tWR);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
}
else if (command == Command::REFAB)
{
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::RDA][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::RDA][rank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
+ memSpec->tRBTP + memSpec->tRPpb);
else
@@ -555,10 +556,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->tRBTP + memSpec->tRPpb);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndRank[Command::WRA][rank.ID()] == 32)
if (lastBurstLengthByCommandAndRank[Command::WRA][rank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
+ memSpec->BL_n_min_32 + memSpec->tCK + memSpec->tWR + memSpec->tRPpb);
else
@@ -566,32 +567,32 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_min_16 + memSpec->tCK + memSpec->tWR + memSpec->tRPpb);
}
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
}
else if (command == Command::REFPB)
{
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBank[Command::RDA][bank.ID()] == 32)
if (lastBurstLengthByCommandAndBank[Command::RDA][bank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
+ memSpec->tRBTP + memSpec->tRPpb);
else
@@ -599,10 +600,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->tRBTP + memSpec->tRPpb);
}
lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBank[Command::WRA][bank.ID()] == 32)
if (lastBurstLengthByCommandAndBank[Command::WRA][bank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
+ memSpec->BL_n_min_32 + memSpec->tCK + memSpec->tWR + memSpec->tRPpb);
else
@@ -610,45 +611,45 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_min_16 + memSpec->tCK + memSpec->tWR + memSpec->tRPpb);
}
lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tpbR2pbR);
if (last4Activates[rank.ID()].size() >= 4)
earliestTimeToStart = std::max(earliestTimeToStart, last4Activates[rank.ID()].front() + memSpec->tFAW);
if (last4Activates[rank].size() >= 4)
earliestTimeToStart = std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
}
else if (command == Command::REFP2B)
{
Bank secondBank = Bank(bank.ID() + memSpec->getPer2BankOffset());
Bank secondBank = Bank(static_cast<std::size_t>(bank) + memSpec->getPer2BankOffset());
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][secondBank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][secondBank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD + memSpec->tCK);
lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBank[Command::RDA][bank.ID()] == 32)
if (lastBurstLengthByCommandAndBank[Command::RDA][bank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
+ memSpec->tRBTP + memSpec->tRPpb);
else
@@ -656,10 +657,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->tRBTP + memSpec->tRPpb);
}
lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][secondBank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][secondBank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBank[Command::RDA][secondBank.ID()] == 32)
if (lastBurstLengthByCommandAndBank[Command::RDA][secondBank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
+ memSpec->tRBTP + memSpec->tRPpb);
else
@@ -667,10 +668,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->tRBTP + memSpec->tRPpb);
}
lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBank[Command::WRA][bank.ID()] == 32)
if (lastBurstLengthByCommandAndBank[Command::WRA][bank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
+ memSpec->BL_n_min_32 + memSpec->tCK + memSpec->tWR + memSpec->tRPpb);
else
@@ -678,10 +679,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_min_16 + memSpec->tCK + memSpec->tWR + memSpec->tRPpb);
}
lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][secondBank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][secondBank];
if (lastCommandStart != scMaxTime)
{
if (lastBurstLengthByCommandAndBank[Command::WRA][secondBank.ID()] == 32)
if (lastBurstLengthByCommandAndBank[Command::WRA][secondBank] == 32)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
+ memSpec->BL_n_min_32 + memSpec->tCK + memSpec->tWR + memSpec->tRPpb);
else
@@ -689,28 +690,28 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
+ memSpec->BL_n_min_16 + memSpec->tCK + memSpec->tWR + memSpec->tRPpb);
}
lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][secondBank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][secondBank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
lastCommandStart = lastScheduledByCommandAndBank[Command::REFP2B][bank.ID()];
lastCommandStart = lastScheduledByCommandAndBank[Command::REFP2B][bank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
lastCommandStart = lastScheduledByCommandAndRank[Command::REFP2B][rank.ID()];
lastCommandStart = lastScheduledByCommandAndRank[Command::REFP2B][rank];
if (lastCommandStart != scMaxTime)
earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tpbR2pbR);
if (last4Activates[rank.ID()].size() >= 4)
earliestTimeToStart = std::max(earliestTimeToStart, last4Activates[rank.ID()].front() + memSpec->tFAW);
if (last4Activates[rank].size() >= 4)
earliestTimeToStart = std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
}
else
SC_REPORT_FATAL("CheckerLPDDR5", "Unknown command!");
@@ -729,33 +730,36 @@ void CheckerLPDDR5::insert(Command command, const tlm_generic_payload& payload)
Bank bank = ControllerExtension::getBank(payload);
unsigned burstLength = ControllerExtension::getBurstLength(payload);
PRINTDEBUGMESSAGE("CheckerLPDDR5", "Changing state on bank " + std::to_string(bank.ID())
PRINTDEBUGMESSAGE("CheckerLPDDR5", "Changing state on bank " + std::to_string(static_cast<std::size_t>(bank))
+ " command is " + command.toString());
lastScheduledByCommandAndRank[command][rank.ID()] = sc_time_stamp();
lastScheduledByCommandAndBankGroup[command][bankGroup.ID()] = sc_time_stamp();
lastScheduledByCommandAndBank[command][bank.ID()] = sc_time_stamp();
lastScheduledByCommandAndRank[command][rank] = sc_time_stamp();
lastScheduledByCommandAndBankGroup[command][bankGroup] = sc_time_stamp();
lastScheduledByCommandAndBank[command][bank] = sc_time_stamp();
lastScheduledByCommand[command] = sc_time_stamp();
if (command.isCasCommand())
{
lastBurstLengthByCommandAndRank[command][rank.ID()] = burstLength;
lastBurstLengthByCommandAndBankGroup[command][bankGroup.ID()] = burstLength;
lastBurstLengthByCommandAndBank[command][bank.ID()] = burstLength;
lastBurstLengthByCommandAndRank[command][rank] = burstLength;
lastBurstLengthByCommandAndBankGroup[command][bankGroup] = burstLength;
lastBurstLengthByCommandAndBank[command][bank] = burstLength;
lastBurstLengthByCommand[command] = burstLength;
}
if (command == Command::REFP2B)
lastScheduledByCommandAndBank[command][bank.ID() + memSpec->getPer2BankOffset()] = sc_time_stamp();
{
Bank secondBank = Bank(static_cast<std::size_t>(bank) + memSpec->getPer2BankOffset());
lastScheduledByCommandAndBank[command][secondBank] = sc_time_stamp();
}
lastCommandOnBus = sc_time_stamp() + memSpec->getCommandLength(command) - memSpec->tCK;
if (command == Command::ACT || command == Command::REFPB || command == Command::REFP2B
|| command == Command::RFMPB || command == Command::RFMP2B)
{
if (last4Activates[rank.ID()].size() == 4)
last4Activates[rank.ID()].pop();
last4Activates[rank.ID()].push(lastCommandOnBus);
if (last4Activates[rank].size() == 4)
last4Activates[rank].pop();
last4Activates[rank].push(lastCommandOnBus);
}
}

14
extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.h
View File

@@ -57,16 +57,16 @@ public:
private:
const MemSpecLPDDR5 *memSpec;
std::vector<std::vector<sc_core::sc_time>> lastScheduledByCommandAndRank;
std::vector<std::vector<sc_core::sc_time>> lastScheduledByCommandAndBankGroup;
std::vector<std::vector<sc_core::sc_time>> lastScheduledByCommandAndBank;
std::vector<ControllerVector<Rank, sc_core::sc_time>> lastScheduledByCommandAndRank;
std::vector<ControllerVector<BankGroup, sc_core::sc_time>> lastScheduledByCommandAndBankGroup;
std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
std::vector<sc_core::sc_time> lastScheduledByCommand;
sc_core::sc_time lastCommandOnBus;
std::vector<std::queue<sc_core::sc_time>> last4Activates;
ControllerVector<Rank, std::queue<sc_core::sc_time>> last4Activates;
std::vector<std::vector<uint8_t>> lastBurstLengthByCommandAndRank;
std::vector<std::vector<uint8_t>> lastBurstLengthByCommandAndBankGroup;
std::vector<std::vector<uint8_t>> lastBurstLengthByCommandAndBank;
std::vector<ControllerVector<Rank, uint8_t>> lastBurstLengthByCommandAndRank;
std::vector<ControllerVector<BankGroup, uint8_t>> lastBurstLengthByCommandAndBankGroup;
std::vector<ControllerVector<Bank, uint8_t>> lastBurstLengthByCommandAndBank;
std::vector<uint8_t> lastBurstLengthByCommand;
const sc_core::sc_time scMaxTime = sc_core::sc_max_time();