diff --git a/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.cpp b/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.cpp index 6a5c9c96..a2809a84 100644 --- a/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.cpp +++ b/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,12 +29,14 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #include "CheckerDDR5.h" - #include "DRAMSys/common/DebugManager.h" +#include "DRAMSys/common/utils.h" #include @@ -44,1136 +46,5853 @@ using namespace tlm; namespace DRAMSys { -CheckerDDR5::CheckerDDR5(const MemSpecDDR5& memSpec) - : memSpec(memSpec) +CheckerDDR5::CheckerDDR5(const MemSpecDDR5& memSpec) : memSpec(memSpec) { - lastScheduledByCommandAndDimmRank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.dimmRanksPerChannel, scMaxTime)); - lastScheduledByCommandAndPhysicalRank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.physicalRanksPerChannel, scMaxTime)); - lastScheduledByCommandAndLogicalRank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.logicalRanksPerChannel, scMaxTime)); - lastScheduledByCommandAndBankGroup = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.bankGroupsPerChannel, scMaxTime)); - lastScheduledByCommandAndBank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.banksPerChannel, scMaxTime)); - lastScheduledByCommand = std::vector(Command::numberOfCommands(), scMaxTime); - // Required for Same Bank Refresh - lastScheduledByCommandAndBankInGroup = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.ranksPerChannel * memSpec.banksPerGroup, - scMaxTime)); - lastCommandOnBus = scMaxTime; - dummyCommandOnBus.start = scMaxTime; - dummyCommandOnBus.end = scMaxTime; + + nextCommandByBank.fill({BankVector(memSpec.banksPerChannel, SC_ZERO_TIME)}); + nextCommandByBankGroup.fill({BankGroupVector(memSpec.bankGroupsPerChannel, SC_ZERO_TIME)}); + nextCommandByLogicalRank.fill({LogicalRankVector(memSpec.logicalRanksPerChannel, SC_ZERO_TIME)}); + nextCommandByPhysicalRank.fill({PhysicalRankVector(memSpec.physicalRanksPerChannel, SC_ZERO_TIME)}); + nextCommandByDimmRank.fill({DimmRankVector(memSpec.dimmRanksPerChannel, SC_ZERO_TIME)}); + last4ActivatesOnLogicalRank = LogicalRankVector>(memSpec.logicalRanksPerChannel); + last4ActivatesOnPhysicalRank = PhysicalRankVector>(memSpec.physicalRanksPerChannel); - last4ActivatesLogical = - ControllerVector>(memSpec.logicalRanksPerChannel); - last4ActivatesPhysical = - ControllerVector>(memSpec.physicalRanksPerChannel); - - lastBurstLengthByCommandAndDimmRank = std::vector>( - Command::WRA + 1, ControllerVector(memSpec.dimmRanksPerChannel)); - lastBurstLengthByCommandAndPhysicalRank = std::vector>( - Command::WRA + 1, - ControllerVector(memSpec.physicalRanksPerChannel)); - lastBurstLengthByCommandAndLogicalRank = std::vector>( - Command::WRA + 1, ControllerVector(memSpec.logicalRanksPerChannel)); - lastBurstLengthByCommandAndBankGroup = std::vector>( - Command::WRA + 1, ControllerVector(memSpec.bankGroupsPerChannel)); - lastBurstLengthByCommandAndBank = std::vector>( - Command::WRA + 1, ControllerVector(memSpec.banksPerChannel)); - lastBurstLengthByCommand = std::vector(Command::WRA + 1); - lastBurstLengthByCommandAndBankInGroup = std::vector>( - Command::WRA + 1, - ControllerVector(memSpec.ranksPerChannel * memSpec.banksPerGroup)); - - cmdLengthDiff = memSpec.cmdMode * memSpec.tCK; - - tBURST16 = 8 * memSpec.tCK; - tBURST32 = 16 * memSpec.tCK; - tWTRA = memSpec.tWR - memSpec.tRTP; - tWRRDA = memSpec.tWL + tBURST16 + tWTRA; // tWTRA = tWR - tRTP - tWRPRE = memSpec.tWL + tBURST16 + memSpec.tWR; - tRDAACT = memSpec.tRTP + memSpec.tRP; - tWRAACT = tWRPRE + memSpec.tRP; - tCCD_L_RTW_slr = memSpec.tRL - memSpec.tWL + tBURST16 + 2 * memSpec.tCK - memSpec.tRDDQS + - memSpec.tRPST + memSpec.tWPRE; - tCCD_S_RTW_slr = memSpec.tRL - memSpec.tWL + tBURST16 + 2 * memSpec.tCK - memSpec.tRDDQS + - memSpec.tRPST + memSpec.tWPRE; - tCCD_RTW_dlr = memSpec.tRL - memSpec.tWL + tBURST16 + 2 * memSpec.tCK - memSpec.tRDDQS + - memSpec.tRPST + memSpec.tWPRE; - tRDRD_dpr = tBURST16 + memSpec.tRTRS; - tRDRD_ddr = tBURST16 + memSpec.tRTRS; - tRDWR_dpr = memSpec.tRL - memSpec.tWL + tBURST16 + memSpec.tRTRS - memSpec.tRDDQS + - memSpec.tRPST + memSpec.tWPRE; - tRDWR_ddr = memSpec.tRL - memSpec.tWL + tBURST16 + memSpec.tRTRS - memSpec.tRDDQS + - memSpec.tRPST + memSpec.tWPRE; - tCCD_L_WTR_slr = memSpec.tWL + tBURST16 + memSpec.tWTR_L; - tCCD_M_WTR_slr = memSpec.tWL + tBURST16 + memSpec.tWTR_M; // tWTR_M is max(16nck, 10ns) - tCCD_S_WTR_slr = memSpec.tWL + tBURST16 + memSpec.tWTR_S; - tCCD_WTR_dlr = memSpec.tWL + tBURST16 + memSpec.tWTR_S; - tWRWR_dpr = std::max(memSpec.tCCD_WR_dpr, tBURST16 + memSpec.tRTRS); - tWRWR_ddr = tBURST16 + memSpec.tRTRS; - tWRRD_dpr = memSpec.tWL - memSpec.tRL + tBURST16 + memSpec.tRTRS + memSpec.tRDDQS + - memSpec.tWPST + memSpec.tRPRE; - tWRRD_ddr = memSpec.tWL - memSpec.tRL + tBURST16 + memSpec.tRTRS + memSpec.tRDDQS + - memSpec.tWPST + memSpec.tRPRE; - tRDPDEN = memSpec.tRL + tBURST16 + cmdLengthDiff; - tWRPDEN = memSpec.tWL + tBURST16 + memSpec.tWR + cmdLengthDiff; - tWRAPDEN = memSpec.tWL + tBURST16 + memSpec.tWR + cmdLengthDiff; + cmdLengthDiff = (memSpec.cmdMode * memSpec.tCK); + tBURST16 = (memSpec.tCK * 8); + tBURST32 = (memSpec.tCK * 16); + tWTRA = (memSpec.tWR - memSpec.tRTP); + tWRRDA = ((memSpec.tWL + tBURST16) + tWTRA); + tWRPRE = ((memSpec.tWL + tBURST16) + memSpec.tWR); + tRDAACT = (memSpec.tRTP + memSpec.tRP); + tWRAACT = (tWRPRE + memSpec.tRP); + tCCD_L_RTW_slr = ((((((memSpec.tRL - memSpec.tWL) + tBURST16) + (memSpec.tCK * 2)) - memSpec.tRDDQS) + memSpec.tRPST) + memSpec.tWPRE); + tCCD_S_RTW_slr = ((((((memSpec.tRL - memSpec.tWL) + tBURST16) + (memSpec.tCK * 2)) - memSpec.tRDDQS) + memSpec.tRPST) + memSpec.tWPRE); + tCCD_RTW_dlr = ((((((memSpec.tRL - memSpec.tWL) + tBURST16) + (memSpec.tCK * 2)) - memSpec.tRDDQS) + memSpec.tRPST) + memSpec.tWPRE); + tRDRD_dpr = (tBURST16 + memSpec.tRTRS); + tRDRD_ddr = (tBURST16 + memSpec.tRTRS); + tRDWR_dpr = ((((((memSpec.tRL - memSpec.tWL) + tBURST16) + memSpec.tRTRS) - memSpec.tRDDQS) + memSpec.tRPST) + memSpec.tWPRE); + tRDWR_ddr = ((((((memSpec.tRL - memSpec.tWL) + tBURST16) + memSpec.tRTRS) - memSpec.tRDDQS) + memSpec.tRPST) + memSpec.tWPRE); + tCCD_L_WTR_slr = ((memSpec.tWL + tBURST16) + memSpec.tWTR_L); + tCCD_M_WTR_slr = ((memSpec.tWL + tBURST16) + memSpec.tWTR_M); + tCCD_S_WTR_slr = ((memSpec.tWL + tBURST16) + memSpec.tWTR_S); + tCCD_WTR_dlr = ((memSpec.tWL + tBURST16) + memSpec.tWTR_S); + tWRWR_dpr = std::max(memSpec.tCCD_WR_dpr, (tBURST16 + memSpec.tRTRS)); + tWRWR_ddr = (tBURST16 + memSpec.tRTRS); + tWRRD_dpr = ((((((memSpec.tWL - memSpec.tRL) + tBURST16) + memSpec.tRTRS) + memSpec.tRDDQS) + memSpec.tWPST) + memSpec.tRPRE); + tWRRD_ddr = ((((((memSpec.tWL - memSpec.tRL) + tBURST16) + memSpec.tRTRS) + memSpec.tRDDQS) + memSpec.tWPST) + memSpec.tRPRE); + tRDPDEN = (((memSpec.tRL + tBURST16) + memSpec.tCK) + cmdLengthDiff); + tWRPDEN = ((((memSpec.tWL + tBURST16) + memSpec.tWR) + memSpec.tCK) + cmdLengthDiff); + tWRAPDEN = ((((memSpec.tWL + tBURST16) + memSpec.tWR) + memSpec.tCK) + cmdLengthDiff); + } -sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, - const tlm_generic_payload& payload) const +sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic_payload& payload) const { - LogicalRank logicalRank = LogicalRank(ControllerExtension::getRank(payload)); - PhysicalRank physicalRank = - PhysicalRank(static_cast(logicalRank) / memSpec.logicalRanksPerPhysicalRank); - DimmRank dimmRank = - DimmRank(static_cast(physicalRank) / memSpec.physicalRanksPerDimmRank); - BankGroup bankGroup = ControllerExtension::getBankGroup(payload); Bank bank = ControllerExtension::getBank(payload); - Bank bankInGroup = Bank(static_cast(logicalRank) * memSpec.banksPerGroup + - static_cast(bank) % memSpec.banksPerGroup); + BankGroup bankGroup = ControllerExtension::getBankGroup(payload); + LogicalRank logicalRank{static_cast(ControllerExtension::getRank(payload))}; + PhysicalRank physicalRank{static_cast(logicalRank) / memSpec.logicalRanksPerPhysicalRank}; + DimmRank dimmRank{static_cast(physicalRank) / memSpec.physicalRanksPerDimmRank}; + - sc_time lastCommandStart; sc_time earliestTimeToStart = sc_time_stamp(); - if (command == Command::RD || command == Command::RDA) - { - unsigned burstLength = ControllerExtension::getBurstLength(payload); - assert((burstLength == 16) || (burstLength == 32)); - assert(!(burstLength == 32) || (memSpec.bitWidth == 4)); - assert(burstLength <= memSpec.maxBurstLength); - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L_slr); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_M_slr); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RD][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S_slr); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RD][physicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndPhysicalRank[Command::RD][physicalRank] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST32); - - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_dlr); - } - - lastCommandStart = lastScheduledByCommand[Command::RD]; - if (lastCommandStart != - lastScheduledByCommandAndPhysicalRank[Command::RD] - [physicalRank]) // different physical rank - { - if (lastCommandStart == - lastScheduledByCommandAndDimmRank[Command::RD][dimmRank]) // same DIMM - { - if (lastBurstLengthByCommandAndDimmRank[Command::RD][dimmRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDRD_dpr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDRD_dpr); - } - else // different DIMM - { - if (lastBurstLengthByCommand[Command::RD] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDRD_ddr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDRD_ddr); - } - } - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_M_slr); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RDA][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S_slr); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RDA][physicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndPhysicalRank[Command::RDA][physicalRank] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST32); - - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_dlr); - } - - lastCommandStart = lastScheduledByCommand[Command::RDA]; - if (lastCommandStart != - lastScheduledByCommandAndPhysicalRank[Command::RDA] - [physicalRank]) // different physical rank - { - if (lastCommandStart == - lastScheduledByCommandAndDimmRank[Command::RDA][dimmRank]) // same DIMM - { - if (lastBurstLengthByCommandAndDimmRank[Command::RDA][dimmRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDRD_dpr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDRD_dpr); - } - else // different DIMM - { - if (lastBurstLengthByCommand[Command::RDA] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDRD_ddr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDRD_ddr); - } - } - - if (command == Command::RDA) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBank[Command::WR][bank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRRDA + tBURST16); - else - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDA); - } - } - - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBank[Command::WR][bank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_L_WTR_slr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_L_WTR_slr); - } - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_M_WTR_slr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_M_WTR_slr); - } - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WR][logicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndLogicalRank[Command::WR][logicalRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_S_WTR_slr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_S_WTR_slr); - } - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::WR][physicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndPhysicalRank[Command::WR][physicalRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_WTR_dlr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_WTR_dlr); - } - - lastCommandStart = lastScheduledByCommand[Command::WR]; - if (lastCommandStart != - lastScheduledByCommandAndPhysicalRank[Command::WR] - [physicalRank]) // different physical rank - { - if (lastCommandStart == - lastScheduledByCommandAndDimmRank[Command::WR][dimmRank]) // same DIMM - { - if (lastBurstLengthByCommandAndDimmRank[Command::WR][dimmRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRRD_dpr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRRD_dpr); - } - else // different DIMM - { - if (lastBurstLengthByCommand[Command::WR] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRRD_ddr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRRD_ddr); - } - } - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_M_WTR_slr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_M_WTR_slr); - } - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WRA][logicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndLogicalRank[Command::WRA][logicalRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_S_WTR_slr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_S_WTR_slr); - } - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::WRA][physicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndPhysicalRank[Command::WRA][physicalRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_WTR_dlr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_WTR_dlr); - } - - lastCommandStart = lastScheduledByCommand[Command::WRA]; - if (lastCommandStart != - lastScheduledByCommandAndPhysicalRank[Command::WRA] - [physicalRank]) // different physical rank - { - if (lastCommandStart == - lastScheduledByCommandAndDimmRank[Command::WRA][dimmRank]) // same DIMM - { - if (lastBurstLengthByCommandAndDimmRank[Command::WRA][dimmRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRRD_dpr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRRD_dpr); - } - else // different DIMM - { - if (lastBurstLengthByCommand[Command::WRA] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRRD_ddr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRRD_ddr); - } - } - } - else if (command == Command::WR || command == Command::WRA || command == Command::MWR || - command == Command::MWRA) - { - unsigned burstLength = ControllerExtension::getBurstLength(payload); - assert((burstLength == 16) || (burstLength == 32)); - assert(!(burstLength == 32) || (memSpec.bitWidth == 4)); - assert(burstLength <= memSpec.maxBurstLength); - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankGroup[Command::RD][bankGroup] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_L_RTW_slr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_L_RTW_slr); - } - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RD][logicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndLogicalRank[Command::RD][logicalRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_S_RTW_slr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_S_RTW_slr); - } - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RD][physicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndPhysicalRank[Command::RD][physicalRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_RTW_dlr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_RTW_dlr); - } - - lastCommandStart = lastScheduledByCommand[Command::RD]; - if (lastCommandStart != - lastScheduledByCommandAndPhysicalRank[Command::RD] - [physicalRank]) // different physical rank - { - if (lastCommandStart == - lastScheduledByCommandAndDimmRank[Command::RD][dimmRank]) // same DIMM - { - if (lastBurstLengthByCommandAndDimmRank[Command::RD][dimmRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDWR_dpr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDWR_dpr); - } - else // different DIMM - { - if (lastBurstLengthByCommand[Command::RD] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDWR_ddr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDWR_ddr); - } - } - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankGroup[Command::RDA][bankGroup] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_L_RTW_slr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_L_RTW_slr); - } - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RDA][logicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndLogicalRank[Command::RDA][logicalRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_S_RTW_slr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_S_RTW_slr); - } - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RDA][physicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndPhysicalRank[Command::RDA][physicalRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_RTW_dlr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tCCD_RTW_dlr); - } - - lastCommandStart = lastScheduledByCommand[Command::RDA]; - if (lastCommandStart != - lastScheduledByCommandAndPhysicalRank[Command::RDA] - [physicalRank]) // different physical rank - { - if (lastCommandStart == - lastScheduledByCommandAndDimmRank[Command::RDA][dimmRank]) // same DIMM - { - if (lastBurstLengthByCommandAndDimmRank[Command::RDA][dimmRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDWR_dpr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDWR_dpr); - } - else // different DIMM - { - if (lastBurstLengthByCommand[Command::RDA] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDWR_ddr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDWR_ddr); - } - } - - if (memSpec.requiresMaskedWrite(payload)) // second WR requires RMW - { - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBank[Command::WR][bank] == 32) - { - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tBURST16 + memSpec.tCCD_L_WR_slr); - } - else - { - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L_WR_slr); - } - } - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup]; - if (lastCommandStart != - lastScheduledByCommandAndBank[Command::WR][bank]) // different bank - { - if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup] == 32) - { - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tBURST16 + memSpec.tCCD_M_WR_slr); - } - else - { - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_M_WR_slr); - } - } - } - else // no RMW - { - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup] == 32) - { - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tBURST16 + memSpec.tCCD_L_WR2_slr); - } - else - { - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L_WR2_slr); - } - } - } - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WR][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S_WR_slr); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::WR][physicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndPhysicalRank[Command::WR][physicalRank] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST32); - - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_WR_dlr); - } - - lastCommandStart = lastScheduledByCommand[Command::WR]; - if (lastCommandStart != - lastScheduledByCommandAndPhysicalRank[Command::WR] - [physicalRank]) // different physical rank - { - if (lastCommandStart == - lastScheduledByCommandAndDimmRank[Command::WR][dimmRank]) // same DIMM - { - if (lastBurstLengthByCommandAndDimmRank[Command::WR][dimmRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRWR_dpr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRWR_dpr); - } - else // different DIMM - { - if (lastBurstLengthByCommand[Command::WR] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRWR_ddr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRWR_ddr); - } - } - - if (memSpec.requiresMaskedWrite(payload)) // second WR requires RMW - { - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup] == 32) - { - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tBURST16 + memSpec.tCCD_M_WR_slr); - } - else - { - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_M_WR_slr); - } - } - } - else // no RMW - { - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup] == 32) - { - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tBURST16 + memSpec.tCCD_L_WR2_slr); - } - else - { - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L_WR2_slr); - } - } - } - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WRA][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S_WR_slr); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::WRA][physicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndPhysicalRank[Command::WRA][physicalRank] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST32); - - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_WR_dlr); - } - - lastCommandStart = lastScheduledByCommand[Command::WRA]; - if (lastCommandStart != - lastScheduledByCommandAndPhysicalRank[Command::WRA] - [physicalRank]) // different physical rank - { - if (lastCommandStart == - lastScheduledByCommandAndDimmRank[Command::WRA][dimmRank]) // same DIMM - { - if (lastBurstLengthByCommandAndDimmRank[Command::WRA][dimmRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRWR_dpr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRWR_dpr); - } - else // different DIMM - { - if (lastBurstLengthByCommand[Command::WRA] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRWR_ddr + tBURST16); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRWR_ddr); - } - } - } - else if (command == Command::ACT) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD_L_slr); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::ACT][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD_S_slr); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::ACT][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD_dlr); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDAACT); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBank[Command::WRA][bank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRAACT + tBURST16); - else - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAACT); - } - - lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::PREAB][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::PRESB][bankInGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFAB][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_slr - cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMAB][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_slr - cmdLengthDiff); - - // TODO: No tRFC_dlr and tRFC_dpr between REFAB and ACT? - - lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::REFSB][bankInGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRFCsb_slr - cmdLengthDiff); - - // TODO: No tRFCsb_dlr between REFSB and ACT? - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFSB][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + memSpec.tREFSBRD_slr - cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::REFSB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + memSpec.tREFSBRD_dlr - cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::RFMSB][bankInGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRFCsb_slr - cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMSB][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + memSpec.tREFSBRD_slr - cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RFMSB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + memSpec.tREFSBRD_dlr - cmdLengthDiff); - - if (last4ActivatesLogical[logicalRank].size() >= 4) - earliestTimeToStart = std::max(earliestTimeToStart, - last4ActivatesLogical[logicalRank].front() + - memSpec.tFAW_slr - memSpec.longCmdOffset); - - if (last4ActivatesPhysical[physicalRank].size() >= 4) - earliestTimeToStart = std::max(earliestTimeToStart, - last4ActivatesPhysical[physicalRank].front() + - memSpec.tFAW_dlr - memSpec.longCmdOffset); - } - else if (command == Command::PREPB) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBank[Command::WR][bank] == 32) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tWRPRE + tBURST16 + cmdLengthDiff); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + cmdLengthDiff); - } - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREPB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREAB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PRESB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD); - } - else if (command == Command::PREAB) - { - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::ACT][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RD][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RDA][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WR][logicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndLogicalRank[Command::WR][logicalRank] == 32) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tWRPRE + tBURST16 + cmdLengthDiff); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + cmdLengthDiff); - } - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WRA][logicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndLogicalRank[Command::WRA][logicalRank]) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tWRPRE + tBURST16 + cmdLengthDiff); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + cmdLengthDiff); - } - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREPB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREAB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD); - - // PRESB tPPD - } - else if (command == Command::PRESB) - { - lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::ACT][bankInGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::RD][bankInGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::RDA][bankInGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::WR][bankInGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankInGroup[Command::WR][bankInGroup] == 32) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tWRPRE + tBURST16 + cmdLengthDiff); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + cmdLengthDiff); - } - - lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::WRA][bankInGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankInGroup[Command::WRA][bankInGroup] == 32) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tWRPRE + tBURST16 + cmdLengthDiff); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + cmdLengthDiff); - } - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREPB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD); - - // PREA tRP - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PRESB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD); - } - else if (command == Command::REFAB || command == Command::RFMAB) - { - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::ACT][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RDA][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDAACT + cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WRA][logicalRank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndLogicalRank[Command::WRA][logicalRank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + tWRPRE + tBURST16 + memSpec.tRP + cmdLengthDiff); - else - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP + cmdLengthDiff); - } - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::PREPB][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::PREAB][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFAB][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_slr); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::REFAB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dlr); - - lastCommandStart = lastScheduledByCommandAndDimmRank[Command::REFAB][dimmRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dpr); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMAB][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_slr); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RFMAB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dlr); - - lastCommandStart = lastScheduledByCommandAndDimmRank[Command::RFMAB][dimmRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dpr); - - // REFSB tRFCsb_slr/dlr - // PRESB tRP - } - else if (command == Command::REFSB || command == Command::RFMSB) - { - lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::ACT][bankInGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::ACT][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRRD_L_slr + cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::RDA][bankInGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDAACT + cmdLengthDiff); - - lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::WRA][bankInGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankInGroup[Command::WRA][bankInGroup] == 32) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tWRAACT + tBURST16 + cmdLengthDiff); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRAACT + cmdLengthDiff); - } - - lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::PREPB][bankInGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - // PREA tRP - - lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::PRESB][bankInGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFAB][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_slr); - - // TODO: check this - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::REFAB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dlr); - - // TODO: check this - lastCommandStart = lastScheduledByCommandAndDimmRank[Command::REFAB][dimmRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dpr); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMAB][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_slr); - - // TODO: check this - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RFMAB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dlr); - - // TODO: check this - lastCommandStart = lastScheduledByCommandAndDimmRank[Command::RFMAB][dimmRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dpr); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFSB][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCsb_slr); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::REFSB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCsb_dlr); - - lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMSB][logicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCsb_slr); - - lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RFMSB][physicalRank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCsb_dlr); - - if (last4ActivatesLogical[logicalRank].size() >= 4) - earliestTimeToStart = std::max(earliestTimeToStart, - last4ActivatesLogical[logicalRank].front() + - memSpec.tFAW_slr - memSpec.shortCmdOffset); - - if (last4ActivatesPhysical[physicalRank].size() >= 4) - earliestTimeToStart = std::max(earliestTimeToStart, - last4ActivatesPhysical[physicalRank].front() + - memSpec.tFAW_dlr - memSpec.shortCmdOffset); - } - else - SC_REPORT_FATAL("CheckerDDR5", "Unknown command!"); - - if (lastCommandOnBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK); - - if (dummyCommandOnBus.start != scMaxTime) - { - TimeInterval currentCommandOnBus(earliestTimeToStart, - earliestTimeToStart + memSpec.getCommandLength(command)); - if (currentCommandOnBus.intersects(dummyCommandOnBus)) - earliestTimeToStart = dummyCommandOnBus.end; - } + + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByBank[command][bank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByBankGroup[command][bankGroup]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByLogicalRank[command][logicalRank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByPhysicalRank[command][physicalRank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByDimmRank[command][dimmRank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandOnBus); return earliestTimeToStart; } void CheckerDDR5::insert(Command command, const tlm_generic_payload& payload) { - LogicalRank logicalRank = LogicalRank(ControllerExtension::getRank(payload)); - PhysicalRank physicalRank = - PhysicalRank(static_cast(logicalRank) / memSpec.logicalRanksPerPhysicalRank); - DimmRank dimmRank = - DimmRank(static_cast(physicalRank) / memSpec.physicalRanksPerDimmRank); - BankGroup bankGroup = ControllerExtension::getBankGroup(payload); - Bank bank = ControllerExtension::getBank(payload); - Bank bankInGroup = Bank(static_cast(logicalRank) * memSpec.banksPerGroup + - static_cast(bank) % memSpec.banksPerGroup); - unsigned burstLength = ControllerExtension::getBurstLength(payload); + const Bank bank = ControllerExtension::getBank(payload); + const BankGroup bankGroup = ControllerExtension::getBankGroup(payload); + const LogicalRank logicalRank{static_cast(ControllerExtension::getRank(payload))}; + const PhysicalRank physicalRank{static_cast(logicalRank) / memSpec.logicalRanksPerPhysicalRank}; + const DimmRank dimmRank{static_cast(physicalRank) / memSpec.physicalRanksPerDimmRank}; + const unsigned burstLength = ControllerExtension::getBurstLength(payload); - // Hack: Convert MWR to WR and MWRA to WRA - if (command == Command::MWR) - command = Command::WR; - else if (command == Command::MWRA) - command = Command::WRA; - - PRINTDEBUGMESSAGE("CheckerDDR5", - "Changing state on bank " + std::to_string(static_cast(bank)) + - " command is " + command.toString()); - - lastScheduledByCommandAndDimmRank[command][dimmRank] = sc_time_stamp(); - lastScheduledByCommandAndPhysicalRank[command][physicalRank] = sc_time_stamp(); - lastScheduledByCommandAndLogicalRank[command][logicalRank] = sc_time_stamp(); - lastScheduledByCommandAndBankGroup[command][bankGroup] = sc_time_stamp(); - lastScheduledByCommandAndBank[command][bank] = sc_time_stamp(); - lastScheduledByCommand[command] = sc_time_stamp(); - lastScheduledByCommandAndBankInGroup[command][bankInGroup] = sc_time_stamp(); - - if (command.isCasCommand()) + PRINTDEBUGMESSAGE("CheckerDDR5", "Changing state on bank " + std::to_string(static_cast(bank)) + + " command is " + command.toString()); + + const sc_time& currentTime = sc_time_stamp(); + + switch (command) { - lastBurstLengthByCommandAndDimmRank[command][dimmRank] = burstLength; - lastBurstLengthByCommandAndPhysicalRank[command][physicalRank] = burstLength; - lastBurstLengthByCommandAndLogicalRank[command][logicalRank] = burstLength; - lastBurstLengthByCommandAndBankGroup[command][bankGroup] = burstLength; - lastBurstLengthByCommandAndBank[command][bank] = burstLength; - lastBurstLengthByCommand[command] = burstLength; - lastBurstLengthByCommandAndBankInGroup[command][bankInGroup] = burstLength; - - if (burstLength == 32) + case Command::RD: + { + // Bank (RD,RD) memSpec.tCCD_L_slr [] SameComponent() { - dummyCommandOnBus.start = sc_time_stamp() + tBURST16; - dummyCommandOnBus.end = sc_time_stamp() + tBURST16 + memSpec.getCommandLength(command); + const sc_time constraint = currentTime + memSpec.tCCD_L_slr; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); } + + // Bank (RD,RDA) memSpec.tCCD_L_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L_slr; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RD,RD) memSpec.tCCD_M_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_M_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RD,RDA) memSpec.tCCD_M_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_M_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (RD,RD) memSpec.tCCD_S_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RD][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (RD,RDA) memSpec.tCCD_S_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RDA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (RD,RD) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RD,RDA) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RD,RD) memSpec.tCCD_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (RD,RDA) memSpec.tCCD_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (RD,RD) (tRDRD_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDRD_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RD,RDA) (tRDRD_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDRD_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RD,RD) tRDRD_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDRD_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RD,RDA) tRDRD_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDRD_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,RD) (tRDRD_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDRD_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RD][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,RDA) (tRDRD_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDRD_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RDA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,RD) tRDRD_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDRD_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RD][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,RDA) tRDRD_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDRD_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RDA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // BankGroup (RD,WR) (tCCD_L_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_L_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,WRA) (tCCD_L_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_L_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,MWR) (tCCD_L_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_L_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,MWRA) (tCCD_L_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_L_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,WR) tCCD_L_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_L_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,WRA) tCCD_L_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_L_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,MWR) tCCD_L_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_L_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,MWRA) tCCD_L_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_L_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RD,WR) (tCCD_S_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RD,WRA) (tCCD_S_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RD,MWR) (tCCD_S_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RD,MWRA) (tCCD_S_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RD,WR) tCCD_S_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RD,WRA) tCCD_S_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RD,MWR) tCCD_S_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RD,MWRA) tCCD_S_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RD,WR) (tCCD_RTW_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_RTW_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RD,WRA) (tCCD_RTW_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_RTW_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RD,MWR) (tCCD_RTW_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_RTW_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RD,MWRA) (tCCD_RTW_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_RTW_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RD,WR) tCCD_RTW_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_RTW_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RD,WRA) tCCD_RTW_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_RTW_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RD,MWR) tCCD_RTW_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_RTW_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RD,MWRA) tCCD_RTW_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_RTW_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // DimmRank (RD,WR) (tRDWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RD,WRA) (tRDWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RD,MWR) (tRDWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RD,MWRA) (tRDWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RD,WR) tRDWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RD,WRA) tRDWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RD,MWR) tRDWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RD,MWRA) tRDWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,WR) (tRDWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,WRA) (tRDWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,MWR) (tRDWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,MWRA) (tRDWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,WR) tRDWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,WRA) tRDWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,MWR) tRDWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,MWRA) tRDWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Bank (RD,PREPB) (memSpec.tRTP + cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRTP + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (RD,PREAB) (memSpec.tRTP + cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRTP + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::PREAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RD,PRESB) (memSpec.tRTP + cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (memSpec.tRTP + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PRESB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; } - - lastCommandOnBus = sc_time_stamp() + memSpec.getCommandLength(command) - memSpec.tCK; - - if (command == Command::ACT || command == Command::REFSB || command == Command::RFMSB) + case Command::WR: { - if (last4ActivatesLogical[logicalRank].size() == 4) - last4ActivatesLogical[logicalRank].pop(); - last4ActivatesLogical[logicalRank].push(lastCommandOnBus); + // Bank (WR,RDA) (tWRRDA + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRDA + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,RDA) (tWRRDA + tBURST16) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRRDA + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,RD) (tCCD_L_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_L_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,RDA) (tCCD_L_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_L_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,RD) tCCD_L_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_L_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,RDA) tCCD_L_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_L_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,RD) (tCCD_M_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_M_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,RDA) (tCCD_M_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_M_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,RD) tCCD_M_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_M_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,RDA) tCCD_M_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_M_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WR,RD) (tCCD_S_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RD][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WR,RDA) (tCCD_S_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RDA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WR,RD) tCCD_S_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RD][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WR,RDA) tCCD_S_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RDA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WR,RD) (tCCD_WTR_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_WTR_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WR,RDA) (tCCD_WTR_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_WTR_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WR,RD) tCCD_WTR_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_WTR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WR,RDA) tCCD_WTR_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_WTR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // DimmRank (WR,RD) (tWRRD_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WR,RDA) (tWRRD_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WR,RD) tWRRD_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WR,RDA) tWRRD_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,RD) (tWRRD_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RD][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,RDA) (tWRRD_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RDA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,RD) tWRRD_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RD][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,RDA) tWRRD_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RDA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Bank (WR,MWR) (memSpec.tCCD_L_WR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_L_WR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,MWRA) (memSpec.tCCD_L_WR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_L_WR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,MWR) memSpec.tCCD_L_WR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_L_WR_slr; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,MWRA) memSpec.tCCD_L_WR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_L_WR_slr; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,MWR) (memSpec.tCCD_M_WR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_M_WR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,MWRA) (memSpec.tCCD_M_WR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_M_WR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,MWR) memSpec.tCCD_M_WR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_M_WR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,MWRA) memSpec.tCCD_M_WR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_M_WR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,WR) (memSpec.tCCD_L_WR2_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_L_WR2_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,WRA) (memSpec.tCCD_L_WR2_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_L_WR2_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,WR) memSpec.tCCD_L_WR2_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_L_WR2_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,WRA) memSpec.tCCD_L_WR2_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_L_WR2_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WR,WR) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (WR,WRA) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (WR,MWR) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (WR,MWRA) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (WR,WR) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WR,WRA) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WR,MWR) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WR,MWRA) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WR,WR) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (WR,WRA) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (WR,MWR) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (WR,MWRA) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (WR,WR) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WR,WRA) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WR,MWR) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WR,MWRA) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WR,WR) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WR,WRA) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WR,MWR) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WR,MWRA) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,WR) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,WRA) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,MWR) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,MWRA) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,WR) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,WRA) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,MWR) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,MWRA) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Bank (WR,PREPB) ((tWRPRE + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRPRE + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,PREPB) (tWRPRE + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRPRE + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WR,PREAB) ((tWRPRE + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRPRE + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::PREAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WR,PREAB) (tWRPRE + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRPRE + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::PREAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,PRESB) ((tWRPRE + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponentsIn(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRPRE + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PRESB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,PRESB) (tWRPRE + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponentsIn(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRPRE + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PRESB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + - if (last4ActivatesPhysical[physicalRank].size() == 4) - last4ActivatesPhysical[physicalRank].pop(); - last4ActivatesPhysical[physicalRank].push(lastCommandOnBus); + break; } + case Command::MWR: + { + // Bank (MWR,RDA) (tWRRDA + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRDA + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,RDA) (tWRRDA + tBURST16) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRRDA + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,RD) (tCCD_L_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_L_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,RDA) (tCCD_L_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_L_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,RD) tCCD_L_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_L_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,RDA) tCCD_L_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_L_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,RD) (tCCD_M_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_M_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,RDA) (tCCD_M_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_M_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,RD) tCCD_M_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_M_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,RDA) tCCD_M_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_M_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWR,RD) (tCCD_S_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RD][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWR,RDA) (tCCD_S_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RDA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWR,RD) tCCD_S_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RD][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWR,RDA) tCCD_S_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RDA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWR,RD) (tCCD_WTR_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_WTR_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWR,RDA) (tCCD_WTR_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_WTR_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWR,RD) tCCD_WTR_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_WTR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWR,RDA) tCCD_WTR_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_WTR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // DimmRank (MWR,RD) (tWRRD_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWR,RDA) (tWRRD_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWR,RD) tWRRD_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWR,RDA) tWRRD_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,RD) (tWRRD_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RD][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,RDA) (tWRRD_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RDA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,RD) tWRRD_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RD][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,RDA) tWRRD_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RDA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Bank (MWR,MWR) (memSpec.tCCD_L_WR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_L_WR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,MWRA) (memSpec.tCCD_L_WR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_L_WR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,MWR) memSpec.tCCD_L_WR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_L_WR_slr; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,MWRA) memSpec.tCCD_L_WR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_L_WR_slr; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,MWR) (memSpec.tCCD_M_WR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_M_WR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,MWRA) (memSpec.tCCD_M_WR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_M_WR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,MWR) memSpec.tCCD_M_WR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_M_WR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,MWRA) memSpec.tCCD_M_WR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_M_WR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,WR) (memSpec.tCCD_L_WR2_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_L_WR2_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,WRA) (memSpec.tCCD_L_WR2_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_L_WR2_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,WR) memSpec.tCCD_L_WR2_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_L_WR2_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,WRA) memSpec.tCCD_L_WR2_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_L_WR2_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWR,WR) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (MWR,WRA) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (MWR,MWR) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (MWR,MWRA) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (MWR,WR) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWR,WRA) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWR,MWR) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWR,MWRA) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWR,WR) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (MWR,WRA) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (MWR,MWR) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (MWR,MWRA) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (MWR,WR) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWR,WRA) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWR,MWR) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWR,MWRA) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWR,WR) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWR,WRA) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWR,MWR) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWR,MWRA) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,WR) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,WRA) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,MWR) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,MWRA) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,WR) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,WRA) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,MWR) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,MWRA) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Bank (MWR,PREPB) ((tWRPRE + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRPRE + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,PREPB) (tWRPRE + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRPRE + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWR,PREAB) ((tWRPRE + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRPRE + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::PREAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWR,PREAB) (tWRPRE + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRPRE + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::PREAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,PRESB) ((tWRPRE + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponentsIn(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRPRE + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PRESB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,PRESB) (tWRPRE + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponentsIn(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRPRE + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PRESB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::RDA: + { + // BankGroup (RDA,RD) memSpec.tCCD_M_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_M_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RDA,RDA) memSpec.tCCD_M_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_M_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (RDA,RD) memSpec.tCCD_S_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RD][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (RDA,RDA) memSpec.tCCD_S_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RDA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (RDA,RD) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RDA,RDA) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RDA,RD) memSpec.tCCD_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (RDA,RDA) memSpec.tCCD_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (RDA,RD) (tRDRD_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDRD_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RDA,RDA) (tRDRD_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDRD_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RDA,RD) tRDRD_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDRD_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RDA,RDA) tRDRD_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDRD_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,RD) (tRDRD_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDRD_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RD][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,RDA) (tRDRD_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDRD_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RDA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,RD) tRDRD_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDRD_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RD][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,RDA) tRDRD_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDRD_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RDA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // BankGroup (RDA,WR) (tCCD_L_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_L_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,WRA) (tCCD_L_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_L_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,MWR) (tCCD_L_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_L_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,MWRA) (tCCD_L_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_L_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,WR) tCCD_L_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_L_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,WRA) tCCD_L_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_L_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,MWR) tCCD_L_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_L_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,MWRA) tCCD_L_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_L_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RDA,WR) (tCCD_S_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RDA,WRA) (tCCD_S_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RDA,MWR) (tCCD_S_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RDA,MWRA) (tCCD_S_RTW_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_RTW_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RDA,WR) tCCD_S_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RDA,WRA) tCCD_S_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RDA,MWR) tCCD_S_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (RDA,MWRA) tCCD_S_RTW_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_RTW_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RDA,WR) (tCCD_RTW_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_RTW_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RDA,WRA) (tCCD_RTW_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_RTW_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RDA,MWR) (tCCD_RTW_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_RTW_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RDA,MWRA) (tCCD_RTW_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_RTW_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RDA,WR) tCCD_RTW_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_RTW_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RDA,WRA) tCCD_RTW_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_RTW_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RDA,MWR) tCCD_RTW_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_RTW_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (RDA,MWRA) tCCD_RTW_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_RTW_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // DimmRank (RDA,WR) (tRDWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RDA,WRA) (tRDWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RDA,MWR) (tRDWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RDA,MWRA) (tRDWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RDA,WR) tRDWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RDA,WRA) tRDWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RDA,MWR) tRDWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (RDA,MWRA) tRDWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,WR) (tRDWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,WRA) (tRDWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,MWR) (tRDWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,MWRA) (tRDWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tRDWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,WR) tRDWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,WRA) tRDWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,MWR) tRDWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,MWRA) tRDWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tRDWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Bank (RDA,ACT) tRDAACT [] SameComponent() + { + const sc_time constraint = currentTime + tRDAACT; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RDA,PRESB) (memSpec.tRTP + cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (memSpec.tRTP + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PRESB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (RDA,REFAB) (tRDAACT + cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (tRDAACT + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::REFAB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (RDA,RFMAB) (tRDAACT + cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (tRDAACT + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RFMAB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RDA,REFSB) (tRDAACT + cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (tRDAACT + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RDA,RFMSB) (tRDAACT + cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (tRDAACT + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RFMSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::WRA: + { + // BankGroup (WRA,RD) (tCCD_M_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_M_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,RDA) (tCCD_M_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_M_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,RD) tCCD_M_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_M_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,RDA) tCCD_M_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_M_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WRA,RD) (tCCD_S_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RD][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WRA,RDA) (tCCD_S_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RDA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WRA,RD) tCCD_S_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RD][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WRA,RDA) tCCD_S_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RDA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WRA,RD) (tCCD_WTR_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_WTR_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WRA,RDA) (tCCD_WTR_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_WTR_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WRA,RD) tCCD_WTR_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_WTR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WRA,RDA) tCCD_WTR_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_WTR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // DimmRank (WRA,RD) (tWRRD_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WRA,RDA) (tWRRD_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WRA,RD) tWRRD_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WRA,RDA) tWRRD_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,RD) (tWRRD_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RD][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,RDA) (tWRRD_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RDA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,RD) tWRRD_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RD][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,RDA) tWRRD_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RDA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // BankGroup (WRA,MWR) (memSpec.tCCD_M_WR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_M_WR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,MWRA) (memSpec.tCCD_M_WR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_M_WR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,MWR) memSpec.tCCD_M_WR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_M_WR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,MWRA) memSpec.tCCD_M_WR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_M_WR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,WR) (memSpec.tCCD_L_WR2_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_L_WR2_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,WRA) (memSpec.tCCD_L_WR2_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_L_WR2_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,WR) memSpec.tCCD_L_WR2_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_L_WR2_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,WRA) memSpec.tCCD_L_WR2_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_L_WR2_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WRA,WR) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (WRA,WRA) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (WRA,MWR) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (WRA,MWRA) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (WRA,WR) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WRA,WRA) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WRA,MWR) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WRA,MWRA) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (WRA,WR) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (WRA,WRA) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (WRA,MWR) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (WRA,MWRA) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (WRA,WR) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WRA,WRA) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WRA,MWR) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WRA,MWRA) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WRA,WR) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WRA,WRA) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WRA,MWR) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (WRA,MWRA) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,WR) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,WRA) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,MWR) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,MWRA) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,WR) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,WRA) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,MWR) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,MWRA) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Bank (WRA,ACT) (tWRAACT + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRAACT + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,ACT) tWRAACT [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRAACT; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WRA,PREAB) ((tWRPRE + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRPRE + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::PREAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WRA,PREAB) (tWRPRE + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRPRE + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::PREAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,PRESB) ((tWRPRE + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponentsIn(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRPRE + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PRESB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,PRESB) (tWRPRE + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponentsIn(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRPRE + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PRESB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WRA,REFAB) ((memSpec.tRP + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tRP + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WRA,RFMAB) ((memSpec.tRP + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tRP + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WRA,REFAB) (memSpec.tRP + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.tRP + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (WRA,RFMAB) (memSpec.tRP + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.tRP + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,REFSB) ((tWRAACT + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponentsIn(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRAACT + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,RFMSB) ((tWRAACT + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponentsIn(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRAACT + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RFMSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,REFSB) (tWRAACT + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponentsIn(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRAACT + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,RFMSB) (tWRAACT + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponentsIn(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRAACT + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RFMSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::MWRA: + { + // BankGroup (MWRA,RD) (tCCD_M_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_M_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,RDA) (tCCD_M_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_M_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,RD) tCCD_M_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_M_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,RDA) tCCD_M_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_M_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWRA,RD) (tCCD_S_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RD][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWRA,RDA) (tCCD_S_WTR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_S_WTR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RDA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWRA,RD) tCCD_S_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RD][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWRA,RDA) tCCD_S_WTR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_S_WTR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RDA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWRA,RD) (tCCD_WTR_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_WTR_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWRA,RDA) (tCCD_WTR_dlr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tCCD_WTR_dlr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWRA,RD) tCCD_WTR_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_WTR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWRA,RDA) tCCD_WTR_dlr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tCCD_WTR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // DimmRank (MWRA,RD) (tWRRD_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWRA,RDA) (tWRRD_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWRA,RD) tWRRD_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RD][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWRA,RDA) tWRRD_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RDA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,RD) (tWRRD_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RD][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,RDA) (tWRRD_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRRD_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RDA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,RD) tWRRD_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RD][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,RDA) tWRRD_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRRD_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RDA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // BankGroup (MWRA,MWR) (memSpec.tCCD_M_WR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_M_WR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,MWRA) (memSpec.tCCD_M_WR_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_M_WR_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,MWR) memSpec.tCCD_M_WR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_M_WR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,MWRA) memSpec.tCCD_M_WR_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_M_WR_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,WR) (memSpec.tCCD_L_WR2_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_L_WR2_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,WRA) (memSpec.tCCD_L_WR2_slr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD_L_WR2_slr + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,WR) memSpec.tCCD_L_WR2_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_L_WR2_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,WRA) memSpec.tCCD_L_WR2_slr [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD_L_WR2_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWRA,WR) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (MWRA,WRA) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::WRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (MWRA,MWR) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWR][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (MWRA,MWRA) memSpec.tCCD_S_WR_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S_WR_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::MWRA][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (MWRA,WR) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWRA,WRA) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWRA,MWR) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWRA,MWRA) tBURST32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + tBURST32; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // PhysicalRank (MWRA,WR) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (MWRA,WRA) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (MWRA,MWR) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (MWRA,MWRA) memSpec.tCCD_WR_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_WR_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (MWRA,WR) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWRA,WRA) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWRA,MWR) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWRA,MWRA) (tWRWR_dpr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_dpr + tBURST16); + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWRA,WR) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWRA,WRA) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::WRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWRA,MWR) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWR][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // DimmRank (MWRA,MWRA) tWRWR_dpr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_dpr; + for (unsigned int i = memSpec.physicalRanksPerDimmRank * static_cast(dimmRank); i < memSpec.physicalRanksPerDimmRank * (1 + static_cast(dimmRank)); i++) + { + PhysicalRank currentPhysicalRank{i}; + + if (currentPhysicalRank == physicalRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::MWRA][currentPhysicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,WR) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,WRA) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,MWR) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,MWRA) (tWRWR_ddr + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (tWRWR_ddr + tBURST16); + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,WR) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,WRA) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::WRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,MWR) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWR][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,MWRA) tWRWR_ddr [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + tWRWR_ddr; + for (unsigned int i = memSpec.dimmRanksPerChannel * static_cast(0); i < memSpec.dimmRanksPerChannel * (1 + static_cast(0)); i++) + { + DimmRank currentDimmRank{i}; + + if (currentDimmRank == dimmRank) + continue; + + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::MWRA][currentDimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // LogicalRank (MWRA,PREAB) ((tWRPRE + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRPRE + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::PREAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWRA,PREAB) (tWRPRE + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRPRE + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::PREAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWRA,PRESB) ((tWRPRE + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponentsIn(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRPRE + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PRESB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWRA,PRESB) (tWRPRE + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponentsIn(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRPRE + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PRESB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWRA,REFAB) ((memSpec.tRP + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tRP + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWRA,RFMAB) ((memSpec.tRP + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tRP + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWRA,REFAB) (memSpec.tRP + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.tRP + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // LogicalRank (MWRA,RFMAB) (memSpec.tRP + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.tRP + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWRA,REFSB) ((tWRAACT + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponentsIn(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRAACT + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWRA,RFMSB) ((tWRAACT + cmdLengthDiff) + tBURST16) [LastBurstLength(burst_length=32, inversed=False)] SameComponentsIn(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((tWRAACT + cmdLengthDiff) + tBURST16); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RFMSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWRA,REFSB) (tWRAACT + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponentsIn(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRAACT + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWRA,RFMSB) (tWRAACT + cmdLengthDiff) [LastBurstLength(burst_length=32, inversed=True)] SameComponentsIn(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (tWRAACT + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RFMSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::ACT: + { + // Bank (ACT,RD) memSpec.tRCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,RDA) memSpec.tRCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WR) memSpec.tRCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WRA) memSpec.tRCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWR) memSpec.tRCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWRA) memSpec.tRCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,ACT) memSpec.tRC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRC; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (ACT,ACT) memSpec.tRRD_L_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRD_L_slr; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::ACT][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (ACT,ACT) memSpec.tRRD_S_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRD_S_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::ACT][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (ACT,ACT) memSpec.tRRD_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRD_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::ACT][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,PREPB) (memSpec.tRAS + cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRAS + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (ACT,PREAB) (memSpec.tRAS + cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRAS + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::PREAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,PRESB) (memSpec.tRAS + cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (memSpec.tRAS + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PRESB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (ACT,REFAB) (memSpec.tRC + cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRC + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (ACT,RFMAB) (memSpec.tRC + cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRC + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,REFSB) (memSpec.tRC + cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (memSpec.tRC + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,RFMSB) (memSpec.tRC + cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (memSpec.tRC + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RFMSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (ACT,REFSB) memSpec.tRRD_L_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRD_L_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (ACT,RFMSB) memSpec.tRRD_L_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRD_L_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnLogicalRank[logicalRank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnLogicalRank[logicalRank].size() >= 4) + { + sc_time constraint = last4ActivatesOnLogicalRank[logicalRank].front() - memSpec.getCommandLength(command) + memSpec.tFAW_slr; + { + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::ACT][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnLogicalRank[logicalRank].pop(); + } + last4ActivatesOnPhysicalRank[physicalRank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnPhysicalRank[physicalRank].size() >= 4) + { + sc_time constraint = last4ActivatesOnPhysicalRank[physicalRank].front() - memSpec.getCommandLength(command) + memSpec.tFAW_dlr; + { + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::ACT][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::REFSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RFMSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnPhysicalRank[physicalRank].pop(); + } + + break; + } + case Command::PREPB: + { + // Bank (PREPB,ACT) (memSpec.tRP - cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRP - cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (PREPB,PREPB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::PREPB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (PREPB,PREAB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::PREAB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (PREPB,PRESB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::PRESB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (PREPB,REFAB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (PREPB,RFMAB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (PREPB,REFSB) (memSpec.tRP + cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (memSpec.tRP + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (PREPB,RFMSB) (memSpec.tRP + cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (memSpec.tRP + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RFMSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PRESB: + { + // Bank (PRESB,ACT) (memSpec.tRP - cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (memSpec.tRP - cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (PRESB,PREPB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::PREPB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (PRESB,PRESB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::PRESB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (PRESB,REFSB) (memSpec.tRP + cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (memSpec.tRP + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (PRESB,RFMSB) (memSpec.tRP + cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (memSpec.tRP + cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RFMSB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::REFSB: + { + // Bank (REFSB,ACT) (memSpec.tRFCsb_slr - cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (memSpec.tRFCsb_slr - cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (REFSB,ACT) (memSpec.tREFSBRD_slr - cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tREFSBRD_slr - cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::ACT][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (REFSB,ACT) (memSpec.tREFSBRD_dlr - cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tREFSBRD_dlr - cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::ACT][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (REFSB,REFSB) memSpec.tRFCsb_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCsb_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (REFSB,RFMSB) memSpec.tRFCsb_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCsb_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (REFSB,REFSB) memSpec.tRFCsb_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCsb_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::REFSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (REFSB,RFMSB) memSpec.tRFCsb_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCsb_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RFMSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnLogicalRank[logicalRank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnLogicalRank[logicalRank].size() >= 4) + { + sc_time constraint = last4ActivatesOnLogicalRank[logicalRank].front() - memSpec.getCommandLength(command) + memSpec.tFAW_slr; + { + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::ACT][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnLogicalRank[logicalRank].pop(); + } + last4ActivatesOnPhysicalRank[physicalRank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnPhysicalRank[physicalRank].size() >= 4) + { + sc_time constraint = last4ActivatesOnPhysicalRank[physicalRank].front() - memSpec.getCommandLength(command) + memSpec.tFAW_dlr; + { + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::ACT][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::REFSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RFMSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnPhysicalRank[physicalRank].pop(); + } + + break; + } + case Command::RFMSB: + { + // Bank (RFMSB,ACT) (memSpec.tRFCsb_slr - cmdLengthDiff) [] SameComponentsIn(level=) + { + const sc_time constraint = currentTime + (memSpec.tRFCsb_slr - cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (RFMSB,ACT) (memSpec.tREFSBRD_slr - cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tREFSBRD_slr - cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::ACT][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (RFMSB,ACT) (memSpec.tREFSBRD_dlr - cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tREFSBRD_dlr - cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::ACT][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (RFMSB,REFSB) memSpec.tRFCsb_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCsb_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (RFMSB,RFMSB) memSpec.tRFCsb_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCsb_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (RFMSB,REFSB) memSpec.tRFCsb_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCsb_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::REFSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (RFMSB,RFMSB) memSpec.tRFCsb_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCsb_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RFMSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnLogicalRank[logicalRank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnLogicalRank[logicalRank].size() >= 4) + { + sc_time constraint = last4ActivatesOnLogicalRank[logicalRank].front() - memSpec.getCommandLength(command) + memSpec.tFAW_slr; + { + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::ACT][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnLogicalRank[logicalRank].pop(); + } + last4ActivatesOnPhysicalRank[physicalRank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnPhysicalRank[physicalRank].size() >= 4) + { + sc_time constraint = last4ActivatesOnPhysicalRank[physicalRank].front() - memSpec.getCommandLength(command) + memSpec.tFAW_dlr; + { + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::ACT][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::REFSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RFMSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnPhysicalRank[physicalRank].pop(); + } + + break; + } + case Command::PREAB: + { + // LogicalRank (PREAB,ACT) (memSpec.tRP - cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRP - cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::ACT][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (PREAB,PREPB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::PREPB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (PREAB,PREAB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::PREAB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (PREAB,REFAB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (PREAB,RFMAB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::REFAB: + { + // LogicalRank (REFAB,ACT) (memSpec.tRFC_slr - cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRFC_slr - cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::ACT][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (REFAB,REFAB) memSpec.tRFC_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (REFAB,RFMAB) memSpec.tRFC_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (REFAB,REFAB) memSpec.tRFC_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::REFAB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (REFAB,RFMAB) memSpec.tRFC_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RFMAB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (REFAB,REFAB) memSpec.tRFC_dpr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dpr; + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::REFAB][dimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (REFAB,RFMAB) memSpec.tRFC_dpr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dpr; + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RFMAB][dimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (REFAB,REFSB) memSpec.tRFC_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (REFAB,RFMSB) memSpec.tRFC_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (REFAB,REFSB) memSpec.tRFC_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::REFSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (REFAB,RFMSB) memSpec.tRFC_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RFMSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (REFAB,REFSB) memSpec.tRFC_dpr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dpr; + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::REFSB][dimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (REFAB,RFMSB) memSpec.tRFC_dpr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dpr; + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RFMSB][dimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::RFMAB: + { + // LogicalRank (RFMAB,ACT) (memSpec.tRFC_slr - cmdLengthDiff) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRFC_slr - cmdLengthDiff); + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::ACT][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (RFMAB,REFAB) memSpec.tRFC_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (RFMAB,RFMAB) memSpec.tRFC_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMAB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (RFMAB,REFAB) memSpec.tRFC_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::REFAB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (RFMAB,RFMAB) memSpec.tRFC_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RFMAB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (RFMAB,REFAB) memSpec.tRFC_dpr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dpr; + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::REFAB][dimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (RFMAB,RFMAB) memSpec.tRFC_dpr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dpr; + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RFMAB][dimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (RFMAB,REFSB) memSpec.tRFC_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::REFSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // LogicalRank (RFMAB,RFMSB) memSpec.tRFC_slr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_slr; + sc_time &earliestTimeToStart = nextCommandByLogicalRank[Command::RFMSB][logicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (RFMAB,REFSB) memSpec.tRFC_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::REFSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // PhysicalRank (RFMAB,RFMSB) memSpec.tRFC_dlr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dlr; + sc_time &earliestTimeToStart = nextCommandByPhysicalRank[Command::RFMSB][physicalRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (RFMAB,REFSB) memSpec.tRFC_dpr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dpr; + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::REFSB][dimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // DimmRank (RFMAB,RFMSB) memSpec.tRFC_dpr [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC_dpr; + sc_time &earliestTimeToStart = nextCommandByDimmRank[Command::RFMSB][dimmRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + + } + nextCommandOnBus = std::max(nextCommandOnBus, currentTime + memSpec.getCommandLength(command)); } -} // namespace DRAMSys +} // namespace DRAMSys \ No newline at end of file diff --git a/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.h b/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.h index ac069d0c..dbdf1672 100644 --- a/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.h +++ b/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,20 +29,20 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #ifndef CHECKERDDR5_H #define CHECKERDDR5_H +#include "DRAMSys/controller/checker/CheckerIF.h" +#include "DRAMSys/configuration/memspec/MemSpecDDR5.h" + #include #include -#include - -#include -#include - namespace DRAMSys { @@ -50,42 +50,12 @@ class CheckerDDR5 final : public CheckerIF { public: explicit CheckerDDR5(const MemSpecDDR5& memSpec); - sc_core::sc_time - timeToSatisfyConstraints(Command command, - const tlm::tlm_generic_payload& payload) const override; + [[nodiscard]] sc_core::sc_time timeToSatisfyConstraints(Command command, const tlm::tlm_generic_payload& payload) const override; void insert(Command command, const tlm::tlm_generic_payload& payload) override; private: const MemSpecDDR5& memSpec; - std::vector> lastScheduledByCommandAndDimmRank; - std::vector> - lastScheduledByCommandAndPhysicalRank; - std::vector> - lastScheduledByCommandAndLogicalRank; - std::vector> lastScheduledByCommandAndBankGroup; - std::vector> lastScheduledByCommandAndBank; - std::vector lastScheduledByCommand; - sc_core::sc_time lastCommandOnBus; - TimeInterval dummyCommandOnBus; - - std::vector> lastScheduledByCommandAndBankInGroup; - - ControllerVector> last4ActivatesPhysical; - ControllerVector> last4ActivatesLogical; - - std::vector> lastBurstLengthByCommandAndDimmRank; - std::vector> lastBurstLengthByCommandAndPhysicalRank; - std::vector> lastBurstLengthByCommandAndLogicalRank; - std::vector> lastBurstLengthByCommandAndBankGroup; - std::vector> lastBurstLengthByCommandAndBank; - std::vector lastBurstLengthByCommand; - - std::vector> lastBurstLengthByCommandAndBankInGroup; - - // TODO: store BL of last RD and WR globally or for each hierarchy? - - const sc_core::sc_time scMaxTime = sc_core::sc_max_time(); sc_core::sc_time cmdLengthDiff; sc_core::sc_time tBURST16; sc_core::sc_time tBURST32; @@ -112,8 +82,31 @@ private: sc_core::sc_time tRDPDEN; sc_core::sc_time tWRPDEN; sc_core::sc_time tWRAPDEN; + template + using CommandArray = std::array; + template + using BankVector = ControllerVector; + template + using BankGroupVector = ControllerVector; + template + using LogicalRankVector = ControllerVector; + template + using PhysicalRankVector = ControllerVector; + template + using DimmRankVector = ControllerVector; + + + CommandArray> nextCommandByBank; + CommandArray> nextCommandByBankGroup; + CommandArray> nextCommandByLogicalRank; + CommandArray> nextCommandByPhysicalRank; + CommandArray> nextCommandByDimmRank; + + LogicalRankVector> last4ActivatesOnLogicalRank; + PhysicalRankVector> last4ActivatesOnPhysicalRank; + sc_core::sc_time nextCommandOnBus = sc_core::SC_ZERO_TIME; }; } // namespace DRAMSys -#endif // CHECKERDDR5_H +#endif // CHECKERDDR5_H \ No newline at end of file diff --git a/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.cpp b/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.cpp index c262bedf..3a0a5204 100644 --- a/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.cpp +++ b/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,12 +29,14 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #include "CheckerHBM3.h" - #include "DRAMSys/common/DebugManager.h" +#include "DRAMSys/common/utils.h" #include @@ -44,765 +46,1530 @@ using namespace tlm; namespace DRAMSys { -CheckerHBM3::CheckerHBM3(const MemSpecHBM3& memSpec) - : memSpec(memSpec) +CheckerHBM3::CheckerHBM3(const MemSpecHBM3& memSpec) : memSpec(memSpec) { - lastScheduledByCommandAndBank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.banksPerChannel, scMaxTime)); - lastScheduledByCommandAndBankGroup = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.bankGroupsPerChannel, scMaxTime)); - lastScheduledByCommandAndRank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.ranksPerChannel, scMaxTime)); - lastScheduledByCommand = std::vector(Command::numberOfCommands(), scMaxTime); - lastCommandOnRasBus = scMaxTime; - lastCommandOnCasBus = scMaxTime; - last4Activates = ControllerVector>(memSpec.ranksPerChannel); + + nextCommandByBank.fill({BankVector(memSpec.banksPerChannel, SC_ZERO_TIME)}); + nextCommandByBankGroup.fill({BankGroupVector(memSpec.bankGroupsPerChannel, SC_ZERO_TIME)}); + nextCommandByRank.fill({RankVector(memSpec.ranksPerChannel, SC_ZERO_TIME)}); + last4ActivatesOnRank = RankVector>(memSpec.ranksPerChannel); + tRDPDE = ((memSpec.tRL + memSpec.tPL) + (memSpec.tCK * 2)); + tRDSRE = ((memSpec.tRL + memSpec.tPL) + (memSpec.tCK * 3)); + tWRPRE = ((memSpec.tWL + (memSpec.tCK * 2)) + memSpec.tWR); + tWRPDE = (((memSpec.tWL + memSpec.tPL) + (memSpec.tCK * 3)) + memSpec.tWR); + tWRAPDE = (((memSpec.tWL + memSpec.tPL) + (memSpec.tCK * 3)) + memSpec.tWR); + tWRRDS = ((memSpec.tWL + (memSpec.tCK * 2)) + memSpec.tWTRS); + tWRRDL = ((memSpec.tWL + (memSpec.tCK * 2)) + memSpec.tWTRL); + bankwiseRefreshCounter = ControllerVector(memSpec.ranksPerChannel); - - tRDPDE = memSpec.tRL + memSpec.tPL + 2 * memSpec.tCK; - tRDSRE = memSpec.tRL + memSpec.tPL + 3 * memSpec.tCK; - tWRPRE = memSpec.tWL + 2 * memSpec.tCK + memSpec.tWR; - tWRPDE = memSpec.tWL + memSpec.tPL + 3 * memSpec.tCK + memSpec.tWR; - tWRAPDE = memSpec.tWL + memSpec.tPL + 3 * memSpec.tCK + memSpec.tWR; - tWRRDS = memSpec.tWL + 2 * memSpec.tCK + memSpec.tWTRS; - tWRRDL = memSpec.tWL + 2 * memSpec.tCK + memSpec.tWTRL; } -sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, - const tlm_generic_payload& payload) const +sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic_payload& payload) const { - Rank rank = ControllerExtension::getRank(payload); - BankGroup bankGroup = ControllerExtension::getBankGroup(payload); Bank bank = ControllerExtension::getBank(payload); + BankGroup bankGroup = ControllerExtension::getBankGroup(payload); + Rank rank = ControllerExtension::getRank(payload); + - sc_time lastCommandStart; sc_time earliestTimeToStart = sc_time_stamp(); - if (command == Command::PREPB) + + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByBank[command][bank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByBankGroup[command][bankGroup]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByRank[command][rank]); + if (command.isRasCommand()) { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - if (lastCommandOnRasBus != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK / 2); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandOnRasBus); } - else if (command == Command::RD) + if (command.isCasCommand()) { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDRD + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - if (lastCommandOnCasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec.tCK); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandOnCasBus); } - else if (command == Command::WR) + if (command != Command::PREAB && command != Command::PREPB && !isFullCycle(earliestTimeToStart, memSpec.tCK)) { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDWR + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - if (lastCommandOnCasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec.tCK); + earliestTimeToStart = alignAtNext(earliestTimeToStart, memSpec.tCK); } - else if (command == Command::RDA) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDRD + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS); - - 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]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - if (lastCommandOnCasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec.tCK); - } - else if (command == Command::WRA) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDWR + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - if (lastCommandOnCasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec.tCK); - } - else if (command == Command::ACT) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRTP + memSpec.tRP - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + tWRPRE + memSpec.tRP - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::REFPB][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS - memSpec.tCK); - - if (last4Activates[rank].size() >= 4) - earliestTimeToStart = - 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]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - - if (lastCommandOnRasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK); - } - else if (command == Command::PREAB) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB); - - if (lastCommandOnRasBus != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK / 2); - } - else if (command == Command::REFPB) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - { - if (bankwiseRefreshCounter[rank] == 0) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD); - } - - if (last4Activates[rank].size() >= 4) - earliestTimeToStart = - 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]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK); - - 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]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - - if (lastCommandOnRasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK); - } - else if (command == Command::RFMAB) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB); - - if (lastCommandOnRasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK); - } - else if (command == Command::RFMAB) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD); - - if (lastCommandOnRasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK); - } - else if (command == Command::PDEA) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE); - - if (lastCommandOnRasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK); - } - else if (command == Command::PDEP) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - - if (lastCommandOnRasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK); - } - else if (command == Command::PDXP) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD); - - if (lastCommandOnRasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK); - } - else if (command == Command::PDXA) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD); - - if (lastCommandOnRasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK); - } - else if (command == Command::SREFEX) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKESR); - - if (lastCommandOnRasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK); - } - else - { - SC_REPORT_FATAL("CheckerHBM3", "Unknown command!"); - } - - // Don't issue commands at half cycles. - if (command != Command::PREAB && command != Command::PREPB && !isFullCycle(earliestTimeToStart)) - earliestTimeToStart += memSpec.tCK / 2; return earliestTimeToStart; } void CheckerHBM3::insert(Command command, const tlm_generic_payload& payload) { - Rank rank = ControllerExtension::getRank(payload); - BankGroup bankGroup = ControllerExtension::getBankGroup(payload); - Bank bank = ControllerExtension::getBank(payload); + const Bank bank = ControllerExtension::getBank(payload); + const BankGroup bankGroup = ControllerExtension::getBankGroup(payload); + const Rank rank = ControllerExtension::getRank(payload); + - PRINTDEBUGMESSAGE("CheckerHBM3", - "Changing state on bank " + std::to_string(static_cast(bank)) + - " command is " + command.toString()); - - 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()) - lastCommandOnCasBus = sc_time_stamp(); - else if (command == Command::ACT) - lastCommandOnRasBus = sc_time_stamp() + memSpec.tCK; - else - lastCommandOnRasBus = sc_time_stamp(); - - if (command == Command::ACT || command == Command::REFPB) + PRINTDEBUGMESSAGE("CheckerHBM3", "Changing state on bank " + std::to_string(static_cast(bank)) + + " command is " + command.toString()); + + const sc_time& currentTime = sc_time_stamp(); + if (command == Command::REFPB || command == Command::RFMPB) { - if (last4Activates[rank].size() == 4) - last4Activates[rank].pop(); - last4Activates[rank].push(lastCommandOnRasBus); - } - - if (command == Command::REFPB) bankwiseRefreshCounter[rank] = (bankwiseRefreshCounter[rank] + 1) % memSpec.banksPerRank; + } + + switch (command) + { + case Command::RD: + { + // Bank (RD,PREPB) memSpec.tRTP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTP; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RD,RD) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RD,RDA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PREAB) memSpec.tRTP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PDEA) tRDPDE [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PDEP) tRDPDE [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,RD) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,RDA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,WR) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,MWR) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,WRA) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,MWRA) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::WR: + { + // Bank (WR,PREPB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,RDA) ((memSpec.tWL + (memSpec.tCK * 2)) + std::max((memSpec.tWR - memSpec.tRTP), memSpec.tWTRL)) [] SameComponent() + { + const sc_time constraint = currentTime + ((memSpec.tWL + (memSpec.tCK * 2)) + std::max((memSpec.tWR - memSpec.tRTP), memSpec.tWTRL)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,WR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,MWR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,WRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,MWRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,RD) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,RDA) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,PDEA) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,WR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,MWR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,WRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,MWRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,RD) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,RDA) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::MWR: + { + // Bank (MWR,PREPB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,RDA) ((memSpec.tWL + (memSpec.tCK * 2)) + std::max((memSpec.tWR - memSpec.tRTP), memSpec.tWTRL)) [] SameComponent() + { + const sc_time constraint = currentTime + ((memSpec.tWL + (memSpec.tCK * 2)) + std::max((memSpec.tWR - memSpec.tRTP), memSpec.tWTRL)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,WR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,MWR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,WRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,MWRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,RD) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,RDA) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,PDEA) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,WR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,MWR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,WRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,MWRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,RD) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,RDA) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::RDA: + { + // Bank (RDA,ACT) ((memSpec.tRTP + memSpec.tRP) - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + ((memSpec.tRTP + memSpec.tRP) - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RDA,REFPB) (memSpec.tRTP + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRTP + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RDA,RD) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RDA,RDA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PDEA) tRDPDE [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PDEP) tRDPDE [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,RD) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,RDA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,WR) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,MWR) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,WRA) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,MWRA) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,REFAB) (memSpec.tRTP + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRTP + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PREAB) memSpec.tRTP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,SREFEN) std::max((memSpec.tRTP + memSpec.tRP), tRDSRE) [] SameComponent() + { + const sc_time constraint = currentTime + std::max((memSpec.tRTP + memSpec.tRP), tRDSRE); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::WRA: + { + // Bank (WRA,ACT) ((tWRPRE + memSpec.tRP) - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + ((tWRPRE + memSpec.tRP) - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WRA,REFPB) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,WR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,MWR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,WRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,MWRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,RD) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,RDA) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PDEA) tWRAPDE [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PDEP) tWRAPDE [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,WR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,MWR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,WRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,MWRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,RD) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,RDA) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,REFAB) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,SREFEN) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::MWRA: + { + // Bank (MWRA,ACT) ((tWRPRE + memSpec.tRP) - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + ((tWRPRE + memSpec.tRP) - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWRA,REFPB) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,WR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,MWR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,WRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,MWRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,RD) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,RDA) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PDEA) tWRAPDE [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PDEP) tWRAPDE [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,WR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,MWR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,WRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,MWRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,RD) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,RDA) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,REFAB) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,SREFEN) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::ACT: + { + // Bank (ACT,PREPB) (memSpec.tRAS + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRAS + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WR) (memSpec.tRCDWR + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCDWR + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::WR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWR) (memSpec.tRCDWR + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCDWR + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WRA) (memSpec.tRCDWR + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCDWR + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::WRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWRA) (memSpec.tRCDWR + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCDWR + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,RD) (memSpec.tRCDRD + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCDRD + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,RDA) (memSpec.tRCDRD + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCDRD + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,ACT) memSpec.tRC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRC; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,REFPB) (memSpec.tRC + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRC + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (ACT,ACT) memSpec.tRRDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::ACT][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (ACT,REFPB) (memSpec.tRRDL + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRRDL + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::REFPB][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,ACT) memSpec.tRRDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,REFAB) (memSpec.tRC + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRC + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,RFMAB) (memSpec.tRC + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRC + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RFMAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,SREFEN) (memSpec.tRC + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRC + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,PREAB) (memSpec.tRAS + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRAS + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,REFPB) (memSpec.tRRDS + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRRDS + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,RFMPB) (memSpec.tRRDS + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRRDS + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RFMPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnRank[rank].size() >= 4) + { + sc_time constraint = last4ActivatesOnRank[rank].front() - memSpec.getCommandLength(command) + memSpec.tFAW; + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].pop(); + } + + break; + } + case Command::PREPB: + { + // Bank (PREPB,ACT) (memSpec.tRP - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRP - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (PREPB,REFPB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (PREPB,PREPB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,REFAB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,SREFEN) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,PREAB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::REFPB: + { + // Bank (REFPB,ACT) (memSpec.tRFCPB - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRFCPB - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (REFPB,REFPB) memSpec.tRFCPB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (REFPB,RFMPB) memSpec.tRFCPB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RFMPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,ACT) (memSpec.tRREFD - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRREFD - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,REFPB) memSpec.tRFCPB [BankwiseRefreshCounter(counter=0, inversed=False)] SameComponent() + { + if (bankwiseRefreshCounter[rank] == 0) + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (REFPB,RFMPB) memSpec.tRFCPB [BankwiseRefreshCounter(counter=0, inversed=False)] SameComponent() + { + if (bankwiseRefreshCounter[rank] == 0) + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RFMPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (REFPB,REFPB) memSpec.tRREFD [BankwiseRefreshCounter(counter=0, inversed=True)] SameComponent() + { + if (bankwiseRefreshCounter[rank] != 0) + { + const sc_time constraint = currentTime + memSpec.tRREFD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (REFPB,RFMPB) memSpec.tRREFD [BankwiseRefreshCounter(counter=0, inversed=True)] SameComponent() + { + if (bankwiseRefreshCounter[rank] != 0) + { + const sc_time constraint = currentTime + memSpec.tRREFD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RFMPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (REFPB,REFAB) memSpec.tRFCPB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,RFMAB) memSpec.tRFCPB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RFMAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,PREAB) memSpec.tRFCPB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,SREFEN) memSpec.tRFCPB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnRank[rank].size() >= 4) + { + sc_time constraint = last4ActivatesOnRank[rank].front() - memSpec.getCommandLength(command) + memSpec.tFAW; + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].pop(); + } + + break; + } + case Command::RFMPB: + { + // Bank (RFMPB,REFPB) memSpec.tRFCPB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RFMPB,RFMPB) memSpec.tRFCPB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RFMPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RFMPB,ACT) memSpec.tRFCPB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RFMPB,REFPB) memSpec.tRREFD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRREFD; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::REFPB][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RFMPB,RFMPB) memSpec.tRREFD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRREFD; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RFMPB][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RFMPB,ACT) memSpec.tRREFD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRREFD; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::ACT][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RFMPB,REFAB) memSpec.tRFCPB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RFMPB,RFMAB) memSpec.tRFCPB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RFMAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RFMPB,RFMPB) memSpec.tRFCPB [BankwiseRefreshCounter(counter=0, inversed=False)] SameComponent() + { + if (bankwiseRefreshCounter[rank] == 0) + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RFMPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RFMPB,REFPB) memSpec.tRFCPB [BankwiseRefreshCounter(counter=0, inversed=False)] SameComponent() + { + if (bankwiseRefreshCounter[rank] == 0) + { + const sc_time constraint = currentTime + memSpec.tRFCPB; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RFMPB,RFMPB) memSpec.tRREFD [BankwiseRefreshCounter(counter=0, inversed=True)] SameComponent() + { + if (bankwiseRefreshCounter[rank] != 0) + { + const sc_time constraint = currentTime + memSpec.tRREFD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RFMPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RFMPB,REFPB) memSpec.tRREFD [BankwiseRefreshCounter(counter=0, inversed=True)] SameComponent() + { + if (bankwiseRefreshCounter[rank] != 0) + { + const sc_time constraint = currentTime + memSpec.tRREFD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::PREAB: + { + // Rank (PREAB,PREPB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,PREAB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,ACT) (memSpec.tRP - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRP - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,REFAB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,REFPB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,SREFEN) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::REFAB: + { + // Rank (REFAB,ACT) (memSpec.tRFC - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRFC - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,REFAB) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,REFPB) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,RFMAB) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RFMAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,RFMPB) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RFMPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,SREFEN) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::RFMAB: + { + // Rank (RFMAB,REFAB) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RFMAB,REFPB) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RFMAB,RFMAB) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RFMAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RFMAB,RFMPB) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RFMPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RFMAB,ACT) (memSpec.tRFC - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRFC - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDEA: + { + // Rank (PDEA,PDXA) memSpec.tPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDXA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDEP: + { + // Rank (PDEP,PDXP) memSpec.tPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDXP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDXA: + { + // Rank (PDXA,PDEA) memSpec.tCKE [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,REFPB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,PREPB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,PREAB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,RD) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,RDA) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,WR) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,MWR) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,WRA) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,MWRA) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,ACT) (memSpec.tXP - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tXP - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDXP: + { + // Rank (PDXP,PDEP) memSpec.tCKE [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,REFAB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,REFPB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,SREFEN) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,ACT) (memSpec.tXP - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tXP - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::SREFEX: + { + // Rank (SREFEX,ACT) (memSpec.tXS - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tXS - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,REFPB) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,REFAB) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,PDEP) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,SREFEN) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,SREFEX) memSpec.tCKESR [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKESR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEX][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + + } + if (command.isRasCommand()) + { + nextCommandOnRasBus = std::max(nextCommandOnRasBus, currentTime + memSpec.getCommandLength(command)); + } + if (command.isCasCommand()) + { + nextCommandOnCasBus = std::max(nextCommandOnCasBus, currentTime + memSpec.getCommandLength(command)); + } } -bool CheckerHBM3::isFullCycle(const sc_core::sc_time& time) const -{ - sc_time aligedAtHalfCycle = std::floor((time * 2 / memSpec.tCK + 0.5)) / 2 * memSpec.tCK; - return sc_time::from_value(aligedAtHalfCycle.value() % memSpec.tCK.value()) == SC_ZERO_TIME; -} - -} // namespace DRAMSys +} // namespace DRAMSys \ No newline at end of file diff --git a/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.h b/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.h index ff928e83..983e76af 100644 --- a/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.h +++ b/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,20 +29,20 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #ifndef CHECKERHBM3_H #define CHECKERHBM3_H +#include "DRAMSys/controller/checker/CheckerIF.h" +#include "DRAMSys/configuration/memspec/MemSpecHBM3.h" + #include #include -#include - -#include -#include - namespace DRAMSys { @@ -50,29 +50,12 @@ class CheckerHBM3 final : public CheckerIF { public: explicit CheckerHBM3(const MemSpecHBM3& memSpec); - sc_core::sc_time - timeToSatisfyConstraints(Command command, - const tlm::tlm_generic_payload& payload) const override; + [[nodiscard]] sc_core::sc_time timeToSatisfyConstraints(Command command, const tlm::tlm_generic_payload& payload) const override; void insert(Command command, const tlm::tlm_generic_payload& payload) override; private: - bool isFullCycle(const sc_core::sc_time& time) const; - const MemSpecHBM3& memSpec; - std::vector> lastScheduledByCommandAndBank; - std::vector> lastScheduledByCommandAndBankGroup; - std::vector> lastScheduledByCommandAndRank; - std::vector lastScheduledByCommand; - - sc_core::sc_time lastCommandOnRasBus; - sc_core::sc_time lastCommandOnCasBus; - - // Four activate window - ControllerVector> last4Activates; - ControllerVector bankwiseRefreshCounter; - - const sc_core::sc_time scMaxTime = sc_core::sc_max_time(); sc_core::sc_time tRDPDE; sc_core::sc_time tRDSRE; sc_core::sc_time tWRPRE; @@ -80,8 +63,26 @@ private: sc_core::sc_time tWRAPDE; sc_core::sc_time tWRRDS; sc_core::sc_time tWRRDL; + template + using CommandArray = std::array; + template + using BankVector = ControllerVector; + template + using BankGroupVector = ControllerVector; + template + using RankVector = ControllerVector; + + + CommandArray> nextCommandByBank; + CommandArray> nextCommandByBankGroup; + CommandArray> nextCommandByRank; + + RankVector> last4ActivatesOnRank; + ControllerVector bankwiseRefreshCounter; + sc_core::sc_time nextCommandOnRasBus = sc_core::SC_ZERO_TIME; + sc_core::sc_time nextCommandOnCasBus = sc_core::SC_ZERO_TIME; }; } // namespace DRAMSys -#endif // CHECKERHBM3_H +#endif // CHECKERHBM3_H \ No newline at end of file diff --git a/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.cpp b/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.cpp index e6f163df..233f8877 100644 --- a/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.cpp +++ b/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,12 +29,14 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #include "CheckerLPDDR5.h" - #include "DRAMSys/common/DebugManager.h" +#include "DRAMSys/common/utils.h" #include @@ -44,929 +46,3845 @@ using namespace tlm; namespace DRAMSys { -CheckerLPDDR5::CheckerLPDDR5(const MemSpecLPDDR5& memSpec) - : memSpec(memSpec) +CheckerLPDDR5::CheckerLPDDR5(const MemSpecLPDDR5& memSpec) : memSpec(memSpec) { - lastScheduledByCommandAndRank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.ranksPerChannel, scMaxTime)); - lastScheduledByCommandAndBankGroup = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.bankGroupsPerChannel, scMaxTime)); - lastScheduledByCommandAndBank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.banksPerChannel, scMaxTime)); - lastScheduledByCommand = std::vector(Command::numberOfCommands(), scMaxTime); - lastCommandOnBus = scMaxTime; + + nextCommandByBank.fill({BankVector(memSpec.banksPerChannel, SC_ZERO_TIME)}); + nextCommandByBankGroup.fill({BankGroupVector(memSpec.bankGroupsPerChannel, SC_ZERO_TIME)}); + nextCommandByRank.fill({RankVector(memSpec.ranksPerChannel, SC_ZERO_TIME)}); + last4ActivatesOnRank = RankVector>(memSpec.ranksPerChannel); - last4Activates = ControllerVector>(memSpec.ranksPerChannel); - - lastBurstLengthByCommandAndRank = std::vector>( - Command::WRA + 1, ControllerVector(memSpec.ranksPerChannel)); - lastBurstLengthByCommandAndBankGroup = std::vector>( - Command::WRA + 1, ControllerVector(memSpec.bankGroupsPerChannel)); - lastBurstLengthByCommandAndBank = std::vector>( - Command::WRA + 1, ControllerVector(memSpec.banksPerChannel)); - lastBurstLengthByCommand = std::vector(Command::WRA + 1); - - tBURST16 = 16 / memSpec.dataRate * memSpec.tCK; - tBURST32 = 32 / memSpec.dataRate * memSpec.tCK; + } -sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, - const tlm_generic_payload& payload) const +sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_generic_payload& payload) const { - Rank rank = ControllerExtension::getRank(payload); - BankGroup bankGroup = ControllerExtension::getBankGroup(payload); Bank bank = ControllerExtension::getBank(payload); + BankGroup bankGroup = ControllerExtension::getBankGroup(payload); + Rank rank = ControllerExtension::getRank(payload); + - sc_time lastCommandStart; sc_time earliestTimeToStart = sc_time_stamp(); - // TODO: model BG mode BL32 interleaved burst - if (command == Command::RD || command == Command::RDA) - { - unsigned burstLength = ControllerExtension::getBurstLength(payload); - assert(!(memSpec.bankMode == MemSpecLPDDR5::BankMode::M8B) || - (burstLength == 32)); // 8B mode -> BL32 - assert(!(memSpec.bankMode == MemSpecLPDDR5::BankMode::MBG) || - (memSpec.dataRate == 8)); // BG mode -> 4:1 ratio - assert(burstLength <= memSpec.maxBurstLength); - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD_L + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup]; - if (lastCommandStart != scMaxTime) - { - 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]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndRank[Command::RD][rank] == 32) - { - // TODO: model BG mode BL32 interleaved burst, remove this fix - if (memSpec.bankMode == MemSpecLPDDR5::BankMode::MBG) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_S_32 + 2 * memSpec.tCK); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_32); - } - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_16); - } - - lastCommandStart = - lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank] - ? lastScheduledByCommand[Command::RD] - : scMaxTime; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommand[Command::RD] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_32 + - memSpec.tCK + memSpec.tRPST + memSpec.tRPRE); - else - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_16 + - memSpec.tCK + memSpec.tRPST + memSpec.tRPRE); - } - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup]; - if (lastCommandStart != scMaxTime) - { - 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]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndRank[Command::RDA][rank] == 32) - { - // TODO: model BG mode BL32 interleaved burst, remove this fix - if (memSpec.bankMode == MemSpecLPDDR5::BankMode::MBG) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_S_32 + 2 * memSpec.tCK); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_32); - } - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_16); - } - - lastCommandStart = lastScheduledByCommand[Command::RDA] != - lastScheduledByCommandAndRank[Command::RDA][rank] - ? lastScheduledByCommand[Command::RDA] - : scMaxTime; - if (lastCommandStart != scMaxTime) - { - // TODO: BG mode with BL32 - if (lastBurstLengthByCommand[Command::RDA] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_32 + - memSpec.tCK + memSpec.tRPST + memSpec.tRPRE); - else - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_16 + - memSpec.tCK + memSpec.tRPST + memSpec.tRPRE); - } - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + - memSpec.BL_n_max_32 + memSpec.tWTR_L); - else - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + - memSpec.BL_n_max_16 + memSpec.tWTR_L); - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndRank[Command::WR][rank] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + - memSpec.BL_n_min_32 + memSpec.tWTR_S); - else - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + - memSpec.BL_n_min_16 + memSpec.tWTR_S); - } - - lastCommandStart = - lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank] - ? lastScheduledByCommand[Command::WR] - : scMaxTime; - if (lastCommandStart != scMaxTime) - { - // TODO: BG mode with BL32 - if (lastBurstLengthByCommand[Command::WR] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK - - memSpec.tRL); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK - - memSpec.tRL); - } - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + - memSpec.BL_n_max_32 + memSpec.tWTR_L); - else - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + - memSpec.BL_n_max_16 + memSpec.tWTR_L); - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndRank[Command::WRA][rank] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + - memSpec.BL_n_min_32 + memSpec.tWTR_S); - else - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + - memSpec.BL_n_min_16 + memSpec.tWTR_S); - } - - lastCommandStart = lastScheduledByCommand[Command::WRA] != - lastScheduledByCommandAndRank[Command::WRA][rank] - ? lastScheduledByCommand[Command::WRA] - : scMaxTime; - if (lastCommandStart != scMaxTime) - { - // TODO: BG mode with BL32 - if (lastBurstLengthByCommand[Command::WRA] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK - - memSpec.tRL); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK - - memSpec.tRL); - } - } - else if (command == Command::WR || command == Command::WRA || command == Command::MWR || - command == Command::MWRA) - { - unsigned burstLength = ControllerExtension::getBurstLength(payload); - assert(!(memSpec.bankMode == MemSpecLPDDR5::BankMode::M8B) || - (burstLength == 32)); // 8B mode -> BL32 - assert(!(memSpec.bankMode == MemSpecLPDDR5::BankMode::MBG) || - (memSpec.dataRate == 8)); // BG mode -> 4:1 ratio - assert(burstLength <= memSpec.maxBurstLength); - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD_S + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankGroup[Command::RD][bankGroup] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRL + memSpec.BL_n_max_32 + - memSpec.tWCK2DQO - memSpec.tWL); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRL + memSpec.BL_n_max_16 + - memSpec.tWCK2DQO - memSpec.tWL); - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndRank[Command::RD][rank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRL + memSpec.BL_n_min_32 + - memSpec.tWCK2DQO - memSpec.tWL); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRL + memSpec.BL_n_min_16 + - memSpec.tWCK2DQO - memSpec.tWL); - } - - lastCommandStart = - lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank] - ? lastScheduledByCommand[Command::RD] - : scMaxTime; - if (lastCommandStart != scMaxTime) - { - // TODO: BG mode with BL32 - if (lastBurstLengthByCommand[Command::RD] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRL + memSpec.BL_n_min_32 + - memSpec.tWCK2DQO + memSpec.tRPST - memSpec.tWL); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRL + memSpec.BL_n_min_16 + - memSpec.tWCK2DQO + memSpec.tRPST - memSpec.tWL); - } - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBankGroup[Command::RDA][bankGroup] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRL + memSpec.BL_n_max_32 + - memSpec.tWCK2DQO - memSpec.tWL); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRL + memSpec.BL_n_max_16 + - memSpec.tWCK2DQO - memSpec.tWL); - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndRank[Command::RDA][rank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRL + memSpec.BL_n_min_32 + - memSpec.tWCK2DQO - memSpec.tWL); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRL + memSpec.BL_n_min_16 + - memSpec.tWCK2DQO - memSpec.tWL); - } - - lastCommandStart = lastScheduledByCommand[Command::RDA] != - lastScheduledByCommandAndRank[Command::RDA][rank] - ? lastScheduledByCommand[Command::RDA] - : scMaxTime; - if (lastCommandStart != scMaxTime) - { - // TODO: BG mode with BL32 - if (lastBurstLengthByCommand[Command::RDA] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRL + memSpec.BL_n_min_32 + - memSpec.tWCK2DQO + memSpec.tRPST - memSpec.tWL); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRL + memSpec.BL_n_min_16 + - memSpec.tWCK2DQO + memSpec.tRPST - memSpec.tWL); - } - - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - { - if (command == Command::MWR || command == Command::MWRA) - { - if (lastBurstLengthByCommandAndBank[Command::WR][bank] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + 2.5 * memSpec.BL_n_max_32); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + 4 * memSpec.BL_n_max_16); - } - } - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup]; - if (lastCommandStart != scMaxTime) - { - if (command == Command::WR || command == Command::WRA) - { - 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); - } - else if (command == Command::MWR || command == Command::MWRA) - { - if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_max_32); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_max_16); - } - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndRank[Command::WR][rank] == 32) - { - // TODO: model BG mode BL32 interleaved burst, remove this fix - if (memSpec.bankMode == MemSpecLPDDR5::BankMode::MBG) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_S_32 + 2 * memSpec.tCK); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_32); - } - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_16); - } - - lastCommandStart = lastScheduledByCommand[Command::WR]; - if (lastCommandStart != scMaxTime) - { - if (lastScheduledByCommand[Command::WR] != - lastScheduledByCommandAndRank[Command::WR][rank]) - { - // TODO: BG mode with BL32 - if (lastBurstLengthByCommand[Command::WR] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_32 + memSpec.tCK); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_16 + memSpec.tCK); - } - } - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup]; - if (lastCommandStart != scMaxTime) - { - if (command == Command::WR || command == Command::WRA) - { - 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); - } - else if (command == Command::MWR || command == Command::MWRA) - { - if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_max_32); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_max_16); - } - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndRank[Command::WRA][rank] == 32) - { - // TODO: model BG mode BL32 interleaved burst, remove this fix - if (memSpec.bankMode == MemSpecLPDDR5::BankMode::MBG) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_S_32 + 2 * memSpec.tCK); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_32); - } - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_16); - } - - lastCommandStart = lastScheduledByCommand[Command::WRA]; - if (lastCommandStart != scMaxTime) - { - if (lastScheduledByCommand[Command::WRA] != - lastScheduledByCommandAndRank[Command::WRA][rank]) - { - if (lastBurstLengthByCommand[Command::WRA] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_32 + memSpec.tCK); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_16 + memSpec.tCK); - } - } - } - else if (command == Command::ACT) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBank[Command::RDA][bank] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_32 + - memSpec.tRBTP + memSpec.tRPpb - memSpec.tCK); - else - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_16 + - memSpec.tRBTP + memSpec.tRPpb - memSpec.tCK); - } - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBank[Command::WRA][bank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK + - memSpec.tWR + memSpec.tRPpb - memSpec.tCK); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK + - memSpec.tWR + memSpec.tRPpb - memSpec.tCK); - } - - lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tpbR2act - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFP2B][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tpbR2act - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::REFP2B][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb - 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]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBank[Command::RD][bank] == 32) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + memSpec.BL_n_min_32 + memSpec.tRBTP); - else - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + memSpec.BL_n_min_16 + memSpec.tRBTP); - } - - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBank[Command::WR][bank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK + - memSpec.tWR); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK + - memSpec.tWR); - } - - 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]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndRank[Command::RD][rank] == 32) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + memSpec.BL_n_min_32 + memSpec.tRBTP); - else - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + memSpec.BL_n_min_16 + memSpec.tRBTP); - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndRank[Command::RDA][rank] == 32) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + memSpec.BL_n_min_32 + memSpec.tRBTP); - else - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + memSpec.BL_n_min_16 + memSpec.tRBTP); - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndRank[Command::WR][rank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK + - memSpec.tWR); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK + - memSpec.tWR); - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndRank[Command::WRA][rank] == 32) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK + - memSpec.tWR); - else - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK + - memSpec.tWR); - } - - 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]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndRank[Command::RDA][rank] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_32 + - memSpec.tRBTP + memSpec.tRPpb); - else - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_16 + - memSpec.tRBTP + memSpec.tRPpb); - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - { - 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 - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK + - memSpec.tWR + memSpec.tRPpb); - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab); - - 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]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBank[Command::RDA][bank] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_32 + - memSpec.tRBTP + memSpec.tRPpb); - else - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_16 + - memSpec.tRBTP + memSpec.tRPpb); - } - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank]; - if (lastCommandStart != scMaxTime) - { - 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 - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK + - memSpec.tWR + memSpec.tRPpb); - } - - lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab); - - lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tpbR2pbR); - - if (last4Activates[rank].size() >= 4) - earliestTimeToStart = - std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW); - } - else if (command == Command::REFP2B) - { - Bank secondBank = Bank(static_cast(bank) + memSpec.getPer2BankOffset()); - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][secondBank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBank[Command::RDA][bank] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_32 + - memSpec.tRBTP + memSpec.tRPpb); - else - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_16 + - memSpec.tRBTP + memSpec.tRPpb); - } - - lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][secondBank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBank[Command::RDA][secondBank] == 32) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_32 + - memSpec.tRBTP + memSpec.tRPpb); - else - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.BL_n_min_16 + - memSpec.tRBTP + memSpec.tRPpb); - } - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank]; - if (lastCommandStart != scMaxTime) - { - 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 - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK + - memSpec.tWR + memSpec.tRPpb); - } - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][secondBank]; - if (lastCommandStart != scMaxTime) - { - 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 - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK + - memSpec.tWR + memSpec.tRPpb); - } - - lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb); - - lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][secondBank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab); - - lastCommandStart = lastScheduledByCommandAndBank[Command::REFP2B][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFP2B][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tpbR2pbR); - - if (last4Activates[rank].size() >= 4) - earliestTimeToStart = - std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW); - } - else - SC_REPORT_FATAL("CheckerLPDDR5", "Unknown command!"); - - // Check if command bus is free - if (lastCommandOnBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK); + + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByBank[command][bank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByBankGroup[command][bankGroup]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByRank[command][rank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandOnBus); return earliestTimeToStart; } void CheckerLPDDR5::insert(Command command, const tlm_generic_payload& payload) { - Rank rank = ControllerExtension::getRank(payload); - BankGroup bankGroup = ControllerExtension::getBankGroup(payload); - Bank bank = ControllerExtension::getBank(payload); - unsigned burstLength = ControllerExtension::getBurstLength(payload); + const Bank bank = ControllerExtension::getBank(payload); + const BankGroup bankGroup = ControllerExtension::getBankGroup(payload); + const Rank rank = ControllerExtension::getRank(payload); + const unsigned burstLength = ControllerExtension::getBurstLength(payload); - // Hack: Convert MWR to WR and MWRA to WRA - if (command == Command::MWR) - command = Command::WR; - else if (command == Command::MWRA) - command = Command::WRA; - - PRINTDEBUGMESSAGE("CheckerLPDDR5", - "Changing state on bank " + std::to_string(static_cast(bank)) + - " command is " + command.toString()); - - 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()) + PRINTDEBUGMESSAGE("CheckerLPDDR5", "Changing state on bank " + std::to_string(static_cast(bank)) + + " command is " + command.toString()); + + const sc_time& currentTime = sc_time_stamp(); + + switch (command) { - lastBurstLengthByCommandAndRank[command][rank] = burstLength; - lastBurstLengthByCommandAndBankGroup[command][bankGroup] = burstLength; - lastBurstLengthByCommandAndBank[command][bank] = burstLength; - lastBurstLengthByCommand[command] = burstLength; - } - - if (command == Command::REFP2B) + case Command::RD: { - Bank secondBank = Bank(static_cast(bank) + memSpec.getPer2BankOffset()); - lastScheduledByCommandAndBank[command][secondBank] = sc_time_stamp(); + // Bank (RD,PREPB) (memSpec.BL_n_min_32 + memSpec.tRBTP) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tRBTP); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (RD,PREPB) (memSpec.BL_n_min_16 + memSpec.tRBTP) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tRBTP); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,RD) memSpec.BL_n_L_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,RDA) memSpec.BL_n_L_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,RD) memSpec.BL_n_L_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,RDA) memSpec.BL_n_L_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,WR) (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,WRA) (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,MWR) (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,MWRA) (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,WR) (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,WRA) (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,MWR) (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RD,MWRA) (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RD,RD) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (RD,RDA) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (RD,RD) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (RD,RDA) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (RD,RD) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RD,RDA) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RD,WR) (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RD,WRA) (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RD,MWR) (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RD,MWRA) (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RD,WR) (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RD,WRA) (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RD,MWR) (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RD,MWRA) (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RD,PREAB) (memSpec.BL_n_min_32 + memSpec.tRBTP) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tRBTP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RD,PREAB) (memSpec.BL_n_min_16 + memSpec.tRBTP) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tRBTP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,RD) (((memSpec.BL_n_min_32 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.BL_n_min_32 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,RDA) (((memSpec.BL_n_min_32 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.BL_n_min_32 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,RD) (((memSpec.BL_n_min_16 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.BL_n_min_16 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,RDA) (((memSpec.BL_n_min_16 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.BL_n_min_16 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,WR) ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,WRA) ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,MWR) ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,MWRA) ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,WR) ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,WRA) ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,MWR) ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RD,MWRA) ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + + break; } - - 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) + case Command::WR: { - if (last4Activates[rank].size() == 4) - last4Activates[rank].pop(); - last4Activates[rank].push(lastCommandOnBus); + // Bank (WR,MWR) (memSpec.BL_n_max_32 * 2.5) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_max_32 * 2.5); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,MWRA) (memSpec.BL_n_max_32 * 2.5) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_max_32 * 2.5); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,MWR) (memSpec.BL_n_max_16 * 4) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_max_16 * 4); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,MWRA) (memSpec.BL_n_max_16 * 4) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_max_16 * 4); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,PREPB) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,PREPB) (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) + memSpec.tWR) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) + memSpec.tWR); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,RD) ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,RDA) ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,RD) ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,RDA) ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,WR) memSpec.BL_n_L_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,WRA) memSpec.BL_n_L_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,WR) memSpec.BL_n_L_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,WRA) memSpec.BL_n_L_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,MWR) memSpec.BL_n_max_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,MWRA) memSpec.BL_n_max_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,MWR) memSpec.BL_n_max_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WR,MWRA) memSpec.BL_n_max_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,RD) ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,RDA) ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,RD) ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,RDA) ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,WR) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WR,WRA) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WR,MWR) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WR,MWRA) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WR,WR) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WR,WRA) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WR,MWR) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WR,MWRA) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WR,WR) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,WRA) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,MWR) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,MWRA) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,PREAB) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,PREAB) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,RD) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,RDA) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,RD) (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,RDA) (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,WR) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,WRA) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,MWR) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,MWRA) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,WR) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,WRA) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,MWR) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WR,MWRA) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + + break; } + case Command::MWR: + { + // Bank (MWR,MWR) (memSpec.BL_n_max_32 * 2.5) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_max_32 * 2.5); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,MWRA) (memSpec.BL_n_max_32 * 2.5) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_max_32 * 2.5); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,MWR) (memSpec.BL_n_max_16 * 4) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_max_16 * 4); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,MWRA) (memSpec.BL_n_max_16 * 4) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_max_16 * 4); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,RD) ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,RDA) ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,RD) ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,RDA) ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,WR) memSpec.BL_n_L_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,WRA) memSpec.BL_n_L_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,WR) memSpec.BL_n_L_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,WRA) memSpec.BL_n_L_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,MWR) memSpec.BL_n_max_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,MWRA) memSpec.BL_n_max_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,MWR) memSpec.BL_n_max_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWR,MWRA) memSpec.BL_n_max_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,RD) ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,RDA) ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,RD) ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,RDA) ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,WR) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWR,WRA) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWR,MWR) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWR,MWRA) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWR,WR) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWR,WRA) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWR,MWR) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWR,MWRA) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWR,WR) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,WRA) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,MWR) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,MWRA) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,PREAB) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,PREAB) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,RD) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,RDA) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,RD) (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,RDA) (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,WR) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,WRA) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,MWR) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,MWRA) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,WR) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,WRA) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,MWR) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWR,MWRA) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + + break; + } + case Command::RDA: + { + // Bank (RDA,ACT) (((memSpec.BL_n_min_32 + memSpec.tRBTP) + memSpec.tRPpb) - memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.BL_n_min_32 + memSpec.tRBTP) + memSpec.tRPpb) - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (RDA,ACT) (((memSpec.BL_n_min_16 + memSpec.tRBTP) + memSpec.tRPpb) - memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.BL_n_min_16 + memSpec.tRBTP) + memSpec.tRPpb) - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (RDA,REFP2B) ((memSpec.BL_n_min_32 + memSpec.tRBTP) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.BL_n_min_32 + memSpec.tRBTP) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFP2B][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (RDA,REFP2B) ((memSpec.BL_n_min_16 + memSpec.tRBTP) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.BL_n_min_16 + memSpec.tRBTP) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFP2B][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (RDA,REFP2B) ((memSpec.BL_n_min_32 + memSpec.tRBTP) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=False)] Per2ComponentsIn(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.BL_n_min_32 + memSpec.tRBTP) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFP2B][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (RDA,REFP2B) ((memSpec.BL_n_min_16 + memSpec.tRBTP) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=True)] Per2ComponentsIn(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.BL_n_min_16 + memSpec.tRBTP) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFP2B][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,RD) memSpec.BL_n_L_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,RDA) memSpec.BL_n_L_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,RD) memSpec.BL_n_L_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,RDA) memSpec.BL_n_L_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,WR) (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,WRA) (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,MWR) (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,MWRA) (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,WR) (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,WRA) (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,MWR) (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (RDA,MWRA) (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_max_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,RD) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (RDA,RDA) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (RDA,RD) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (RDA,RDA) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (RDA,RD) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,RDA) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,WR) (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,WRA) (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,MWR) (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,MWRA) (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,WR) (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,WRA) (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,MWR) (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,MWRA) (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) - memSpec.tWL); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,PREAB) (memSpec.BL_n_min_32 + memSpec.tRBTP) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tRBTP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,PREAB) (memSpec.BL_n_min_16 + memSpec.tRBTP) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tRBTP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,REFAB) ((memSpec.BL_n_min_32 + memSpec.tRBTP) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.BL_n_min_32 + memSpec.tRBTP) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,REFAB) ((memSpec.BL_n_min_16 + memSpec.tRBTP) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.BL_n_min_16 + memSpec.tRBTP) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,REFPB) ((memSpec.BL_n_min_32 + memSpec.tRBTP) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.BL_n_min_32 + memSpec.tRBTP) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (RDA,REFPB) ((memSpec.BL_n_min_16 + memSpec.tRBTP) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.BL_n_min_16 + memSpec.tRBTP) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,RD) (((memSpec.BL_n_min_32 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.BL_n_min_32 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,RDA) (((memSpec.BL_n_min_32 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.BL_n_min_32 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,RD) (((memSpec.BL_n_min_16 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.BL_n_min_16 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,RDA) (((memSpec.BL_n_min_16 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.BL_n_min_16 + memSpec.tCK) + memSpec.tRPST) + memSpec.tRPRE); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,WR) ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,WRA) ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,MWR) ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,MWRA) ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_32) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,WR) ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,WRA) ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,MWR) ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (RDA,MWRA) ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((((memSpec.tRL + memSpec.BL_n_min_16) + memSpec.tWCK2DQO) + memSpec.tRPST) - memSpec.tWL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + + break; + } + case Command::WRA: + { + // Bank (WRA,ACT) ((((memSpec.BL_n_min_32 + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb) - memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((((memSpec.BL_n_min_32 + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb) - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,ACT) ((((memSpec.BL_n_min_16 + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb) - memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((((memSpec.BL_n_min_16 + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb) - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,REFP2B) ((((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFP2B][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,REFP2B) ((((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFP2B][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,REFP2B) ((((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=False)] Per2ComponentsIn(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFP2B][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,REFP2B) ((((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=True)] Per2ComponentsIn(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFP2B][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,RD) ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,RDA) ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,RD) ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,RDA) ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,WR) memSpec.BL_n_L_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,WRA) memSpec.BL_n_L_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,WR) memSpec.BL_n_L_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,WRA) memSpec.BL_n_L_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,MWR) memSpec.BL_n_max_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,MWRA) memSpec.BL_n_max_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,MWR) memSpec.BL_n_max_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (WRA,MWRA) memSpec.BL_n_max_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,RD) ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,RDA) ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,RD) ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,RDA) ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,WR) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WRA,WRA) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WRA,MWR) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WRA,MWRA) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WRA,WR) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WRA,WRA) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WRA,MWR) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WRA,MWRA) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (WRA,WR) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,WRA) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,MWR) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,MWRA) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,PREAB) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,PREAB) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,REFAB) ((((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,REFAB) ((((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,REFPB) ((((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,REFPB) ((((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) + memSpec.tWR) + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,RD) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,RDA) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,RD) (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,RDA) (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,WR) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,WRA) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,MWR) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,MWRA) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,WR) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,WRA) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,MWR) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (WRA,MWRA) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + + break; + } + case Command::MWRA: + { + // BankGroup (MWRA,RD) ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,RDA) ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_32) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,RD) ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,RDA) ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_max_16) + memSpec.tWTR_L); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,WR) memSpec.BL_n_L_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,WRA) memSpec.BL_n_L_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,WR) memSpec.BL_n_L_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,WRA) memSpec.BL_n_L_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_L_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,MWR) memSpec.BL_n_max_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,MWRA) memSpec.BL_n_max_32 [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_32; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,MWR) memSpec.BL_n_max_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // BankGroup (MWRA,MWRA) memSpec.BL_n_max_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_max_16; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,RD) ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,RDA) ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,RD) ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,RDA) ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + ((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tWTR_S); + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,WR) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWRA,WRA) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWRA,MWR) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWRA,MWRA) (memSpec.BL_n_S_32 + (memSpec.tCK * 2)) [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=False)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + (memSpec.BL_n_S_32 + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWRA,WR) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWRA,WRA) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWRA,MWR) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWRA,MWRA) memSpec.BL_n_S_32 [LastBurstLength(burst_length=32, inversed=False), BankMode(bank_mode='MBG', inversed=True)] SameComponent() + { + if (burstLength == 32) + { + { + const sc_time constraint = currentTime + memSpec.BL_n_S_32; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Rank (MWRA,WR) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,WRA) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,MWR) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,MWRA) memSpec.BL_n_S_16 [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.BL_n_S_16; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,PREAB) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,PREAB) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR) [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) + memSpec.tWR); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,RD) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,RDA) (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_32) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,RD) (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,RDA) (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (((memSpec.tWL + memSpec.BL_n_min_16) + memSpec.tCK) - memSpec.tRL); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,WR) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,WRA) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,MWR) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,MWRA) (memSpec.BL_n_min_32 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=False)] Different(level=) + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_32 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,WR) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,WRA) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,MWR) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + // Channel (MWRA,MWRA) (memSpec.BL_n_min_16 + memSpec.tCK) [LastBurstLength(burst_length=32, inversed=True)] Different(level=) + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + (memSpec.BL_n_min_16 + memSpec.tCK); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + } + + + break; + } + case Command::ACT: + { + // Bank (ACT,RD) (memSpec.tRCD_L + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD_L + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,RDA) (memSpec.tRCD_L + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD_L + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WR) (memSpec.tRCD_S + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD_S + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::WR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WRA) (memSpec.tRCD_S + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD_S + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::WRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWR) (memSpec.tRCD_S + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD_S + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWRA) (memSpec.tRCD_S + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD_S + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,ACT) memSpec.tRCpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCpb; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,PREPB) (memSpec.tRAS + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRAS + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,REFPB) (memSpec.tRCpb + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCpb + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,REFP2B) (memSpec.tRCpb + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCpb + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFP2B][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,REFP2B) (memSpec.tRCpb + memSpec.tCK) [] Per2ComponentsIn(level=) + { + const sc_time constraint = currentTime + (memSpec.tRCpb + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFP2B][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,ACT) memSpec.tRRD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,PREAB) (memSpec.tRAS + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRAS + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,REFAB) (memSpec.tRCpb + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCpb + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,REFPB) (memSpec.tRRD + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRRD + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,REFP2B) memSpec.tRRD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFP2B][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnRank[rank].size() >= 4) + { + sc_time constraint = last4ActivatesOnRank[rank].front() - memSpec.getCommandLength(command) + memSpec.tFAW; + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].pop(); + } + + break; + } + case Command::PREPB: + { + // Bank (PREPB,ACT) (memSpec.tRPpb - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRPpb - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (PREPB,REFPB) memSpec.tRPpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRPpb; + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (PREPB,REFP2B) memSpec.tRPpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRPpb; + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFP2B][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,ACT) (memSpec.tRPab - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRPab - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,PREPB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,PREAB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,REFAB) memSpec.tRPpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRPpb; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::REFPB: + { + // Bank (REFPB,ACT) (memSpec.tRFCpb - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRFCpb - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (REFPB,REFPB) memSpec.tRFCpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCpb; + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,ACT) (memSpec.tpbR2act - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tpbR2act - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,REFPB) memSpec.tpbR2pbR [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tpbR2pbR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnRank[rank].size() >= 4) + { + sc_time constraint = last4ActivatesOnRank[rank].front() - memSpec.getCommandLength(command) + memSpec.tFAW; + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].pop(); + } + + break; + } + case Command::REFP2B: + { + // Bank (REFP2B,ACT) (memSpec.tRFCpb - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRFCpb - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (REFP2B,REFP2B) memSpec.tRFCpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCpb; + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFP2B][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFP2B,ACT) (memSpec.tpbR2act - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tpbR2act - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFP2B,REFP2B) memSpec.tpbR2pbR [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tpbR2pbR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFP2B][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PREAB: + { + // Rank (PREAB,REFAB) memSpec.tRPab [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRPab; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,REFPB) memSpec.tRPab [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRPab; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,REFP2B) memSpec.tRPab [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRPab; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFP2B][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::REFAB: + { + // Rank (REFAB,REFAB) memSpec.tRFCab [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCab; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + + } + nextCommandOnBus = std::max(nextCommandOnBus, currentTime + memSpec.getCommandLength(command)); } -} // namespace DRAMSys +} // namespace DRAMSys \ No newline at end of file diff --git a/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.h b/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.h index e84fe4fa..fa6a4d1b 100644 --- a/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.h +++ b/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,20 +29,20 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #ifndef CHECKERLPDDR5_H #define CHECKERLPDDR5_H +#include "DRAMSys/controller/checker/CheckerIF.h" +#include "DRAMSys/configuration/memspec/MemSpecLPDDR5.h" + #include #include -#include - -#include -#include - namespace DRAMSys { @@ -50,42 +50,30 @@ class CheckerLPDDR5 final : public CheckerIF { public: explicit CheckerLPDDR5(const MemSpecLPDDR5& memSpec); - sc_core::sc_time - timeToSatisfyConstraints(Command command, - const tlm::tlm_generic_payload& payload) const override; + [[nodiscard]] sc_core::sc_time timeToSatisfyConstraints(Command command, const tlm::tlm_generic_payload& payload) const override; void insert(Command command, const tlm::tlm_generic_payload& payload) override; private: const MemSpecLPDDR5& memSpec; - std::vector> lastScheduledByCommandAndRank; - std::vector> lastScheduledByCommandAndBankGroup; - std::vector> lastScheduledByCommandAndBank; - std::vector lastScheduledByCommand; - sc_core::sc_time lastCommandOnBus; - ControllerVector> last4Activates; + template + using CommandArray = std::array; + template + using BankVector = ControllerVector; + template + using BankGroupVector = ControllerVector; + template + using RankVector = ControllerVector; - std::vector> lastBurstLengthByCommandAndRank; - std::vector> lastBurstLengthByCommandAndBankGroup; - std::vector> lastBurstLengthByCommandAndBank; - std::vector lastBurstLengthByCommand; - - const sc_core::sc_time scMaxTime = sc_core::sc_max_time(); - sc_core::sc_time tBURST16; - sc_core::sc_time tBURST32; - sc_core::sc_time tRDWR; - sc_core::sc_time tRDWR_R; - sc_core::sc_time tWRRD_S; - sc_core::sc_time tWRRD_L; - sc_core::sc_time tWRRD_R; - sc_core::sc_time tRDAACT; - sc_core::sc_time tWRPRE; - sc_core::sc_time tWRAACT; - sc_core::sc_time tRDPDEN; - sc_core::sc_time tWRPDEN; - sc_core::sc_time tWRAPDEN; + + CommandArray> nextCommandByBank; + CommandArray> nextCommandByBankGroup; + CommandArray> nextCommandByRank; + + RankVector> last4ActivatesOnRank; + sc_core::sc_time nextCommandOnBus = sc_core::SC_ZERO_TIME; }; } // namespace DRAMSys -#endif // CHECKERLPDDR5_H +#endif // CHECKERLPDDR5_H \ No newline at end of file diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.cpp index 522857ee..1cb25a57 100644 --- a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.cpp +++ b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,12 +29,14 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #include "CheckerDDR3.h" - #include "DRAMSys/common/DebugManager.h" +#include "DRAMSys/common/utils.h" #include @@ -44,461 +46,1601 @@ using namespace tlm; namespace DRAMSys { -CheckerDDR3::CheckerDDR3(const MemSpecDDR3& memSpec) : - memSpec(memSpec) +CheckerDDR3::CheckerDDR3(const MemSpecDDR3& memSpec) : memSpec(memSpec) { - lastScheduledByCommandAndBank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.banksPerChannel, scMaxTime)); - lastScheduledByCommandAndRank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.ranksPerChannel, scMaxTime)); - lastScheduledByCommand = std::vector(Command::numberOfCommands(), scMaxTime); - lastCommandOnBus = scMaxTime; - last4Activates = ControllerVector>(memSpec.ranksPerChannel); + + nextCommandByBank.fill({BankVector(memSpec.banksPerChannel, SC_ZERO_TIME)}); + nextCommandByRank.fill({RankVector(memSpec.ranksPerChannel, SC_ZERO_TIME)}); + last4ActivatesOnRank = RankVector>(memSpec.ranksPerChannel); - tBURST = memSpec.defaultBurstLength / memSpec.dataRate * memSpec.tCK; - tRDWR = memSpec.tRL + tBURST + 2 * memSpec.tCK - memSpec.tWL; - tRDWR_R = memSpec.tRL + tBURST + memSpec.tRTRS - memSpec.tWL; - tWRRD = memSpec.tWL + tBURST + memSpec.tWTR - memSpec.tAL; - tWRRD_R = memSpec.tWL + tBURST + memSpec.tRTRS - memSpec.tRL; - tWRPRE = memSpec.tWL + tBURST + memSpec.tWR; - tRDPDEN = memSpec.tRL + tBURST + memSpec.tCK; - tWRPDEN = memSpec.tWL + tBURST + memSpec.tWR; - tWRAPDEN = memSpec.tWL + tBURST + memSpec.tWR + memSpec.tCK; + tBURST = ((memSpec.defaultBurstLength / memSpec.dataRate) * memSpec.tCK); + tRDWR = (((memSpec.tRL + tBURST) + (memSpec.tCK * 2)) - memSpec.tWL); + tRDWR_R = (((memSpec.tRL + tBURST) + memSpec.tRTRS) - memSpec.tWL); + tWRRD = (((memSpec.tWL + tBURST) + memSpec.tWTR) - memSpec.tAL); + tWRRD_R = (((memSpec.tWL + tBURST) + memSpec.tRTRS) - memSpec.tRL); + tWRPRE = ((memSpec.tWL + tBURST) + memSpec.tWR); + tRDPDEN = ((memSpec.tRL + tBURST) + memSpec.tCK); + tWRPDEN = ((memSpec.tWL + tBURST) + memSpec.tWR); + tWRAPDEN = (((memSpec.tWL + tBURST) + memSpec.tWR) + memSpec.tCK); + } -sc_time CheckerDDR3::timeToSatisfyConstraints(Command command, - const tlm_generic_payload& payload) const +sc_time CheckerDDR3::timeToSatisfyConstraints(Command command, const tlm_generic_payload& payload) const { - Rank rank = ControllerExtension::getRank(payload); Bank bank = ControllerExtension::getBank(payload); + Rank rank = ControllerExtension::getRank(payload); + - sc_time lastCommandStart; sc_time earliestTimeToStart = sc_time_stamp(); - if (command == Command::RD || command == Command::RDA) - { - assert(ControllerExtension::getBurstLength(payload) == 8); - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD - memSpec.tAL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD); - - lastCommandStart = - lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank] - ? lastScheduledByCommand[Command::RD] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD); - - lastCommandStart = lastScheduledByCommand[Command::RDA] != - lastScheduledByCommandAndRank[Command::RDA][rank] - ? lastScheduledByCommand[Command::RDA] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS); - - if (command == Command::RDA) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tWRPRE - memSpec.tRTP - memSpec.tAL); - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD); - - lastCommandStart = lastScheduledByCommand[Command::WR]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD); - - lastCommandStart = lastScheduledByCommand[Command::WRA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSDLL); - } - else if (command == Command::WR || command == Command::WRA || command == Command::MWR || - command == Command::MWRA) - { - assert(ControllerExtension::getBurstLength(payload) == 8); - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD - memSpec.tAL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR); - - lastCommandStart = - lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank] - ? lastScheduledByCommand[Command::RD] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR); - - lastCommandStart = lastScheduledByCommand[Command::RDA] != - lastScheduledByCommandAndRank[Command::RDA][rank] - ? lastScheduledByCommand[Command::RDA] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD); - - lastCommandStart = - lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank] - ? lastScheduledByCommand[Command::WR] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD); - - lastCommandStart = lastScheduledByCommand[Command::WRA] != - lastScheduledByCommandAndRank[Command::WRA][rank] - ? lastScheduledByCommand[Command::WRA] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSDLL); - } - else if (command == Command::ACT) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tAL + memSpec.tRTP + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - - if (last4Activates[rank].size() >= 4) - earliestTimeToStart = - std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW); - } - else if (command == Command::PREPB) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - } - else if (command == Command::PREAB) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - } - else if (command == Command::REFAB) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tAL + memSpec.tRTP + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - } - else if (command == Command::PDEA) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tACTPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE); - } - else if (command == Command::PDXA) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD); - } - else if (command == Command::PDEP) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tREFPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - } - else if (command == Command::PDXP) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD); - } - else if (command == Command::SREFEN) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max( - earliestTimeToStart, - lastCommandStart + std::max(tRDPDEN, memSpec.tAL + memSpec.tRTP + memSpec.tRP)); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec.tRP)); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - } - else if (command == Command::SREFEX) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKESR); - } - else - SC_REPORT_FATAL("CheckerDDR3", "Unknown command!"); - - if (lastCommandOnBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK); + + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByBank[command][bank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByRank[command][rank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandOnBus); return earliestTimeToStart; } void CheckerDDR3::insert(Command command, const tlm_generic_payload& payload) { - Rank rank = ControllerExtension::getRank(payload); - Bank bank = ControllerExtension::getBank(payload); + const Bank bank = ControllerExtension::getBank(payload); + const Rank rank = ControllerExtension::getRank(payload); + - // Hack: Convert MWR to WR and MWRA to WRA - if (command == Command::MWR) - command = Command::WR; - else if (command == Command::MWRA) - command = Command::WRA; - - PRINTDEBUGMESSAGE("CheckerDDR3", - "Changing state on bank " + std::to_string(static_cast(bank)) + - " command is " + command.toString()); - - lastScheduledByCommandAndRank[command][rank] = sc_time_stamp(); - lastScheduledByCommandAndBank[command][bank] = sc_time_stamp(); - lastScheduledByCommand[command] = sc_time_stamp(); - - lastCommandOnBus = sc_time_stamp(); - - if (command == Command::ACT) + PRINTDEBUGMESSAGE("CheckerDDR3", "Changing state on bank " + std::to_string(static_cast(bank)) + + " command is " + command.toString()); + + const sc_time& currentTime = sc_time_stamp(); + + switch (command) { - if (last4Activates[rank].size() == 4) - last4Activates[rank].pop(); - last4Activates[rank].push(sc_time_stamp()); + case Command::RD: + { + // Bank (RD,PREPB) (memSpec.tAL + memSpec.tRTP) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tAL + memSpec.tRTP); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RD,WR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RD,MWR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RD,WRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RD,MWRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PREAB) (memSpec.tAL + memSpec.tRTP) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tAL + memSpec.tRTP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PDEA) tRDPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PDEP) tRDPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,RD) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,RDA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,WR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,MWR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,WRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,MWRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (RD,RD) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,RDA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,WR) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,MWR) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,WRA) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,MWRA) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; } + case Command::WR: + { + // Bank (WR,PREPB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,WR) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,MWR) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,WRA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,MWRA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,RD) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,RDA) std::max(tWRRD, ((tWRPRE - memSpec.tRTP) - memSpec.tAL)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tWRRD, ((tWRPRE - memSpec.tRTP) - memSpec.tAL)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,PDEA) tWRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,WR) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,MWR) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,WRA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,MWRA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,RD) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,RDA) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (WR,WR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,MWR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,WRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,MWRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,RD) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,RDA) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::MWR: + { + // Bank (MWR,PREPB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,WR) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,MWR) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,WRA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,MWRA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,RD) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,RDA) std::max(tWRRD, ((tWRPRE - memSpec.tRTP) - memSpec.tAL)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tWRRD, ((tWRPRE - memSpec.tRTP) - memSpec.tAL)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,PDEA) tWRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,WR) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,MWR) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,WRA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,MWRA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,RD) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,RDA) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (MWR,WR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,MWR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,WRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,MWRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,RD) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,RDA) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::RDA: + { + // Bank (RDA,ACT) ((memSpec.tAL + memSpec.tRTP) + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + ((memSpec.tAL + memSpec.tRTP) + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PDEA) tRDPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PDEP) tRDPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,RD) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,RDA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,WR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,MWR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,WRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,MWRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,REFAB) ((memSpec.tAL + memSpec.tRTP) + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + ((memSpec.tAL + memSpec.tRTP) + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PREAB) (memSpec.tAL + memSpec.tRTP) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tAL + memSpec.tRTP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,SREFEN) std::max(tRDPDEN, ((memSpec.tAL + memSpec.tRTP) + memSpec.tRP)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tRDPDEN, ((memSpec.tAL + memSpec.tRTP) + memSpec.tRP)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (RDA,RD) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,RDA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,WR) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,MWR) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,WRA) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,MWRA) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::WRA: + { + // Bank (WRA,ACT) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PDEA) tWRAPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PDEP) tWRAPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,WR) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,MWR) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,WRA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,MWRA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,RD) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,RDA) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,REFAB) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,SREFEN) std::max(tWRAPDEN, (tWRPRE + memSpec.tRP)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tWRAPDEN, (tWRPRE + memSpec.tRP)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (WRA,WR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,MWR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,WRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,MWRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,RD) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,RDA) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::MWRA: + { + // Bank (MWRA,ACT) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PDEA) tWRAPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PDEP) tWRAPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,WR) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,MWR) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,WRA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,MWRA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,RD) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,RDA) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,REFAB) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,SREFEN) std::max(tWRAPDEN, (tWRPRE + memSpec.tRP)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tWRAPDEN, (tWRPRE + memSpec.tRP)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (MWRA,WR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,MWR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,WRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,MWRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,RD) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,RDA) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::ACT: + { + // Bank (ACT,PREPB) memSpec.tRAS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRAS; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,RD) (memSpec.tRCD - memSpec.tAL) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD - memSpec.tAL); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WR) (memSpec.tRCD - memSpec.tAL) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD - memSpec.tAL); + sc_time &earliestTimeToStart = nextCommandByBank[Command::WR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWR) (memSpec.tRCD - memSpec.tAL) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD - memSpec.tAL); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,RDA) (memSpec.tRCD - memSpec.tAL) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD - memSpec.tAL); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WRA) (memSpec.tRCD - memSpec.tAL) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD - memSpec.tAL); + sc_time &earliestTimeToStart = nextCommandByBank[Command::WRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWRA) (memSpec.tRCD - memSpec.tAL) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD - memSpec.tAL); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,ACT) memSpec.tRC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRC; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,PREAB) memSpec.tRAS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRAS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,ACT) memSpec.tRRD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,PDEA) memSpec.tACTPDEN [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tACTPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,REFAB) memSpec.tRC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,SREFEN) memSpec.tRC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnRank[rank].size() >= 4) + { + sc_time constraint = last4ActivatesOnRank[rank].front() - memSpec.getCommandLength(command) + memSpec.tFAW; + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].pop(); + } + + break; + } + case Command::PREPB: + { + // Bank (PREPB,ACT) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,REFAB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,PDEA) memSpec.tPRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,PDEP) memSpec.tPRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,SREFEN) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PREAB: + { + // Rank (PREAB,ACT) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,REFAB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,SREFEN) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,PDEP) memSpec.tPRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::REFAB: + { + // Rank (REFAB,ACT) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,REFAB) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,SREFEN) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,PDEP) memSpec.tREFPDEN [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tREFPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDEA: + { + // Rank (PDEA,PDXA) memSpec.tPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDXA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDEP: + { + // Rank (PDEP,PDXP) memSpec.tPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDXP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDXA: + { + // Rank (PDXA,PDEA) memSpec.tCKE [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,PDEP) memSpec.tCKE [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,ACT) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,PREPB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,PREAB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,RD) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,RDA) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,WR) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,MWR) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,WRA) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,MWRA) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDXP: + { + // Rank (PDXP,REFAB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,SREFEN) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,ACT) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::SREFEX: + { + // Rank (SREFEX,ACT) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,REFAB) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,PDEP) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,SREFEN) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,RD) memSpec.tXSDLL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSDLL; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,RDA) memSpec.tXSDLL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSDLL; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,WR) memSpec.tXSDLL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSDLL; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,MWR) memSpec.tXSDLL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSDLL; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,WRA) memSpec.tXSDLL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSDLL; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,MWRA) memSpec.tXSDLL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSDLL; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,SREFEX) memSpec.tCKESR [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKESR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEX][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + + } + nextCommandOnBus = std::max(nextCommandOnBus, currentTime + memSpec.getCommandLength(command)); } -} // namespace DRAMSys +} // namespace DRAMSys \ No newline at end of file diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.h b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.h index 9d447250..26e57b4a 100644 --- a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.h +++ b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,14 +29,16 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #ifndef CHECKERDDR3_H #define CHECKERDDR3_H -#include "DRAMSys/configuration/memspec/MemSpecDDR3.h" #include "DRAMSys/controller/checker/CheckerIF.h" +#include "DRAMSys/configuration/memspec/MemSpecDDR3.h" #include #include @@ -47,35 +49,37 @@ namespace DRAMSys class CheckerDDR3 final : public CheckerIF { public: - explicit CheckerDDR3(const MemSpecDDR3 &memSpec); - [[nodiscard]] sc_core::sc_time - timeToSatisfyConstraints(Command command, - const tlm::tlm_generic_payload& payload) const override; + explicit CheckerDDR3(const MemSpecDDR3& memSpec); + [[nodiscard]] sc_core::sc_time timeToSatisfyConstraints(Command command, const tlm::tlm_generic_payload& payload) const override; void insert(Command command, const tlm::tlm_generic_payload& payload) override; private: const MemSpecDDR3& memSpec; - std::vector> lastScheduledByCommandAndBank; - std::vector> lastScheduledByCommandAndRank; - std::vector lastScheduledByCommand; - sc_core::sc_time lastCommandOnBus; - - // Four activate window - ControllerVector> last4Activates; - - const sc_core::sc_time scMaxTime = sc_core::sc_max_time(); sc_core::sc_time tBURST; sc_core::sc_time tRDWR; sc_core::sc_time tRDWR_R; sc_core::sc_time tWRRD; - sc_core::sc_time tWRPRE; sc_core::sc_time tWRRD_R; + sc_core::sc_time tWRPRE; sc_core::sc_time tRDPDEN; sc_core::sc_time tWRPDEN; sc_core::sc_time tWRAPDEN; + template + using CommandArray = std::array; + template + using BankVector = ControllerVector; + template + using RankVector = ControllerVector; + + + CommandArray> nextCommandByBank; + CommandArray> nextCommandByRank; + + RankVector> last4ActivatesOnRank; + sc_core::sc_time nextCommandOnBus = sc_core::SC_ZERO_TIME; }; } // namespace DRAMSys -#endif // CHECKERDDR3_H +#endif // CHECKERDDR3_H \ No newline at end of file diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.cpp index 0e50cd0d..2a1e5777 100644 --- a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.cpp +++ b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,13 +29,14 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #include "CheckerDDR4.h" - #include "DRAMSys/common/DebugManager.h" -#include "DRAMSys/configuration/memspec/MemSpecDDR4.h" +#include "DRAMSys/common/utils.h" #include @@ -45,495 +46,1867 @@ using namespace tlm; namespace DRAMSys { -CheckerDDR4::CheckerDDR4(const MemSpecDDR4 &memSpec) : - memSpec(memSpec) +CheckerDDR4::CheckerDDR4(const MemSpecDDR4& memSpec) : memSpec(memSpec) { - lastScheduledByCommandAndBank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.banksPerChannel, scMaxTime)); - lastScheduledByCommandAndBankGroup = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.bankGroupsPerChannel, scMaxTime)); - lastScheduledByCommandAndRank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.ranksPerChannel, scMaxTime)); - lastScheduledByCommand = std::vector(Command::numberOfCommands(), scMaxTime); - lastCommandOnBus = scMaxTime; - last4Activates = ControllerVector>(memSpec.ranksPerChannel); + + nextCommandByBank.fill({BankVector(memSpec.banksPerChannel, SC_ZERO_TIME)}); + nextCommandByBankGroup.fill({BankGroupVector(memSpec.bankGroupsPerChannel, SC_ZERO_TIME)}); + nextCommandByRank.fill({RankVector(memSpec.ranksPerChannel, SC_ZERO_TIME)}); + last4ActivatesOnRank = RankVector>(memSpec.ranksPerChannel); - tBURST = memSpec.defaultBurstLength / memSpec.dataRate * memSpec.tCK; - tRDWR = memSpec.tRL + tBURST + memSpec.tCK - memSpec.tWL + memSpec.tWPRE; - tRDWR_R = memSpec.tRL + tBURST + memSpec.tRTRS - memSpec.tWL + memSpec.tWPRE; - tWRRD_S = memSpec.tWL + tBURST + memSpec.tWTR_S - memSpec.tAL; - tWRRD_L = memSpec.tWL + tBURST + memSpec.tWTR_L - memSpec.tAL; - tWRRD_R = memSpec.tWL + tBURST + memSpec.tRTRS - memSpec.tRL + memSpec.tRPRE; - tWRPRE = memSpec.tWL + tBURST + memSpec.tWR; - tRDPDEN = memSpec.tRL + tBURST + memSpec.tCK; - tWRPDEN = memSpec.tWL + tBURST + memSpec.tWR; - tWRAPDEN = memSpec.tWL + tBURST + memSpec.tCK + memSpec.tWR; + tBURST = ((memSpec.defaultBurstLength / memSpec.dataRate) * memSpec.tCK); + tRDWR = ((((memSpec.tRL + tBURST) + memSpec.tCK) - memSpec.tWL) + memSpec.tWPRE); + tRDWR_R = ((((memSpec.tRL + tBURST) + memSpec.tRTRS) - memSpec.tWL) + memSpec.tWPRE); + tWRRD_S = (((memSpec.tWL + tBURST) + memSpec.tWTR_S) - memSpec.tAL); + tWRRD_L = (((memSpec.tWL + tBURST) + memSpec.tWTR_L) - memSpec.tAL); + tWRRD_R = ((((memSpec.tWL + tBURST) + memSpec.tRTRS) - memSpec.tRL) + memSpec.tRPRE); + tRDAACT = ((memSpec.tAL + memSpec.tRTP) + memSpec.tRP); + tWRPRE = ((memSpec.tWL + tBURST) + memSpec.tWR); + tWRAACT = (tWRPRE + memSpec.tRP); + tRDPDEN = ((memSpec.tRL + tBURST) + memSpec.tCK); + tWRPDEN = ((memSpec.tWL + tBURST) + memSpec.tWR); + tWRAPDEN = (((memSpec.tWL + tBURST) + memSpec.tWR) + memSpec.tCK); + } -sc_time CheckerDDR4::timeToSatisfyConstraints(Command command, - const tlm_generic_payload& payload) const +sc_time CheckerDDR4::timeToSatisfyConstraints(Command command, const tlm_generic_payload& payload) const { - Rank rank = ControllerExtension::getRank(payload); - BankGroup bankGroup = ControllerExtension::getBankGroup(payload); Bank bank = ControllerExtension::getBank(payload); + BankGroup bankGroup = ControllerExtension::getBankGroup(payload); + Rank rank = ControllerExtension::getRank(payload); + - sc_time lastCommandStart; sc_time earliestTimeToStart = sc_time_stamp(); - if (command == Command::RD || command == Command::RDA) - { - assert(ControllerExtension::getBurstLength(payload) == 8); - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD - memSpec.tAL); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S); - - lastCommandStart = - lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank] - ? lastScheduledByCommand[Command::RD] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S); - - lastCommandStart = lastScheduledByCommand[Command::RDA] != - lastScheduledByCommandAndRank[Command::RDA][rank] - ? lastScheduledByCommand[Command::RDA] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS); - - if (command == Command::RDA) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + tWRPRE - memSpec.tRTP - memSpec.tAL); - } - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_L); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_S); - - lastCommandStart = lastScheduledByCommand[Command::WR]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_L); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_S); - - lastCommandStart = lastScheduledByCommand[Command::WRA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSDLL); - } - else if (command == Command::WR || command == Command::WRA || command == Command::MWR || - command == Command::MWRA) - { - assert(ControllerExtension::getBurstLength(payload) == 8); - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD - memSpec.tAL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR); - - lastCommandStart = - lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank] - ? lastScheduledByCommand[Command::RD] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR); - - lastCommandStart = lastScheduledByCommand[Command::RDA] != - lastScheduledByCommandAndRank[Command::RDA][rank] - ? lastScheduledByCommand[Command::RDA] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S); - - lastCommandStart = - lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank] - ? lastScheduledByCommand[Command::WR] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S); - - lastCommandStart = lastScheduledByCommand[Command::WRA] != - lastScheduledByCommandAndRank[Command::WRA][rank] - ? lastScheduledByCommand[Command::WRA] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSDLL); - } - else if (command == Command::ACT) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD_L); - - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD_S); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tAL + memSpec.tRTP + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - - if (last4Activates[rank].size() >= 4) - earliestTimeToStart = - std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW); - } - else if (command == Command::PREPB) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - } - else if (command == Command::PREAB) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - } - else if (command == Command::REFAB) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tAL + memSpec.tRTP + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - } - else if (command == Command::PDEA) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tACTPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE); - } - else if (command == Command::PDXA) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD); - } - else if (command == Command::PDEP) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tREFPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - } - else if (command == Command::PDXP) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD); - } - else if (command == Command::SREFEN) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max( - earliestTimeToStart, - lastCommandStart + std::max(tRDPDEN, memSpec.tAL + memSpec.tRTP + memSpec.tRP)); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec.tRP)); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - } - else if (command == Command::SREFEX) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKESR); - } - else - SC_REPORT_FATAL("CheckerDDR4", "Unknown command!"); - - if (lastCommandOnBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK); + + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByBank[command][bank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByBankGroup[command][bankGroup]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByRank[command][rank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandOnBus); return earliestTimeToStart; } void CheckerDDR4::insert(Command command, const tlm_generic_payload& payload) { - Rank rank = ControllerExtension::getRank(payload); - BankGroup bankGroup = ControllerExtension::getBankGroup(payload); - Bank bank = ControllerExtension::getBank(payload); + const Bank bank = ControllerExtension::getBank(payload); + const BankGroup bankGroup = ControllerExtension::getBankGroup(payload); + const Rank rank = ControllerExtension::getRank(payload); + - // Hack: Convert MWR to WR and MWRA to WRA - if (command == Command::MWR) - command = Command::WR; - else if (command == Command::MWRA) - command = Command::WRA; - - PRINTDEBUGMESSAGE("CheckerDDR4", - "Changing state on bank " + std::to_string(static_cast(bank)) + - " command is " + command.toString()); - - lastScheduledByCommandAndBank[command][bank] = sc_time_stamp(); - lastScheduledByCommandAndBankGroup[command][bankGroup] = sc_time_stamp(); - lastScheduledByCommandAndRank[command][rank] = sc_time_stamp(); - lastScheduledByCommand[command] = sc_time_stamp(); - lastCommandOnBus = sc_time_stamp(); - - if (command == Command::ACT) + PRINTDEBUGMESSAGE("CheckerDDR4", "Changing state on bank " + std::to_string(static_cast(bank)) + + " command is " + command.toString()); + + const sc_time& currentTime = sc_time_stamp(); + + switch (command) { - if (last4Activates[rank].size() == 4) - last4Activates[rank].pop(); - last4Activates[rank].push(sc_time_stamp()); + case Command::RD: + { + // Bank (RD,PREPB) (memSpec.tAL + memSpec.tRTP) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tAL + memSpec.tRTP); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RD,RD) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RD,RDA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RD,WR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RD,MWR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RD,WRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RD,MWRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RD,RD) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RD,RDA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RD,WR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RD,MWR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RD,WRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RD,MWRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PREAB) (memSpec.tAL + memSpec.tRTP) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tAL + memSpec.tRTP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PDEA) tRDPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PDEP) tRDPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,RD) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,RDA) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,WR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,MWR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,WRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,MWRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (RD,RD) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,RDA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,WR) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,MWR) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,WRA) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,MWRA) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; } + case Command::WR: + { + // Bank (WR,PREPB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,WR) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,MWR) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,WRA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,MWRA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,RD) tWRRD_L [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_L; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,RDA) std::max(tWRRD_L, ((tWRPRE - memSpec.tRTP) - memSpec.tAL)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tWRRD_L, ((tWRPRE - memSpec.tRTP) - memSpec.tAL)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,WR) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,MWR) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,WRA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,MWRA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,RD) tWRRD_L [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,RDA) tWRRD_L [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,PDEA) tWRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,WR) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,MWR) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,WRA) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,MWRA) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,RD) tWRRD_S [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,RDA) tWRRD_S [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (WR,WR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,MWR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,WRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,MWRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,RD) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,RDA) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::MWR: + { + // Bank (MWR,PREPB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,WR) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,MWR) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,WRA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,MWRA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,RD) tWRRD_L [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_L; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,RDA) std::max(tWRRD_L, ((tWRPRE - memSpec.tRTP) - memSpec.tAL)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tWRRD_L, ((tWRPRE - memSpec.tRTP) - memSpec.tAL)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,WR) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,MWR) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,WRA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,MWRA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,RD) tWRRD_L [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,RDA) tWRRD_L [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,PDEA) tWRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,WR) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,MWR) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,WRA) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,MWRA) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,RD) tWRRD_S [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,RDA) tWRRD_S [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (MWR,WR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,MWR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,WRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,MWRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,RD) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,RDA) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::RDA: + { + // Bank (RDA,ACT) tRDAACT [] SameComponent() + { + const sc_time constraint = currentTime + tRDAACT; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RDA,RD) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RDA,RDA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RDA,WR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RDA,MWR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RDA,WRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RDA,MWRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PDEA) tRDPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PDEP) tRDPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,RD) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,RDA) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,WR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,MWR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,WRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,MWRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PREAB) (memSpec.tAL + memSpec.tRTP) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tAL + memSpec.tRTP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,REFAB) tRDAACT [] SameComponent() + { + const sc_time constraint = currentTime + tRDAACT; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,SREFEN) std::max(tRDPDEN, ((memSpec.tAL + memSpec.tRTP) + memSpec.tRP)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tRDPDEN, ((memSpec.tAL + memSpec.tRTP) + memSpec.tRP)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (RDA,WR) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,MWR) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,WRA) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,MWRA) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,RD) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,RDA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::WRA: + { + // Bank (WRA,ACT) tWRAACT [] SameComponent() + { + const sc_time constraint = currentTime + tWRAACT; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,WR) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,MWR) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,WRA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,MWRA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,RD) tWRRD_L [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,RDA) tWRRD_L [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PDEA) tWRAPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PDEP) tWRAPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,WR) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,MWR) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,WRA) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,MWRA) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,RD) tWRRD_S [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,RDA) tWRRD_S [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,REFAB) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,SREFEN) std::max(tWRAPDEN, (tWRPRE + memSpec.tRP)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tWRAPDEN, (tWRPRE + memSpec.tRP)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (WRA,WR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,MWR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,WRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,MWRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,RD) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,RDA) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::MWRA: + { + // BankGroup (MWRA,WR) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,MWR) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,WRA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,MWRA) memSpec.tCCD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,RD) tWRRD_L [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,RDA) tWRRD_L [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PDEA) tWRAPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PDEP) tWRAPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,WR) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,MWR) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,WRA) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,MWRA) memSpec.tCCD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,RD) tWRRD_S [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,RDA) tWRRD_S [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (MWRA,WR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,MWR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,WRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,MWRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,RD) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,RDA) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::ACT: + { + // Bank (ACT,PREPB) memSpec.tRAS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRAS; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,PREAB) memSpec.tRAS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRAS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,RD) (memSpec.tRCD - memSpec.tAL) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD - memSpec.tAL); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WR) (memSpec.tRCD - memSpec.tAL) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD - memSpec.tAL); + sc_time &earliestTimeToStart = nextCommandByBank[Command::WR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWR) (memSpec.tRCD - memSpec.tAL) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD - memSpec.tAL); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,RDA) (memSpec.tRCD - memSpec.tAL) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD - memSpec.tAL); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WRA) (memSpec.tRCD - memSpec.tAL) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD - memSpec.tAL); + sc_time &earliestTimeToStart = nextCommandByBank[Command::WRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWRA) (memSpec.tRCD - memSpec.tAL) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCD - memSpec.tAL); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,ACT) memSpec.tRCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,ACT) memSpec.tRRD_S [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRD_S; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (ACT,ACT) memSpec.tRRD_L [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRD_L; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::ACT][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,PDEA) memSpec.tACTPDEN [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tACTPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,REFAB) memSpec.tRC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,SREFEN) memSpec.tRC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnRank[rank].size() >= 4) + { + sc_time constraint = last4ActivatesOnRank[rank].front() - memSpec.getCommandLength(command) + memSpec.tFAW; + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].pop(); + } + + break; + } + case Command::PREPB: + { + // Bank (PREPB,ACT) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,REFAB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,PDEA) memSpec.tPRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,PDEP) memSpec.tPRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,SREFEN) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PREAB: + { + // Rank (PREAB,ACT) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,REFAB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,PDEP) memSpec.tPRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,SREFEN) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::REFAB: + { + // Rank (REFAB,ACT) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,REFAB) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,SREFEN) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,PDEP) memSpec.tREFPDEN [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tREFPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDEA: + { + // Rank (PDEA,PDXA) memSpec.tPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDXA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDEP: + { + // Rank (PDEP,PDXP) memSpec.tPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDXP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDXA: + { + // Rank (PDXA,PDEA) memSpec.tCKE [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,ACT) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,PREPB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,PREAB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,RD) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,RDA) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,WR) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,MWR) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,WRA) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,MWRA) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDXP: + { + // Rank (PDXP,PDEP) memSpec.tCKE [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,REFAB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,SREFEN) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,ACT) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::SREFEX: + { + // Rank (SREFEX,ACT) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,REFAB) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,PDEP) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,SREFEN) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,RD) memSpec.tXSDLL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSDLL; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,RDA) memSpec.tXSDLL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSDLL; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,WR) memSpec.tXSDLL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSDLL; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,MWR) memSpec.tXSDLL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSDLL; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,WRA) memSpec.tXSDLL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSDLL; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,MWRA) memSpec.tXSDLL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSDLL; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,SREFEX) memSpec.tCKESR [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKESR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEX][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + + } + nextCommandOnBus = std::max(nextCommandOnBus, currentTime + memSpec.getCommandLength(command)); } -} // namespace DRAMSys +} // namespace DRAMSys \ No newline at end of file diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.h b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.h index 945619a0..ec5462b1 100644 --- a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.h +++ b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,18 +29,18 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #ifndef CHECKERDDR4_H #define CHECKERDDR4_H -#include "DRAMSys/configuration/memspec/MemSpecDDR4.h" #include "DRAMSys/controller/checker/CheckerIF.h" +#include "DRAMSys/configuration/memspec/MemSpecDDR4.h" #include -#include -#include #include namespace DRAMSys @@ -50,24 +50,12 @@ class CheckerDDR4 final : public CheckerIF { public: explicit CheckerDDR4(const MemSpecDDR4& memSpec); - [[nodiscard]] sc_core::sc_time - timeToSatisfyConstraints(Command command, - const tlm::tlm_generic_payload& payload) const override; + [[nodiscard]] sc_core::sc_time timeToSatisfyConstraints(Command command, const tlm::tlm_generic_payload& payload) const override; void insert(Command command, const tlm::tlm_generic_payload& payload) override; private: const MemSpecDDR4& memSpec; - std::vector> lastScheduledByCommandAndBank; - std::vector> lastScheduledByCommandAndBankGroup; - std::vector> lastScheduledByCommandAndRank; - std::vector lastScheduledByCommand; - sc_core::sc_time lastCommandOnBus; - - // Four activate window - ControllerVector> last4Activates; - - const sc_core::sc_time scMaxTime = sc_core::sc_max_time(); sc_core::sc_time tBURST; sc_core::sc_time tRDWR; sc_core::sc_time tRDWR_R; @@ -80,8 +68,24 @@ private: sc_core::sc_time tRDPDEN; sc_core::sc_time tWRPDEN; sc_core::sc_time tWRAPDEN; + template + using CommandArray = std::array; + template + using BankVector = ControllerVector; + template + using BankGroupVector = ControllerVector; + template + using RankVector = ControllerVector; + + + CommandArray> nextCommandByBank; + CommandArray> nextCommandByBankGroup; + CommandArray> nextCommandByRank; + + RankVector> last4ActivatesOnRank; + sc_core::sc_time nextCommandOnBus = sc_core::SC_ZERO_TIME; }; } // namespace DRAMSys -#endif // CHECKERDDR4_H +#endif // CHECKERDDR4_H \ No newline at end of file diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.cpp index 4cb8dfe6..1fc8d352 100644 --- a/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.cpp +++ b/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,13 +29,14 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #include "CheckerHBM2.h" - #include "DRAMSys/common/DebugManager.h" -#include "DRAMSys/configuration/memspec/MemSpecHBM2.h" +#include "DRAMSys/common/utils.h" #include @@ -45,488 +46,46 @@ using namespace tlm; namespace DRAMSys { -CheckerHBM2::CheckerHBM2(const MemSpecHBM2& memSpec) : - memSpec(memSpec) +CheckerHBM2::CheckerHBM2(const MemSpecHBM2& memSpec) : memSpec(memSpec) { - lastScheduledByCommandAndBank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.banksPerChannel, scMaxTime)); - lastScheduledByCommandAndBankGroup = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.bankGroupsPerChannel, scMaxTime)); - lastScheduledByCommandAndRank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.ranksPerChannel, scMaxTime)); - lastScheduledByCommand = std::vector(Command::numberOfCommands(), scMaxTime); - lastCommandOnRasBus = scMaxTime; - lastCommandOnCasBus = scMaxTime; - last4Activates = ControllerVector>(memSpec.ranksPerChannel); + + nextCommandByBank.fill({BankVector(memSpec.banksPerChannel, SC_ZERO_TIME)}); + nextCommandByBankGroup.fill({BankGroupVector(memSpec.bankGroupsPerChannel, SC_ZERO_TIME)}); + nextCommandByRank.fill({RankVector(memSpec.ranksPerChannel, SC_ZERO_TIME)}); + last4ActivatesOnRank = RankVector>(memSpec.ranksPerChannel); - bankwiseRefreshCounter = ControllerVector(memSpec.ranksPerChannel); - - tBURST = memSpec.defaultBurstLength / memSpec.dataRate * memSpec.tCK; - tRDPDE = memSpec.tRL + memSpec.tPL + tBURST + memSpec.tCK; + tBURST = ((memSpec.defaultBurstLength / memSpec.dataRate) * memSpec.tCK); + tRDPDE = (((memSpec.tRL + memSpec.tPL) + tBURST) + memSpec.tCK); tRDSRE = tRDPDE; - tWRPRE = memSpec.tWL + tBURST + memSpec.tWR; - tWRPDE = memSpec.tWL + memSpec.tPL + tBURST + memSpec.tCK + memSpec.tWR; - tWRAPDE = memSpec.tWL + memSpec.tPL + tBURST + memSpec.tCK + memSpec.tWR; - tWRRDS = memSpec.tWL + tBURST + memSpec.tWTRS; - tWRRDL = memSpec.tWL + tBURST + memSpec.tWTRL; + tWRPRE = ((memSpec.tWL + tBURST) + memSpec.tWR); + tWRPDE = ((((memSpec.tWL + memSpec.tPL) + tBURST) + memSpec.tCK) + memSpec.tWR); + tWRAPDE = ((((memSpec.tWL + memSpec.tPL) + tBURST) + memSpec.tCK) + memSpec.tWR); + tWRRDS = ((memSpec.tWL + tBURST) + memSpec.tWTRS); + tWRRDL = ((memSpec.tWL + tBURST) + memSpec.tWTRL); + + bankwiseRefreshCounter = ControllerVector(memSpec.ranksPerChannel); } -sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, - const tlm_generic_payload& payload) const +sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic_payload& payload) const { - Rank rank = ControllerExtension::getRank(payload); - BankGroup bankGroup = ControllerExtension::getBankGroup(payload); Bank bank = ControllerExtension::getBank(payload); + BankGroup bankGroup = ControllerExtension::getBankGroup(payload); + Rank rank = ControllerExtension::getRank(payload); + - sc_time lastCommandStart; sc_time earliestTimeToStart = sc_time_stamp(); - if (command == Command::RD || command == Command::RDA) - { - unsigned burstLength = ControllerExtension::getBurstLength(payload); - assert(!(memSpec.ranksPerChannel == 1) || - (burstLength == 2 || burstLength == 4)); // Legacy mode - assert(!(memSpec.ranksPerChannel == 2) || (burstLength == 4)); // Pseudo-channel mode - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDRD + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS); - - if (command == Command::RDA) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec.tRTP); - } - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS); - - lastCommandStart = lastScheduledByCommand[Command::PDXA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - } - else if (command == Command::WR || command == Command::WRA || command == Command::MWR || - command == Command::MWRA) - { - unsigned burstLength = ControllerExtension::getBurstLength(payload); - assert(!(memSpec.ranksPerChannel == 1) || - (burstLength == 2 || burstLength == 4)); // Legacy mode - assert(!(memSpec.ranksPerChannel == 2) || (burstLength == 4)); // Pseudo-channel mode - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDWR + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS); - - lastCommandStart = lastScheduledByCommand[Command::PDXA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - } - else if (command == Command::ACT) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL); - - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRTP + memSpec.tRP - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + tWRPRE + memSpec.tRP - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - memSpec.tCK); - - lastCommandStart = lastScheduledByCommand[Command::PDXA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP - memSpec.tCK); - - lastCommandStart = lastScheduledByCommand[Command::PDXP]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCSB - memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD - memSpec.tCK); - - lastCommandStart = lastScheduledByCommand[Command::SREFEX]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS - 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]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommand[Command::PDXA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - } - else if (command == Command::PREAB) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommand[Command::PDXA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCSB); - } - else if (command == Command::REFAB) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommand[Command::PDXP]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCSB); - - lastCommandStart = lastScheduledByCommand[Command::SREFEX]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - } - else if (command == Command::REFPB) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS + memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommand[Command::PDXA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommand[Command::PDXP]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCSB); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - { - if (bankwiseRefreshCounter[rank] == 0) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCSB); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD); - } - - lastCommandStart = lastScheduledByCommand[Command::SREFEX]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - - if (last4Activates[rank].size() >= 4) - earliestTimeToStart = - std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW); - } - else if (command == Command::PDEA) - { - lastCommandStart = lastScheduledByCommand[Command::RD]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE); - - lastCommandStart = lastScheduledByCommand[Command::RDA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE); - - lastCommandStart = lastScheduledByCommand[Command::WR]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDE); - - lastCommandStart = lastScheduledByCommand[Command::WRA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDE); - - lastCommandStart = lastScheduledByCommand[Command::PDXA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE); - } - else if (command == Command::PDXA) - { - lastCommandStart = lastScheduledByCommand[Command::PDEA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD); - } - else if (command == Command::PDEP) - { - lastCommandStart = lastScheduledByCommand[Command::RD]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE); - - lastCommandStart = lastScheduledByCommand[Command::RDA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE); - - lastCommandStart = lastScheduledByCommand[Command::WRA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDE); - - lastCommandStart = lastScheduledByCommand[Command::PDXP]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE); - - lastCommandStart = lastScheduledByCommand[Command::SREFEX]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - } - else if (command == Command::PDXP) - { - lastCommandStart = lastScheduledByCommand[Command::PDEP]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD); - } - else if (command == Command::SREFEN) - { - lastCommandStart = lastScheduledByCommand[Command::ACT]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK); - - lastCommandStart = lastScheduledByCommand[Command::RDA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + std::max(memSpec.tRTP + memSpec.tRP, tRDSRE)); - - lastCommandStart = lastScheduledByCommand[Command::WRA]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP); - - lastCommandStart = lastScheduledByCommand[Command::PREPB]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommand[Command::PREAB]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP); - - lastCommandStart = lastScheduledByCommand[Command::PDXP]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommand[Command::REFAB]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC); - - lastCommandStart = lastScheduledByCommand[Command::REFPB]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCSB); - - lastCommandStart = lastScheduledByCommand[Command::SREFEX]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS); - } - else if (command == Command::SREFEX) - { - lastCommandStart = lastScheduledByCommand[Command::SREFEN]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKESR); - } - else - SC_REPORT_FATAL("CheckerHBM2", "Unknown command!"); - + + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByBank[command][bank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByBankGroup[command][bankGroup]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByRank[command][rank]); if (command.isRasCommand()) { - if (lastCommandOnRasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandOnRasBus); } - else + if (command.isCasCommand()) { - if (lastCommandOnCasBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec.tCK); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandOnCasBus); } return earliestTimeToStart; @@ -534,41 +93,1242 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, void CheckerHBM2::insert(Command command, const tlm_generic_payload& payload) { - Rank rank = ControllerExtension::getRank(payload); - BankGroup bankGroup = ControllerExtension::getBankGroup(payload); - Bank bank = ControllerExtension::getBank(payload); + const Bank bank = ControllerExtension::getBank(payload); + const BankGroup bankGroup = ControllerExtension::getBankGroup(payload); + const Rank rank = ControllerExtension::getRank(payload); + - // Hack: Convert MWR to WR and MWRA to WRA - if (command == Command::MWR) - command = Command::WR; - else if (command == Command::MWRA) - command = Command::WRA; - - PRINTDEBUGMESSAGE("CheckerHBM2", - "Changing state on bank " + std::to_string(static_cast(bank)) + - " command is " + command.toString()); - - 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()) - lastCommandOnCasBus = sc_time_stamp(); - else if (command == Command::ACT) - lastCommandOnRasBus = sc_time_stamp() + memSpec.tCK; - else - lastCommandOnRasBus = sc_time_stamp(); - - if (command == Command::ACT || command == Command::REFPB) + PRINTDEBUGMESSAGE("CheckerHBM2", "Changing state on bank " + std::to_string(static_cast(bank)) + + " command is " + command.toString()); + + const sc_time& currentTime = sc_time_stamp(); + if (command == Command::REFPB || command == Command::RFMPB) { - if (last4Activates[rank].size() == 4) - last4Activates[rank].pop(); - last4Activates[rank].push(lastCommandOnRasBus); - } - - if (command == Command::REFPB) bankwiseRefreshCounter[rank] = (bankwiseRefreshCounter[rank] + 1) % memSpec.banksPerRank; + } + + switch (command) + { + case Command::RD: + { + // Bank (RD,PREPB) memSpec.tRTP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTP; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RD,RD) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RD,RDA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PREAB) memSpec.tRTP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PDEA) tRDPDE [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PDEP) tRDPDE [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,RD) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,RDA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,WR) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,MWR) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,WRA) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,MWRA) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::WR: + { + // Bank (WR,PREPB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,RDA) ((memSpec.tWL + tBURST) + std::max((memSpec.tWR - memSpec.tRTP), memSpec.tWTRL)) [] SameComponent() + { + const sc_time constraint = currentTime + ((memSpec.tWL + tBURST) + std::max((memSpec.tWR - memSpec.tRTP), memSpec.tWTRL)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,WR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,MWR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,WRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,MWRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,RD) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WR,RDA) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,PDEA) tWRPDE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,WR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,MWR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,WRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,MWRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,RD) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,RDA) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::MWR: + { + // Bank (MWR,PREPB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,RDA) ((memSpec.tWL + tBURST) + std::max((memSpec.tWR - memSpec.tRTP), memSpec.tWTRL)) [] SameComponent() + { + const sc_time constraint = currentTime + ((memSpec.tWL + tBURST) + std::max((memSpec.tWR - memSpec.tRTP), memSpec.tWTRL)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,WR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,MWR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,WRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,MWRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,RD) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWR,RDA) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,PDEA) tWRPDE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,WR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,MWR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,WRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,MWRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,RD) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,RDA) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::RDA: + { + // Bank (RDA,ACT) ((memSpec.tRTP + memSpec.tRP) - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + ((memSpec.tRTP + memSpec.tRP) - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RDA,REFPB) (memSpec.tRTP + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRTP + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RDA,RD) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (RDA,RDA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PDEA) tRDPDE [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PDEP) tRDPDE [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,RD) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,RDA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,WR) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,MWR) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,WRA) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,MWRA) memSpec.tRTW [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTW; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,REFAB) (memSpec.tRTP + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRTP + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PREAB) memSpec.tRTP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRTP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,SREFEN) std::max((memSpec.tRTP + memSpec.tRP), tRDSRE) [] SameComponent() + { + const sc_time constraint = currentTime + std::max((memSpec.tRTP + memSpec.tRP), tRDSRE); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::WRA: + { + // Bank (WRA,ACT) ((tWRPRE + memSpec.tRP) - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + ((tWRPRE + memSpec.tRP) - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WRA,REFPB) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,WR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,MWR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,WRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,MWRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,RD) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (WRA,RDA) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PDEA) tWRAPDE [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PDEP) tWRAPDE [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,WR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,MWR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,WRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,MWRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,RD) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,RDA) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,REFAB) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,SREFEN) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::MWRA: + { + // Bank (MWRA,ACT) ((tWRPRE + memSpec.tRP) - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + ((tWRPRE + memSpec.tRP) - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWRA,REFPB) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,WR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,MWR) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWR][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,WRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::WRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,MWRA) memSpec.tCCDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::MWRA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,RD) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RD][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (MWRA,RDA) tWRRDL [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::RDA][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PDEA) tWRAPDE [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PDEP) tWRAPDE [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,WR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,MWR) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,WRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,MWRA) memSpec.tCCDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,RD) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,RDA) tWRRDS [] SameComponent() + { + const sc_time constraint = currentTime + tWRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,REFAB) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,SREFEN) (tWRPRE + memSpec.tRP) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRP); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::ACT: + { + // Bank (ACT,PREPB) (memSpec.tRAS + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRAS + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,RD) (memSpec.tRCDRD + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCDRD + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,RDA) (memSpec.tRCDRD + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCDRD + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WR) (memSpec.tRCDWR + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCDWR + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::WR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWR) (memSpec.tRCDWR + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCDWR + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WRA) (memSpec.tRCDWR + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCDWR + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::WRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWRA) (memSpec.tRCDWR + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCDWR + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,ACT) memSpec.tRC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRC; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,REFPB) (memSpec.tRC + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRC + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (ACT,ACT) memSpec.tRRDL [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRDL; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::ACT][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (ACT,REFPB) (memSpec.tRRDL + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRRDL + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::REFPB][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,ACT) memSpec.tRRDS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRDS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,REFAB) (memSpec.tRC + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRC + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,SREFEN) (memSpec.tRC + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRC + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,PREAB) (memSpec.tRAS + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRAS + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,REFPB) (memSpec.tRRDS + memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRRDS + memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnRank[rank].size() >= 4) + { + sc_time constraint = last4ActivatesOnRank[rank].front() - memSpec.getCommandLength(command) + memSpec.tFAW; + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].pop(); + } + + break; + } + case Command::PREPB: + { + // Bank (PREPB,ACT) (memSpec.tRP - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRP - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (PREPB,REFPB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,REFAB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,SREFEN) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::REFPB: + { + // Bank (REFPB,ACT) (memSpec.tRFCSB - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRFCSB - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (REFPB,REFPB) memSpec.tRFCSB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCSB; + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (REFPB,REFPB) memSpec.tRREFD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRREFD; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::REFPB][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (REFPB,REFAB) memSpec.tRFCSB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCSB; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::REFAB][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (REFPB,PREAB) memSpec.tRFCSB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCSB; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::PREAB][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // BankGroup (REFPB,SREFEN) memSpec.tRFCSB [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCSB; + sc_time &earliestTimeToStart = nextCommandByBankGroup[Command::SREFEN][bankGroup]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,ACT) (memSpec.tRREFD - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRREFD - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,REFPB) memSpec.tRFCSB [BankwiseRefreshCounter(counter=0, inversed=False)] SameComponent() + { + if (bankwiseRefreshCounter[rank] == 0) + { + const sc_time constraint = currentTime + memSpec.tRFCSB; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (REFPB,REFPB) memSpec.tRREFD [BankwiseRefreshCounter(counter=0, inversed=True)] SameComponent() + { + if (bankwiseRefreshCounter[rank] != 0) + { + const sc_time constraint = currentTime + memSpec.tRREFD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + last4ActivatesOnRank[rank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnRank[rank].size() >= 4) + { + sc_time constraint = last4ActivatesOnRank[rank].front() - memSpec.getCommandLength(command) + memSpec.tFAW; + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].pop(); + } + + break; + } + case Command::PREAB: + { + // Rank (PREAB,ACT) (memSpec.tRP - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRP - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,REFAB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,REFPB) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,SREFEN) memSpec.tRP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::REFAB: + { + // Rank (REFAB,ACT) (memSpec.tRFC - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRFC - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,REFAB) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,REFPB) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,SREFEN) memSpec.tRFC [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFC; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDEA: + { + // Rank (PDEA,PDXA) memSpec.tPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDXA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDEP: + { + // Rank (PDEP,PDXP) memSpec.tPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDXP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDXA: + { + // Rank (PDXA,PDEA) memSpec.tCKE [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,REFPB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,PREPB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,PREAB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,RD) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,RDA) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,WR) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,WRA) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,ACT) (memSpec.tXP - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tXP - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDXP: + { + // Rank (PDXP,PDEP) memSpec.tCKE [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,REFAB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,REFPB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,SREFEN) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,ACT) (memSpec.tXP - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tXP - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::SREFEX: + { + // Rank (SREFEX,ACT) (memSpec.tXS - memSpec.tCK) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tXS - memSpec.tCK); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,REFPB) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,REFAB) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,PDEP) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,SREFEN) memSpec.tXS [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXS; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,SREFEX) memSpec.tCKESR [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKESR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEX][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + + } + if (command.isRasCommand()) + { + nextCommandOnRasBus = std::max(nextCommandOnRasBus, currentTime + memSpec.getCommandLength(command)); + } + if (command.isCasCommand()) + { + nextCommandOnCasBus = std::max(nextCommandOnCasBus, currentTime + memSpec.getCommandLength(command)); + } } -} // namespace DRAMSys +} // namespace DRAMSys \ No newline at end of file diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.h b/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.h index be0bc0db..43c3e5e8 100644 --- a/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.h +++ b/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,14 +29,16 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #ifndef CHECKERHBM2_H #define CHECKERHBM2_H -#include "DRAMSys/configuration/memspec/MemSpecHBM2.h" #include "DRAMSys/controller/checker/CheckerIF.h" +#include "DRAMSys/configuration/memspec/MemSpecHBM2.h" #include #include @@ -48,39 +50,40 @@ class CheckerHBM2 final : public CheckerIF { public: explicit CheckerHBM2(const MemSpecHBM2& memSpec); - [[nodiscard]] sc_core::sc_time - timeToSatisfyConstraints(Command command, - const tlm::tlm_generic_payload& payload) const override; + [[nodiscard]] sc_core::sc_time timeToSatisfyConstraints(Command command, const tlm::tlm_generic_payload& payload) const override; void insert(Command command, const tlm::tlm_generic_payload& payload) override; private: const MemSpecHBM2& memSpec; - std::vector> lastScheduledByCommandAndBank; - std::vector> lastScheduledByCommandAndBankGroup; - std::vector> lastScheduledByCommandAndRank; - std::vector lastScheduledByCommand; - - sc_core::sc_time lastCommandOnRasBus; - sc_core::sc_time lastCommandOnCasBus; - - // Four activate window - ControllerVector> last4Activates; - ControllerVector bankwiseRefreshCounter; - - const sc_core::sc_time scMaxTime = sc_core::sc_max_time(); sc_core::sc_time tBURST; sc_core::sc_time tRDPDE; sc_core::sc_time tRDSRE; sc_core::sc_time tWRPRE; sc_core::sc_time tWRPDE; sc_core::sc_time tWRAPDE; - sc_core::sc_time tRTWR; sc_core::sc_time tWRRDS; sc_core::sc_time tWRRDL; - sc_core::sc_time tWRRDR; + template + using CommandArray = std::array; + template + using BankVector = ControllerVector; + template + using BankGroupVector = ControllerVector; + template + using RankVector = ControllerVector; + + + CommandArray> nextCommandByBank; + CommandArray> nextCommandByBankGroup; + CommandArray> nextCommandByRank; + + RankVector> last4ActivatesOnRank; + ControllerVector bankwiseRefreshCounter; + sc_core::sc_time nextCommandOnRasBus = sc_core::SC_ZERO_TIME; + sc_core::sc_time nextCommandOnCasBus = sc_core::SC_ZERO_TIME; }; } // namespace DRAMSys -#endif // CHECKERHBM2_H +#endif // CHECKERHBM2_H \ No newline at end of file diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.cpp index 3753c75a..b878328a 100644 --- a/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.cpp +++ b/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,12 +29,14 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #include "CheckerLPDDR4.h" - #include "DRAMSys/common/DebugManager.h" +#include "DRAMSys/common/utils.h" #include @@ -44,599 +46,1892 @@ using namespace tlm; namespace DRAMSys { -CheckerLPDDR4::CheckerLPDDR4(const MemSpecLPDDR4& memSpec) : - memSpec(memSpec) +CheckerLPDDR4::CheckerLPDDR4(const MemSpecLPDDR4& memSpec) : memSpec(memSpec) { - lastScheduledByCommandAndBank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.banksPerChannel, scMaxTime)); - lastScheduledByCommandAndRank = std::vector>( - Command::numberOfCommands(), - ControllerVector(memSpec.ranksPerChannel, scMaxTime)); - lastScheduledByCommand = std::vector(Command::numberOfCommands(), scMaxTime); - lastCommandOnBus = scMaxTime; - last4Activates = ControllerVector>(memSpec.ranksPerChannel); + + nextCommandByBank.fill({BankVector(memSpec.banksPerChannel, SC_ZERO_TIME)}); + nextCommandByRank.fill({RankVector(memSpec.ranksPerChannel, SC_ZERO_TIME)}); + last4ActivatesOnRank = RankVector>(memSpec.ranksPerChannel); - lastBurstLengthByCommandAndBank = ControllerVector>( - Command::WRA + 1, ControllerVector(memSpec.banksPerChannel)); - - tBURST = memSpec.defaultBurstLength / memSpec.dataRate * memSpec.tCK; - tRDWR = - memSpec.tRL + memSpec.tDQSCK + tBURST - memSpec.tWL + memSpec.tWPRE + memSpec.tRPST; - tRDWR_R = memSpec.tRL + tBURST + memSpec.tRTRS - memSpec.tWL; - tWRRD = memSpec.tWL + memSpec.tCK + tBURST + memSpec.tWTR; - tWRRD_R = memSpec.tWL + tBURST + memSpec.tRTRS - memSpec.tRL; - tRDPRE = memSpec.tRTP + tBURST - 6 * memSpec.tCK; - tRDAACT = memSpec.tRTP + tBURST - 8 * memSpec.tCK + memSpec.tRPpb; - tWRPRE = memSpec.tWL + tBURST + memSpec.tCK + memSpec.tWR + 2 * memSpec.tCK; - tWRAACT = memSpec.tWL + tBURST + memSpec.tCK + memSpec.tWR + memSpec.tRPpb; - tACTPDEN = 3 * memSpec.tCK + memSpec.tCMDCKE; - tPRPDEN = memSpec.tCK + memSpec.tCMDCKE; - tRDPDEN = 3 * memSpec.tCK + memSpec.tRL + memSpec.tDQSCK + tBURST + memSpec.tRPST; - tWRPDEN = - 3 * memSpec.tCK + memSpec.tWL + - (std::ceil(memSpec.tDQSS / memSpec.tCK) + std::ceil(memSpec.tDQS2DQ / memSpec.tCK)) * - memSpec.tCK + - tBURST + memSpec.tWR; - tWRAPDEN = - 3 * memSpec.tCK + memSpec.tWL + - (std::ceil(memSpec.tDQSS / memSpec.tCK) + std::ceil(memSpec.tDQS2DQ / memSpec.tCK)) * - memSpec.tCK + - tBURST + memSpec.tWR + 2 * memSpec.tCK; - tREFPDEN = memSpec.tCK + memSpec.tCMDCKE; + tBURST = ((memSpec.defaultBurstLength / memSpec.dataRate) * memSpec.tCK); + tRDWR = (((((memSpec.tRL + memSpec.tDQSCK) + tBURST) - memSpec.tWL) + memSpec.tWPRE) + memSpec.tRPST); + tRDWR_R = (((memSpec.tRL + tBURST) + memSpec.tRTRS) - memSpec.tWL); + tWRRD = (((memSpec.tWL + memSpec.tCK) + tBURST) + memSpec.tWTR); + tWRRD_R = (((memSpec.tWL + tBURST) + memSpec.tRTRS) - memSpec.tRL); + tRDPRE = ((memSpec.tRTP + tBURST) - (memSpec.tCK * 6)); + tRDAACT = (((memSpec.tRTP + memSpec.tRPpb) + tBURST) - (memSpec.tCK * 8)); + tWRPRE = (((((memSpec.tCK * 2) + memSpec.tWL) + memSpec.tCK) + tBURST) + memSpec.tWR); + tWRAACT = ((((memSpec.tWL + tBURST) + memSpec.tWR) + memSpec.tCK) + memSpec.tRPpb); + tACTPDEN = ((memSpec.tCK * 3) + memSpec.tCMDCKE); + tPRPDEN = (memSpec.tCK + memSpec.tCMDCKE); + tRDPDEN = (((((memSpec.tCK * 3) + memSpec.tRL) + memSpec.tDQSCK) + tBURST) + memSpec.tRPST); + tWRPDEN = (((((memSpec.tCK * 3) + memSpec.tWL) + ((std::ceil((memSpec.tDQSS / memSpec.tCK)) + std::ceil((memSpec.tDQS2DQ / memSpec.tCK))) * memSpec.tCK)) + tBURST) + memSpec.tWR); + tWRAPDEN = ((((((memSpec.tCK * 3) + memSpec.tWL) + ((std::ceil((memSpec.tDQSS / memSpec.tCK)) + std::ceil((memSpec.tDQS2DQ / memSpec.tCK))) * memSpec.tCK)) + tBURST) + memSpec.tWR) + (memSpec.tCK * 2)); + tREFPDEN = (memSpec.tCK + memSpec.tCMDCKE); + } -sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, - const tlm_generic_payload& payload) const +sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, const tlm_generic_payload& payload) const { - Rank rank = ControllerExtension::getRank(payload); Bank bank = ControllerExtension::getBank(payload); + Rank rank = ControllerExtension::getRank(payload); + - sc_time lastCommandStart; sc_time earliestTimeToStart = sc_time_stamp(); - if (command == Command::RD || command == Command::RDA) - { - unsigned burstLength = ControllerExtension::getBurstLength(payload); - assert((burstLength == 16) || (burstLength == 32)); // TODO: BL16/32 OTF - assert(burstLength <= memSpec.maxBurstLength); - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST); - - lastCommandStart = - lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank] - ? lastScheduledByCommand[Command::RD] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST); - - lastCommandStart = lastScheduledByCommand[Command::RDA] != - lastScheduledByCommandAndRank[Command::RDA][rank] - ? lastScheduledByCommand[Command::RDA] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS); - - if (command == Command::RDA) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE - tRDPRE); - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD); - - lastCommandStart = - lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank] - ? lastScheduledByCommand[Command::WR] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD); - - lastCommandStart = lastScheduledByCommand[Command::WRA] != - lastScheduledByCommandAndRank[Command::WRA][rank] - ? lastScheduledByCommand[Command::WRA] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - } - else if (command == Command::WR || command == Command::WRA || command == Command::MWR || - command == Command::MWRA) - { - unsigned burstLength = ControllerExtension::getBurstLength(payload); - assert((burstLength == 16) || (burstLength == 32)); - assert(burstLength <= memSpec.maxBurstLength); - - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR); - - lastCommandStart = - lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank] - ? lastScheduledByCommand[Command::RD] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR); - - lastCommandStart = lastScheduledByCommand[Command::RDA] != - lastScheduledByCommandAndRank[Command::RDA][rank] - ? lastScheduledByCommand[Command::RDA] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST); - - lastCommandStart = - lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank] - ? lastScheduledByCommand[Command::WR] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST); - - lastCommandStart = lastScheduledByCommand[Command::WRA] != - lastScheduledByCommandAndRank[Command::WRA][rank] - ? lastScheduledByCommand[Command::WRA] - : scMaxTime; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS); - - if (command == Command::MWR || command == Command::MWRA) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - { - if (lastBurstLengthByCommandAndBank[Command::WR][bank] == 32) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + memSpec.tCCDMW + 8 * memSpec.tCK); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDMW); - } - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank]; - { - if (lastBurstLengthByCommandAndBank[Command::WRA][bank] == 32) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + memSpec.tCCDMW + 8 * memSpec.tCK); - else - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDMW); - } - } - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - } - else if (command == Command::ACT) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDAACT); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAACT); - - lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb - 2 * memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab - 2 * memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRFCab - 2 * memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, - lastCommandStart + memSpec.tRFCpb - 2 * memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD - 2 * memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR - 2 * memSpec.tCK); - - if (last4Activates[rank].size() >= 4) - earliestTimeToStart = - std::max(earliestTimeToStart, - last4Activates[rank].front() + memSpec.tFAW - 3 * memSpec.tCK); - } - else if (command == Command::PREPB) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + 2 * memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - } - else if (command == Command::PREAB) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + 2 * memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb); - } - else if (command == Command::REFAB) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + 2 * memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec.tRPpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRPpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR); - } - else if (command == Command::REFPB) - { - lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + 2 * memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD + 2 * memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec.tRPpb); - - lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRPpb); - - lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR); - - if (last4Activates[rank].size() >= 4) - earliestTimeToStart = std::max( - earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW - memSpec.tCK); - } - else if (command == Command::PDEA) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tACTPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tPRPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tREFPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE); - } - else if (command == Command::PDXA) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE); - } - else if (command == Command::PDEP) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tPRPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tPRPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tREFPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tREFPDEN); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR); - } - else if (command == Command::PDXP) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE); - } - else if (command == Command::SREFEN) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + 2 * memSpec.tCK); - - lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max( - earliestTimeToStart, lastCommandStart + std::max(tRDPDEN, tRDPRE + memSpec.tRPpb)); - - lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = - std::max(earliestTimeToStart, - lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec.tRPpb)); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab); - - lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab); - - lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb); - - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR); - } - else if (command == Command::SREFEX) - { - lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank]; - if (lastCommandStart != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tSR); - } - else - SC_REPORT_FATAL("CheckerLPDDR4", "Unknown command!"); - - // Check if command bus is free - if (lastCommandOnBus != scMaxTime) - earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK); + + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByBank[command][bank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandByRank[command][rank]); + earliestTimeToStart = std::max(earliestTimeToStart, nextCommandOnBus); return earliestTimeToStart; } void CheckerLPDDR4::insert(Command command, const tlm_generic_payload& payload) { - Rank rank = ControllerExtension::getRank(payload); - Bank bank = ControllerExtension::getBank(payload); + const Bank bank = ControllerExtension::getBank(payload); + const Rank rank = ControllerExtension::getRank(payload); + const unsigned burstLength = ControllerExtension::getBurstLength(payload); - // Hack: Convert MWR to WR and MWRA to WRA - if (command == Command::MWR) - command = Command::WR; - else if (command == Command::MWRA) - command = Command::WRA; - - PRINTDEBUGMESSAGE("CheckerLPDDR4", - "Changing state on bank " + std::to_string(static_cast(bank)) + - " command is " + command.toString()); - - lastScheduledByCommandAndBank[command][bank] = sc_time_stamp(); - lastScheduledByCommandAndRank[command][rank] = sc_time_stamp(); - lastScheduledByCommand[command] = sc_time_stamp(); - - lastCommandOnBus = sc_time_stamp() + memSpec.getCommandLength(command) - memSpec.tCK; - - if (command == Command::ACT || command == Command::REFPB) + PRINTDEBUGMESSAGE("CheckerLPDDR4", "Changing state on bank " + std::to_string(static_cast(bank)) + + " command is " + command.toString()); + + const sc_time& currentTime = sc_time_stamp(); + + switch (command) { - if (last4Activates[rank].size() == 4) - last4Activates[rank].pop(); - last4Activates[rank].push(lastCommandOnBus); - } - - if (command.isCasCommand()) + case Command::RD: { - unsigned burstLength = ControllerExtension::getBurstLength(payload); - lastBurstLengthByCommandAndBank[command][bank] = burstLength; + // Bank (RD,PREPB) (memSpec.tRRD + (memSpec.tCK * 2)) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRRD + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PREAB) tRDPRE [] SameComponent() + { + const sc_time constraint = currentTime + tRDPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PDEA) tRDPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,PDEP) tRDPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,RD) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,RDA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,WR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,MWR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,WRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RD,MWRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (RD,RD) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,RDA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,WR) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,MWR) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,WRA) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RD,MWRA) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; } + case Command::WR: + { + // Bank (WR,PREPB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WR,MWR) memSpec.tCCDMW [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCDMW; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,MWRA) memSpec.tCCDMW [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCDMW; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,MWR) (memSpec.tCCDMW + (memSpec.tCK * 8)) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCDMW + (memSpec.tCK * 8)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,MWRA) (memSpec.tCCDMW + (memSpec.tCK * 8)) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCDMW + (memSpec.tCK * 8)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WR,RDA) std::max(tWRRD, (tWRPRE - tRDPRE)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tWRRD, (tWRPRE - tRDPRE)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,PDEA) tWRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,WR) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,MWR) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,WRA) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,MWRA) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,WR) (memSpec.tCCD + (memSpec.tCK * 8)) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD + (memSpec.tCK * 8)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,MWR) (memSpec.tCCD + (memSpec.tCK * 8)) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD + (memSpec.tCK * 8)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,WRA) (memSpec.tCCD + (memSpec.tCK * 8)) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD + (memSpec.tCK * 8)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,MWRA) (memSpec.tCCD + (memSpec.tCK * 8)) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD + (memSpec.tCK * 8)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WR,RD) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WR,RDA) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (WR,WR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,MWR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,WRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,MWRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,RD) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WR,RDA) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::MWR: + { + // Bank (MWR,PREPB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWR,MWR) memSpec.tCCDMW [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCDMW; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,MWRA) memSpec.tCCDMW [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCDMW; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWR,RDA) std::max(tWRRD, (tWRPRE - tRDPRE)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tWRRD, (tWRPRE - tRDPRE)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,PDEA) tWRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,WR) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,MWR) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,WRA) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,MWRA) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWR,RD) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWR,RDA) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (MWR,WR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,MWR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,WRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,MWRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,RD) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWR,RDA) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::RDA: + { + // Bank (RDA,ACT) tRDAACT [] SameComponent() + { + const sc_time constraint = currentTime + tRDAACT; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (RDA,REFPB) (tRDPRE + memSpec.tRPpb) [] SameComponent() + { + const sc_time constraint = currentTime + (tRDPRE + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PREAB) tRDPRE [] SameComponent() + { + const sc_time constraint = currentTime + tRDPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PDEA) tRDPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,PDEP) tRDPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tRDPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,RD) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,RDA) memSpec.tCCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,WR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,MWR) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,WRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,MWRA) tRDWR [] SameComponent() + { + const sc_time constraint = currentTime + tRDWR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,REFAB) (tRDPRE + memSpec.tRPpb) [] SameComponent() + { + const sc_time constraint = currentTime + (tRDPRE + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (RDA,SREFEN) std::max(tRDPDEN, (tRDPRE + memSpec.tRPpb)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tRDPDEN, (tRDPRE + memSpec.tRPpb)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (RDA,RD) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,RDA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,WR) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,MWR) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,WRA) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (RDA,MWRA) tRDWR_R [] Different(level=) + { + const sc_time constraint = currentTime + tRDWR_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::WRA: + { + // Bank (WRA,MWR) memSpec.tCCDMW [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCDMW; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,MWRA) memSpec.tCCDMW [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCDMW; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,MWR) (memSpec.tCCDMW + (memSpec.tCK * 8)) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCDMW + (memSpec.tCK * 8)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,MWRA) (memSpec.tCCDMW + (memSpec.tCK * 8)) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCDMW + (memSpec.tCK * 8)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (WRA,ACT) tWRAACT [] SameComponent() + { + const sc_time constraint = currentTime + tWRAACT; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (WRA,REFPB) (tWRPRE + memSpec.tRPpb) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PDEA) tWRAPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,PDEP) tWRAPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,WR) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,MWR) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,WRA) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,MWRA) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,WR) (memSpec.tCCD + (memSpec.tCK * 8)) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD + (memSpec.tCK * 8)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,MWR) (memSpec.tCCD + (memSpec.tCK * 8)) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD + (memSpec.tCK * 8)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,WRA) (memSpec.tCCD + (memSpec.tCK * 8)) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD + (memSpec.tCK * 8)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,MWRA) (memSpec.tCCD + (memSpec.tCK * 8)) [LastBurstLength(burst_length=32, inversed=False)] SameComponent() + { + if (burstLength == 32) + { + const sc_time constraint = currentTime + (memSpec.tCCD + (memSpec.tCK * 8)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (WRA,RD) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,RDA) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,REFAB) (tWRPRE + memSpec.tRPpb) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (WRA,SREFEN) std::max(tWRAPDEN, (tWRPRE + memSpec.tRPpb)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tWRAPDEN, (tWRPRE + memSpec.tRPpb)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (WRA,WR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,MWR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,WRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,MWRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,RD) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (WRA,RDA) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::MWRA: + { + // Bank (MWRA,MWR) memSpec.tCCDMW [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCDMW; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWRA,MWRA) memSpec.tCCDMW [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCDMW; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Bank (MWRA,ACT) tWRAACT [] SameComponent() + { + const sc_time constraint = currentTime + tWRAACT; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (MWRA,REFPB) (tWRPRE + memSpec.tRPpb) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PREAB) tWRPRE [] SameComponent() + { + const sc_time constraint = currentTime + tWRPRE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PDEA) tWRAPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,PDEP) tWRAPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tWRAPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,WR) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,MWR) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,WRA) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,MWRA) memSpec.tCCD [LastBurstLength(burst_length=32, inversed=True)] SameComponent() + { + if (burstLength != 32) + { + const sc_time constraint = currentTime + memSpec.tCCD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Rank (MWRA,RD) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,RDA) tWRRD [] SameComponent() + { + const sc_time constraint = currentTime + tWRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,REFAB) (tWRPRE + memSpec.tRPpb) [] SameComponent() + { + const sc_time constraint = currentTime + (tWRPRE + memSpec.tRPpb); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (MWRA,SREFEN) std::max(tWRAPDEN, (tWRPRE + memSpec.tRPpb)) [] SameComponent() + { + const sc_time constraint = currentTime + std::max(tWRAPDEN, (tWRPRE + memSpec.tRPpb)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Channel (MWRA,WR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,MWR) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWR][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,WRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,MWRA) (tBURST + memSpec.tRTRS) [] Different(level=) + { + const sc_time constraint = currentTime + (tBURST + memSpec.tRTRS); + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::MWRA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,RD) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + // Channel (MWRA,RDA) tWRRD_R [] Different(level=) + { + const sc_time constraint = currentTime + tWRRD_R; + for (unsigned int i = memSpec.ranksPerChannel * static_cast(0); i < memSpec.ranksPerChannel * (1 + static_cast(0)); i++) + { + Rank currentRank{i}; + + if (currentRank == rank) + continue; + + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][currentRank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + } + + + break; + } + case Command::ACT: + { + // Bank (ACT,PREPB) (memSpec.tRAS + (memSpec.tCK * 2)) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRAS + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::PREPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,RD) memSpec.tRCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RD][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WR) memSpec.tRCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWR) memSpec.tRCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWR][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,RDA) memSpec.tRCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::RDA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,WRA) memSpec.tRCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::WRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,MWRA) memSpec.tRCD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCD; + sc_time &earliestTimeToStart = nextCommandByBank[Command::MWRA][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,ACT) memSpec.tRCpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRCpb; + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (ACT,REFPB) (memSpec.tRCpb + (memSpec.tCK * 2)) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCpb + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,PREAB) (memSpec.tRAS + (memSpec.tCK * 2)) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRAS + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,ACT) memSpec.tRRD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRRD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,REFAB) (memSpec.tRCpb + (memSpec.tCK * 2)) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCpb + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,SREFEN) (memSpec.tRCpb + (memSpec.tCK * 2)) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRCpb + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,REFPB) (memSpec.tRRD + (memSpec.tCK * 2)) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRRD + (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (ACT,PDEA) tACTPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tACTPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnRank[rank].size() >= 4) + { + sc_time constraint = last4ActivatesOnRank[rank].front() - memSpec.getCommandLength(command) + memSpec.tFAW; + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].pop(); + } + + break; + } + case Command::PREPB: + { + // Bank (PREPB,ACT) (memSpec.tRPpb - (memSpec.tCK * 2)) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRPpb - (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Bank (PREPB,REFPB) memSpec.tRPpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRPpb; + sc_time &earliestTimeToStart = nextCommandByBank[Command::REFPB][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,PREPB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,PREAB) memSpec.tPPD [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tPPD; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,REFAB) memSpec.tRPpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRPpb; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,SREFEN) memSpec.tRPpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRPpb; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,PDEA) tPRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tPRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREPB,PDEP) tPRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tPRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::REFPB: + { + // Bank (REFPB,ACT) (memSpec.tRFCpb - (memSpec.tCK * 2)) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRFCpb - (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByBank[Command::ACT][bank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,REFAB) memSpec.tRFCpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCpb; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,REFPB) memSpec.tRFCpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCpb; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,ACT) (memSpec.tRRD - (memSpec.tCK * 2)) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRRD - (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,PREAB) memSpec.tRFCpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCpb; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,SREFEN) memSpec.tRFCpb [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCpb; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,PDEA) tREFPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tREFPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFPB,PDEP) tREFPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tREFPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].push(currentTime + memSpec.getCommandLength(command)); + + if (last4ActivatesOnRank[rank].size() >= 4) + { + sc_time constraint = last4ActivatesOnRank[rank].front() - memSpec.getCommandLength(command) + memSpec.tFAW; + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + { + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + last4ActivatesOnRank[rank].pop(); + } + + break; + } + case Command::PREAB: + { + // Rank (PREAB,ACT) (memSpec.tRPab - (memSpec.tCK * 2)) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRPab - (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,REFAB) memSpec.tRPab [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRPab; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,SREFEN) memSpec.tRPab [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRPab; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,REFPB) memSpec.tRPab [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRPab; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PREAB,PDEP) tPRPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tPRPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::REFAB: + { + // Rank (REFAB,ACT) (memSpec.tRFCab - (memSpec.tCK * 2)) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tRFCab - (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,PDEP) tREFPDEN [] SameComponent() + { + const sc_time constraint = currentTime + tREFPDEN; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,REFAB) memSpec.tRFCab [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCab; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,REFPB) memSpec.tRFCab [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCab; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (REFAB,SREFEN) memSpec.tRFCab [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tRFCab; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDEA: + { + // Rank (PDEA,PDXA) memSpec.tCKE [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDXA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDEP: + { + // Rank (PDEP,PDXP) memSpec.tCKE [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDXP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::SREFEN: + { + // Rank (SREFEN,SREFEX) memSpec.tSR [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tSR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEX][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDXA: + { + // Rank (PDXA,PDEA) memSpec.tCKE [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,ACT) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,PREPB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,PREAB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PREAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,RD) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RD][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,RDA) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::RDA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,WR) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WR][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,WRA) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::WRA][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXA,REFPB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::PDXP: + { + // Rank (PDXP,PDEP) memSpec.tCKE [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tCKE; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,REFAB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,REFPB) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,SREFEN) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (PDXP,ACT) memSpec.tXP [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXP; + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + case Command::SREFEX: + { + // Rank (SREFEX,ACT) (memSpec.tXSR - (memSpec.tCK * 2)) [] SameComponent() + { + const sc_time constraint = currentTime + (memSpec.tXSR - (memSpec.tCK * 2)); + sc_time &earliestTimeToStart = nextCommandByRank[Command::ACT][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,REFAB) memSpec.tXSR [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFAB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,REFPB) memSpec.tXSR [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::REFPB][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,PDEP) memSpec.tXSR [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::PDEP][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + // Rank (SREFEX,SREFEN) memSpec.tXSR [] SameComponent() + { + const sc_time constraint = currentTime + memSpec.tXSR; + sc_time &earliestTimeToStart = nextCommandByRank[Command::SREFEN][rank]; + earliestTimeToStart = std::max(earliestTimeToStart, constraint); + } + + + break; + } + + } + nextCommandOnBus = std::max(nextCommandOnBus, currentTime + memSpec.getCommandLength(command)); } -} // namespace DRAMSys +} // namespace DRAMSys \ No newline at end of file diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.h b/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.h index cda1d9ee..4955199e 100644 --- a/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.h +++ b/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, RPTU Kaiserslautern-Landau + * Copyright (c) 2024, RPTU Kaiserslautern-Landau * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,14 +29,16 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * Author: Lukas Steiner + * Authors: + * Lukas Steiner + * Derek Christ */ #ifndef CHECKERLPDDR4_H #define CHECKERLPDDR4_H -#include "DRAMSys/configuration/memspec/MemSpecLPDDR4.h" #include "DRAMSys/controller/checker/CheckerIF.h" +#include "DRAMSys/configuration/memspec/MemSpecLPDDR4.h" #include #include @@ -48,35 +50,20 @@ class CheckerLPDDR4 final : public CheckerIF { public: explicit CheckerLPDDR4(const MemSpecLPDDR4& memSpec); - [[nodiscard]] sc_core::sc_time - timeToSatisfyConstraints(Command command, - const tlm::tlm_generic_payload& payload) const override; + [[nodiscard]] sc_core::sc_time timeToSatisfyConstraints(Command command, const tlm::tlm_generic_payload& payload) const override; void insert(Command command, const tlm::tlm_generic_payload& payload) override; private: const MemSpecLPDDR4& memSpec; - std::vector> lastScheduledByCommandAndBank; - std::vector> lastScheduledByCommandAndRank; - std::vector lastScheduledByCommand; - sc_core::sc_time lastCommandOnBus; - - ControllerVector> lastBurstLengthByCommandAndBank; - - // Four activate window - ControllerVector> last4Activates; - - const sc_core::sc_time scMaxTime = sc_core::sc_max_time(); sc_core::sc_time tBURST; sc_core::sc_time tRDWR; sc_core::sc_time tRDWR_R; sc_core::sc_time tWRRD; sc_core::sc_time tWRRD_R; sc_core::sc_time tRDPRE; - sc_core::sc_time tRDAPRE; sc_core::sc_time tRDAACT; sc_core::sc_time tWRPRE; - sc_core::sc_time tWRAPRE; sc_core::sc_time tWRAACT; sc_core::sc_time tACTPDEN; sc_core::sc_time tPRPDEN; @@ -84,8 +71,21 @@ private: sc_core::sc_time tWRPDEN; sc_core::sc_time tWRAPDEN; sc_core::sc_time tREFPDEN; + template + using CommandArray = std::array; + template + using BankVector = ControllerVector; + template + using RankVector = ControllerVector; + + + CommandArray> nextCommandByBank; + CommandArray> nextCommandByRank; + + RankVector> last4ActivatesOnRank; + sc_core::sc_time nextCommandOnBus = sc_core::SC_ZERO_TIME; }; } // namespace DRAMSys -#endif // CHECKERLPDDR4_H +#endif // CHECKERLPDDR4_H \ No newline at end of file