Merge branch 'wip/unit_test_preps' into 'develop'

Move timing checks out of controller managers (BM, RM, PDM).

See merge request ems/astdm/modeling.dram/dram.sys.5!14

extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.cpp

@@ -48,22 +48,22 @@ CheckerDDR5::CheckerDDR5(const Configuration& config)
         SC_REPORT_FATAL("CheckerDDR5", "Wrong MemSpec chosen");
 
     lastScheduledByCommandAndDimmRank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->dimmRanksPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->dimmRanksPerChannel, scMaxTime));
     lastScheduledByCommandAndPhysicalRank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->physicalRanksPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->physicalRanksPerChannel, scMaxTime));
     lastScheduledByCommandAndLogicalRank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->logicalRanksPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->logicalRanksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, sc_max_time()));
-    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), sc_max_time());
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
+    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
     // Required for Same Bank Refresh
     lastScheduledByCommandAndBankInGroup = std::vector<std::vector<sc_time>>(Command::numberOfCommands(),
-            std::vector<sc_time>(memSpec->ranksPerChannel * memSpec->banksPerGroup, sc_max_time()));
-    lastCommandOnBus = sc_max_time();
-    dummyCommandOnBus.start = sc_max_time();
-    dummyCommandOnBus.end = sc_max_time();
+            std::vector<sc_time>(memSpec->ranksPerChannel * memSpec->banksPerGroup, scMaxTime));
+    lastCommandOnBus = scMaxTime;
+    dummyCommandOnBus.start = scMaxTime;
+    dummyCommandOnBus.end = scMaxTime;
 
     last4ActivatesLogical = std::vector<std::queue<sc_time>>(memSpec->logicalRanksPerChannel);
     last4ActivatesPhysical = std::vector<std::queue<sc_time>>(memSpec->physicalRanksPerChannel);
@@ -138,23 +138,23 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         assert(burstLength <= memSpec->maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_L_slr);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_M_slr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RD][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RD][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndPhysicalRank[Command::RD][physicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST32);
@@ -182,15 +182,15 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_M_slr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RDA][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RDA][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndPhysicalRank[Command::RDA][physicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST32);
@@ -220,7 +220,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
             {
                 if (lastBurstLengthByCommandAndBank[Command::WR][bank.ID()] == 32)
                     earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDA + tBURST16);
@@ -230,7 +230,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::WR][bank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tCCD_L_WTR_slr + tBURST16);
@@ -239,7 +239,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tCCD_M_WTR_slr + tBURST16);
@@ -248,7 +248,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WR][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndLogicalRank[Command::WR][logicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tCCD_S_WTR_slr + tBURST16);
@@ -257,7 +257,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::WR][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndPhysicalRank[Command::WR][physicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tCCD_WTR_dlr + tBURST16);
@@ -285,7 +285,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tCCD_M_WTR_slr + tBURST16);
@@ -294,7 +294,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WRA][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndLogicalRank[Command::WRA][logicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tCCD_S_WTR_slr + tBURST16);
@@ -303,7 +303,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::WRA][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndPhysicalRank[Command::WRA][physicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tCCD_WTR_dlr + tBURST16);
@@ -338,11 +338,11 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         assert(burstLength <= memSpec->maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::RD][bankGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tCCD_L_RTW_slr + tBURST16);
@@ -351,7 +351,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RD][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndLogicalRank[Command::RD][logicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tCCD_S_RTW_slr + tBURST16);
@@ -360,7 +360,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RD][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndPhysicalRank[Command::RD][physicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tCCD_RTW_dlr + tBURST16);
@@ -388,7 +388,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::RDA][bankGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tCCD_L_RTW_slr + tBURST16);
@@ -397,7 +397,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RDA][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndLogicalRank[Command::RDA][logicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tCCD_S_RTW_slr + tBURST16);
@@ -406,7 +406,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RDA][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndPhysicalRank[Command::RDA][physicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tCCD_RTW_dlr + tBURST16);
@@ -436,7 +436,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         if (burstLength == 16 && memSpec->bitWidth == 4) // second WR requires RMW
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
             {
                 if (lastBurstLengthByCommandAndBank[Command::WR][bank.ID()] == 32)
                 {
@@ -464,7 +464,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         else // no RMW
         {
             lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
             {
                 if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup.ID()] == 32)
                 {
@@ -478,11 +478,11 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WR][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S_WR_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::WR][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndPhysicalRank[Command::WR][physicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST32);
@@ -512,7 +512,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         if (burstLength == 16 && memSpec->bitWidth == 4) // second WR requires RMW
         {
             lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
             {
                 if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup.ID()] == 32)
                 {
@@ -527,7 +527,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         else // no RMW
         {
             lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
             {
                 if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup.ID()] == 32)
                 {
@@ -541,11 +541,11 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WRA][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S_WR_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::WRA][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndPhysicalRank[Command::WRA][physicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST32);
@@ -575,27 +575,27 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD_L_slr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::ACT][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD_S_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::ACT][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD_dlr);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDAACT);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::WRA][bank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAACT + tBURST16);
@@ -604,51 +604,51 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::PREAB][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::PRESB][bankInGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFAB][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_slr - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMAB][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        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.ID()];
-        if (lastCommandStart != sc_max_time())
+        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.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFSBRD_slr - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::REFSB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFSBRD_dlr - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::RFMSB][bankInGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCsb_slr - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMSB][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFSBRD_slr - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RFMSB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFSBRD_dlr - cmdLengthDiff);
 
         if (last4ActivatesLogical[logicalRank.ID()].size() >= 4)
@@ -662,15 +662,15 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::WR][bank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + tBURST16 + cmdLengthDiff);
@@ -679,33 +679,33 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREPB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREAB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PRESB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::ACT][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RD][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RDA][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WR][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndLogicalRank[Command::WR][logicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + tBURST16 + cmdLengthDiff);
@@ -714,7 +714,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WRA][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndLogicalRank[Command::WRA][logicalRank.ID()])
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + tBURST16 + cmdLengthDiff);
@@ -723,11 +723,11 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREPB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREAB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         // PRESB tPPD
@@ -735,19 +735,19 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PRESB)
     {
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::ACT][bankInGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::RD][bankInGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::RDA][bankInGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::WR][bankInGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankInGroup[Command::WR][bankInGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + tBURST16 + cmdLengthDiff);
@@ -756,7 +756,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::WRA][bankInGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankInGroup[Command::WRA][bankInGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + tBURST16 + cmdLengthDiff);
@@ -765,27 +765,27 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREPB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         // PREA tRP
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PRESB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
     }
     else if (command == Command::REFAB || command == Command::RFMAB)
     {
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::ACT][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RDA][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDAACT + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WRA][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndLogicalRank[Command::WRA][logicalRank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + tBURST16 + memSpec->tRP + cmdLengthDiff);
@@ -794,35 +794,35 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::PREPB][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::PREAB][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFAB][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::REFAB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dlr);
 
         lastCommandStart = lastScheduledByCommandAndDimmRank[Command::REFAB][dimmRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dpr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMAB][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RFMAB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dlr);
 
         lastCommandStart = lastScheduledByCommandAndDimmRank[Command::RFMAB][dimmRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dpr);
 
         // REFSB tRFCsb_slr/dlr
@@ -831,19 +831,19 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::REFSB || command == Command::RFMSB)
     {
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::ACT][bankInGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::ACT][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD_L_slr + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::RDA][bankInGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDAACT + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::WRA][bankInGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankInGroup[Command::WRA][bankInGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAACT + tBURST16 + cmdLengthDiff);
@@ -852,57 +852,57 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::PREPB][bankInGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         // PREA tRP
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::PRESB][bankInGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFAB][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_slr);
 
         // TODO: check this
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::REFAB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dlr);
 
         // TODO: check this
         lastCommandStart = lastScheduledByCommandAndDimmRank[Command::REFAB][dimmRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dpr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMAB][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_slr);
 
         // TODO: check this
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RFMAB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dlr);
 
         // TODO: check this
         lastCommandStart = lastScheduledByCommandAndDimmRank[Command::RFMAB][dimmRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dpr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFSB][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCsb_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::REFSB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCsb_dlr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMSB][logicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCsb_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RFMSB][physicalRank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCsb_dlr);
 
         if (last4ActivatesLogical[logicalRank.ID()].size() >= 4)
@@ -916,10 +916,10 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command, const tlm_generic
     else
         SC_REPORT_FATAL("CheckerDDR5", "Unknown command!");
 
-    if (lastCommandOnBus != sc_max_time())
+    if (lastCommandOnBus != scMaxTime)
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
 
-    if (dummyCommandOnBus.start != sc_max_time())
+    if (dummyCommandOnBus.start != scMaxTime)
     {
         TimeInterval currentCommandOnBus(earliestTimeToStart,
                                          earliestTimeToStart + memSpec->getCommandLength(command));

extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.h

@@ -79,8 +79,8 @@ private:
 
     // 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;
     sc_core::sc_time tWTRA;

extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.cpp

@@ -48,14 +48,14 @@ CheckerHBM3::CheckerHBM3(const Configuration &config)
         SC_REPORT_FATAL("CheckerHBM3", "Wrong MemSpec chosen");
 
     lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>(
-        Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, sc_max_time()));
+        Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<std::vector<sc_time>>(
-        Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, sc_max_time()));
+        Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>(
-        Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, sc_max_time()));
-    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), sc_max_time());
-    lastCommandOnRasBus = sc_max_time();
-    lastCommandOnCasBus = sc_max_time();
+        Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
+    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
+    lastCommandOnRasBus = scMaxTime;
+    lastCommandOnCasBus = scMaxTime;
     last4Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
 
     bankwiseRefreshCounter = std::vector<unsigned>(memSpec->ranksPerChannel);
@@ -81,27 +81,27 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK / 2);
@@ -109,51 +109,51 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::RD)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
@@ -161,51 +161,51 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::WR)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
@@ -213,52 +213,52 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::RDA)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL + 2 * memSpec->tCK +
                                                                     std::max(memSpec->tWR - memSpec->tRTP, memSpec->tWTRL));
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
@@ -266,51 +266,51 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::WRA)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
@@ -318,77 +318,77 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::REFPB][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RFMPB][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS - memSpec->tCK);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -399,47 +399,47 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -447,39 +447,39 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK / 2);
@@ -487,79 +487,79 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::REFPB][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RFMPB][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (bankwiseRefreshCounter[rank.ID()] == 0)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
@@ -575,40 +575,40 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart, lastCommandStart + std::max(memSpec->tRTP + memSpec->tRP, tRDSRE));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -616,23 +616,23 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::RFMAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -640,47 +640,47 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::RFMAB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::REFPB][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RFMPB][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -688,23 +688,23 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -712,23 +712,23 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PDEP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -736,7 +736,7 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -744,7 +744,7 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -752,7 +752,7 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);

extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.h

@@ -68,6 +68,7 @@ private:
     std::vector<std::queue<sc_core::sc_time>> last4Activates;
     std::vector<unsigned> 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;

extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.cpp

@@ -49,13 +49,13 @@ CheckerLPDDR5::CheckerLPDDR5(const Configuration& config)
     else
     {
         lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>
-                (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, sc_max_time()));
+                (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
         lastScheduledByCommandAndBankGroup = std::vector<std::vector<sc_time>>
-                (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, sc_max_time()));
+                (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
         lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>
-                (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, sc_max_time()));
-        lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), sc_max_time());
-        lastCommandOnBus = sc_max_time();
+                (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
+        lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
+        lastCommandOnBus = scMaxTime;
 
         last4Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
 
@@ -90,11 +90,11 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         assert(burstLength <= memSpec->maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD_L + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::RD][bankGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_32);
@@ -103,7 +103,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::RD][rank.ID()] == 32)
             {
@@ -118,8 +118,8 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ?
-                lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+                lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommand[Command::RD] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
@@ -130,7 +130,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::RDA][bankGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_32);
@@ -139,7 +139,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::RDA][rank.ID()] == 32)
             {
@@ -154,8 +154,8 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ?
-                lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+                lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
         {
             // TODO: BG mode with BL32
             if (lastBurstLengthByCommand[Command::RDA] == 32)
@@ -167,7 +167,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
@@ -178,7 +178,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::WR][rank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
@@ -189,8 +189,8 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ?
-                lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+                lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
         {
             // TODO: BG mode with BL32
             if (lastBurstLengthByCommand[Command::WR] == 32)
@@ -202,7 +202,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
@@ -213,7 +213,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::WRA][rank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
@@ -224,8 +224,8 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ?
-                lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+                lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
         {
             // TODO: BG mode with BL32
             if (lastBurstLengthByCommand[Command::WRA] == 32)
@@ -244,11 +244,11 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         assert(burstLength <= memSpec->maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD_S + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::RD][bankGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRL
@@ -259,7 +259,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::RD][rank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRL
@@ -270,8 +270,8 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ?
-                lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+                lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
         {
             // TODO: BG mode with BL32
             if (lastBurstLengthByCommand[Command::RD] == 32)
@@ -283,7 +283,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::RDA][bankGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRL
@@ -294,7 +294,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::RDA][rank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRL
@@ -305,8 +305,8 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ?
-                lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+                lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
         {
             // TODO: BG mode with BL32
             if (lastBurstLengthByCommand[Command::RDA] == 32)
@@ -318,7 +318,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_32);
@@ -327,7 +327,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::WR][rank.ID()] == 32)
             {
@@ -342,8 +342,8 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ?
-                lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+                lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
         {
             // TODO: BG mode with BL32
             if (lastBurstLengthByCommand[Command::WR] == 32)
@@ -353,7 +353,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_32);
@@ -362,7 +362,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::WRA][rank.ID()] == 32)
             {
@@ -377,8 +377,8 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ?
-                lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+                lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommand[Command::WRA] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32 + memSpec->tCK);
@@ -389,15 +389,15 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::RDA][bank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
@@ -408,7 +408,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::RDA][bank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
@@ -419,31 +419,31 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tpbR2act - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFP2B][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tpbR2act - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFP2B][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb - memSpec->tCK);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -452,11 +452,11 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::RD][bank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
@@ -467,7 +467,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::WR][bank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
@@ -478,17 +478,17 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::RD][rank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
@@ -499,7 +499,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::RDA][rank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
@@ -510,7 +510,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::WR][rank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
@@ -521,7 +521,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::WRA][rank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
@@ -532,17 +532,17 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::RDA][rank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
@@ -553,7 +553,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::WRA][rank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
@@ -564,29 +564,29 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
     }
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::RDA][bank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
@@ -597,7 +597,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::WRA][bank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
@@ -608,19 +608,19 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tpbR2pbR);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -631,19 +631,19 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         Bank secondBank = Bank(bank.ID() + memSpec->getPer2BankOffset());
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][secondBank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::RDA][bank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
@@ -654,7 +654,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][secondBank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::RDA][secondBank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32
@@ -665,7 +665,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::WRA][bank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
@@ -676,7 +676,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][secondBank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::WRA][secondBank.ID()] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tWL
@@ -687,23 +687,23 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][secondBank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFP2B][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFP2B][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tpbR2pbR);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -713,7 +713,7 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command, const tlm_gener
         SC_REPORT_FATAL("CheckerLPDDR5", "Unknown command!");
 
     // Check if command bus is free
-    if (lastCommandOnBus != sc_max_time())
+    if (lastCommandOnBus != scMaxTime)
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
 
     return earliestTimeToStart;

extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.h

@@ -66,6 +66,7 @@ private:
     std::vector<std::vector<uint8_t>> lastBurstLengthByCommandAndBank;
     std::vector<uint8_t> 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;

src/libdramsys/DRAMSys/controller/BankMachine.cpp

@@ -41,18 +41,18 @@
 using namespace sc_core;
 using namespace tlm;
 
-BankMachine::BankMachine(const Configuration& config, const SchedulerIF& scheduler, const CheckerIF& checker, Bank bank)
-    : scheduler(scheduler), checker(checker), memSpec(*config.memSpec), bank(bank),
+BankMachine::BankMachine(const Configuration& config, const SchedulerIF& scheduler, Bank bank)
+    : scheduler(scheduler), memSpec(*config.memSpec), bank(bank),
     bankgroup(BankGroup(bank.ID() / memSpec.banksPerGroup)), rank(Rank(bank.ID() / memSpec.banksPerRank)),
     refreshManagement(config.refreshManagement)
 {}
 
 CommandTuple::Type BankMachine::getNextCommand()
 {
-    return {nextCommand, currentPayload, std::max(timeToSchedule, sc_time_stamp())};
+    return {nextCommand, currentPayload, SC_ZERO_TIME};
 }
 
-void BankMachine::updateState(Command command)
+void BankMachine::update(Command command)
 {
     switch (command)
     {
@@ -121,7 +121,6 @@ uint64_t BankMachine::getRefreshManagementCounter() const
 void BankMachine::block()
 {
     blocked = true;
-    timeToSchedule = sc_max_time();
     nextCommand = Command::NOP;
 }
 
@@ -160,13 +159,11 @@ bool BankMachine::isPrecharged() const
     return state == State::Precharged;
 }
 
-BankMachineOpen::BankMachineOpen(const Configuration& config, const SchedulerIF& scheduler, const CheckerIF& checker,
-                                 Bank bank)
-    : BankMachine(config, scheduler, checker, bank) {}
+BankMachineOpen::BankMachineOpen(const Configuration& config, const SchedulerIF& scheduler, Bank bank)
+    : BankMachine(config, scheduler, bank) {}
 
-sc_time BankMachineOpen::start()
+void BankMachineOpen::evaluate()
 {
-    timeToSchedule = sc_max_time();
     nextCommand = Command::NOP;
 
     if (!(sleeping || blocked))
@@ -174,7 +171,7 @@ sc_time BankMachineOpen::start()
         tlm_generic_payload* newPayload = scheduler.getNextRequest(*this);
         if (newPayload == nullptr)
         {
-            return timeToSchedule;
+            return;
         }
         else
         {
@@ -204,21 +201,15 @@ sc_time BankMachineOpen::start()
                 else // row miss
                     nextCommand = Command::PREPB;
             }
-            timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, *currentPayload);
-            return timeToSchedule;
         }
     }
-    else
-        return timeToSchedule;
 }
 
-BankMachineClosed::BankMachineClosed(const Configuration& config, const SchedulerIF& scheduler,
-                                     const CheckerIF& checker, Bank bank)
-    : BankMachine(config, scheduler, checker, bank) {}
+BankMachineClosed::BankMachineClosed(const Configuration& config, const SchedulerIF& scheduler, Bank bank)
+    : BankMachine(config, scheduler, bank) {}
 
-sc_time BankMachineClosed::start()
+void BankMachineClosed::evaluate()
 {
-    timeToSchedule = sc_max_time();
     nextCommand = Command::NOP;
 
     if (!(sleeping || blocked))
@@ -226,7 +217,7 @@ sc_time BankMachineClosed::start()
         tlm_generic_payload* newPayload = scheduler.getNextRequest(*this);
         if (newPayload == nullptr)
         {
-            return timeToSchedule;
+            return;
         }
         else
         {
@@ -251,21 +242,15 @@ sc_time BankMachineClosed::start()
                 else
                     nextCommand = Command::WRA;
             }
-            timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, *currentPayload);
-            return timeToSchedule;
         }
     }
-    else
-        return timeToSchedule;
 }
 
-BankMachineOpenAdaptive::BankMachineOpenAdaptive(const Configuration& config, const SchedulerIF& scheduler,
-                                                 const CheckerIF& checker, Bank bank)
-    : BankMachine(config, scheduler, checker, bank) {}
+BankMachineOpenAdaptive::BankMachineOpenAdaptive(const Configuration& config, const SchedulerIF& scheduler, Bank bank)
+    : BankMachine(config, scheduler, bank) {}
 
-sc_time BankMachineOpenAdaptive::start()
+void BankMachineOpenAdaptive::evaluate()
 {
-    timeToSchedule = sc_max_time();
     nextCommand = Command::NOP;
 
     if (!(sleeping || blocked))
@@ -273,7 +258,7 @@ sc_time BankMachineOpenAdaptive::start()
         tlm_generic_payload* newPayload = scheduler.getNextRequest(*this);
         if (newPayload == nullptr)
         {
-            return timeToSchedule;
+            return;
         }
         else
         {
@@ -315,21 +300,16 @@ sc_time BankMachineOpenAdaptive::start()
                 else // row miss
                     nextCommand = Command::PREPB;
             }
-            timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, *currentPayload);
-            return timeToSchedule;
         }
     }
-    else
-        return timeToSchedule;
 }
 
 BankMachineClosedAdaptive::BankMachineClosedAdaptive(const Configuration& config, const SchedulerIF& scheduler,
-                                                     const CheckerIF& checker, Bank bank)
-    : BankMachine(config, scheduler, checker, bank) {}
+                                                     Bank bank)
+    : BankMachine(config, scheduler, bank) {}
 
-sc_time BankMachineClosedAdaptive::start()
+void BankMachineClosedAdaptive::evaluate()
 {
-    timeToSchedule = sc_max_time();
     nextCommand = Command::NOP;
 
     if (!(sleeping || blocked))
@@ -337,7 +317,7 @@ sc_time BankMachineClosedAdaptive::start()
         tlm_generic_payload* newPayload = scheduler.getNextRequest(*this);
         if (newPayload == nullptr)
         {
-            return timeToSchedule;
+            return;
         }
         else
         {
@@ -378,10 +358,6 @@ sc_time BankMachineClosedAdaptive::start()
                 else // row miss, can happen when RD/WR mode is switched
                     nextCommand = Command::PREPB;
             }
-            timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, *currentPayload);
-            return timeToSchedule;
         }
     }
-    else
-        return timeToSchedule;
 }

src/libdramsys/DRAMSys/controller/BankMachine.h

@@ -35,6 +35,7 @@
 #ifndef BANKMACHINE_H
 #define BANKMACHINE_H
 
+#include "DRAMSys/controller/ManagerIF.h"
 #include "DRAMSys/controller/scheduler/SchedulerIF.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 #include "DRAMSys/controller/Command.h"
@@ -45,13 +46,11 @@
 #include <systemc>
 #include <tlm>
 
-class BankMachine
+class BankMachine : public ManagerIF
 {
 public:
-    virtual ~BankMachine() = default;
-    virtual sc_core::sc_time start() = 0;
-    CommandTuple::Type getNextCommand();
-    void updateState(Command);
+    CommandTuple::Type getNextCommand() override;
+    void update(Command) override;
     void block();
 
     [[nodiscard]] Rank getRank() const;
@@ -65,14 +64,12 @@ public:
 
 protected:
     enum class State {Precharged, Activated} state = State::Precharged;
-    BankMachine(const Configuration& config, const SchedulerIF& scheduler, const CheckerIF& checker, Bank bank);
+    BankMachine(const Configuration& config, const SchedulerIF& scheduler, Bank bank);
     const MemSpec& memSpec;
     tlm::tlm_generic_payload* currentPayload = nullptr;
     const SchedulerIF& scheduler;
-    const CheckerIF& checker;
     Command nextCommand = Command::NOP;
     Row openRow;
-    sc_core::sc_time timeToSchedule = sc_core::sc_max_time();
     const Bank bank;
     const BankGroup bankgroup;
     const Rank rank;
@@ -86,31 +83,29 @@ protected:
 class BankMachineOpen final : public BankMachine
 {
 public:
-    BankMachineOpen(const Configuration& config, const SchedulerIF& scheduler, const CheckerIF& checker, Bank bank);
-    sc_core::sc_time start() override;
+    BankMachineOpen(const Configuration& config, const SchedulerIF& scheduler, Bank bank);
+    void evaluate() override;
 };
 
 class BankMachineClosed final : public BankMachine
 {
 public:
-    BankMachineClosed(const Configuration& config, const SchedulerIF& scheduler, const CheckerIF& checker, Bank bank);
-    sc_core::sc_time start() override;
+    BankMachineClosed(const Configuration& config, const SchedulerIF& scheduler, Bank bank);
+    void evaluate() override;
 };
 
 class BankMachineOpenAdaptive final : public BankMachine
 {
 public:
-    BankMachineOpenAdaptive(const Configuration& config, const SchedulerIF& scheduler, const CheckerIF& checker,
-                            Bank bank);
-    sc_core::sc_time start() override;
+    BankMachineOpenAdaptive(const Configuration& config, const SchedulerIF& scheduler, Bank bank);
+    void evaluate() override;
 };
 
 class BankMachineClosedAdaptive final : public BankMachine
 {
 public:
-    BankMachineClosedAdaptive(const Configuration& config, const SchedulerIF& scheduler, const CheckerIF& checker,
-                              Bank bank);
-    sc_core::sc_time start() override;
+    BankMachineClosedAdaptive(const Configuration& config, const SchedulerIF& scheduler, Bank bank);
+    void evaluate() override;
 };
 
 #endif // BANKMACHINE_H

src/libdramsys/DRAMSys/controller/Controller.cpp

@@ -164,25 +164,25 @@ Controller::Controller(const sc_module_name& name, const Configuration& config,
     {
         for (unsigned bankID = 0; bankID < memSpec.banksPerChannel; bankID++)
             bankMachines.emplace_back(std::make_unique<BankMachineOpen>
-                    (config, *scheduler, *checker, Bank(bankID)));
+                    (config, *scheduler, Bank(bankID)));
     }
     else if (config.pagePolicy == Configuration::PagePolicy::OpenAdaptive)
     {
         for (unsigned bankID = 0; bankID < memSpec.banksPerChannel; bankID++)
             bankMachines.emplace_back(std::make_unique<BankMachineOpenAdaptive>
-                    (config, *scheduler, *checker, Bank(bankID)));
+                    (config, *scheduler, Bank(bankID)));
     }
     else if (config.pagePolicy == Configuration::PagePolicy::Closed)
     {
         for (unsigned bankID = 0; bankID < memSpec.banksPerChannel; bankID++)
             bankMachines.emplace_back(std::make_unique<BankMachineClosed>
-                    (config, *scheduler, *checker, Bank(bankID)));
+                    (config, *scheduler, Bank(bankID)));
     }
     else if (config.pagePolicy == Configuration::PagePolicy::ClosedAdaptive)
     {
         for (unsigned bankID = 0; bankID < memSpec.banksPerChannel; bankID++)
             bankMachines.emplace_back(std::make_unique<BankMachineClosedAdaptive>
-                    (config, *scheduler, *checker, Bank(bankID)));
+                    (config, *scheduler, Bank(bankID)));
     }
 
     bankMachinesOnRank = std::vector<std::vector<BankMachine*>>(memSpec.ranksPerChannel,
@@ -219,7 +219,7 @@ Controller::Controller(const sc_module_name& name, const Configuration& config,
         for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
         {
             refreshManagers.emplace_back(std::make_unique<RefreshManagerAllBank>
-                    (config, bankMachinesOnRank[rankID], *powerDownManagers[rankID].get(), Rank(rankID), *checker));
+                    (config, bankMachinesOnRank[rankID], *powerDownManagers[rankID].get(), Rank(rankID)));
         }
     }
     else if (config.refreshPolicy == Configuration::RefreshPolicy::SameBank)
@@ -227,7 +227,7 @@ Controller::Controller(const sc_module_name& name, const Configuration& config,
         for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
         {
             refreshManagers.emplace_back(std::make_unique<RefreshManagerSameBank>
-                    (config, bankMachinesOnRank[rankID], *powerDownManagers[rankID].get(), Rank(rankID), *checker));
+                    (config, bankMachinesOnRank[rankID], *powerDownManagers[rankID].get(), Rank(rankID)));
         }
     }
     else if (config.refreshPolicy == Configuration::RefreshPolicy::PerBank)
@@ -236,7 +236,7 @@ Controller::Controller(const sc_module_name& name, const Configuration& config,
         {
             // TODO: remove bankMachines in constructor
             refreshManagers.emplace_back(std::make_unique<RefreshManagerPerBank>
-                    (config, bankMachinesOnRank[rankID], *powerDownManagers[rankID], Rank(rankID), *checker));
+                    (config, bankMachinesOnRank[rankID], *powerDownManagers[rankID], Rank(rankID)));
         }
     }
     else if (config.refreshPolicy == Configuration::RefreshPolicy::Per2Bank)
@@ -245,7 +245,7 @@ Controller::Controller(const sc_module_name& name, const Configuration& config,
         {
             // TODO: remove bankMachines in constructor
             refreshManagers.emplace_back(std::make_unique<RefreshManagerPer2Bank>
-                    (config, bankMachinesOnRank[rankID], *powerDownManagers[rankID], Rank(rankID), *checker));
+                    (config, bankMachinesOnRank[rankID], *powerDownManagers[rankID], Rank(rankID)));
         }
     }
     else
@@ -265,9 +265,9 @@ void Controller::controllerMethod()
 
     // (3) Start refresh and power-down managers to issue requests for the current time
     for (auto& it : refreshManagers)
-        it->start();
+        it->evaluate();
     for (auto& it : powerDownManagers)
-        it->start();
+        it->evaluate();
 
     // (4) Collect all ready commands from BMs, RMs and PDMs
     CommandTuple::Type commandTuple;
@@ -301,6 +301,12 @@ void Controller::controllerMethod()
     bool readyCmdBlocked = false;
     if (!readyCommands.empty())
     {
+        for (auto& it : readyCommands)
+        {
+            Command command = std::get<CommandTuple::Command>(it);
+            tlm_generic_payload* trans = std::get<CommandTuple::Payload>(it);
+            std::get<CommandTuple::Timestamp>(it) = checker->timeToSatisfyConstraints(command, *trans);
+        }
         commandTuple = cmdMux->selectCommand(readyCommands);
         Command command = std::get<CommandTuple::Command>(commandTuple);
         tlm_generic_payload* trans = std::get<CommandTuple::Payload>(commandTuple);
@@ -312,24 +318,24 @@ void Controller::controllerMethod()
             if (command.isRankCommand())
             {
                 for (auto it : bankMachinesOnRank[rank.ID()])
-                    it->updateState(command);
+                    it->update(command);
             }
             else if (command.isGroupCommand())
             {
                 for (unsigned bankID = (bank.ID() % memSpec.banksPerGroup);
                         bankID < memSpec.banksPerRank; bankID += memSpec.banksPerGroup)
-                    bankMachinesOnRank[rank.ID()][bankID]->updateState(command);
+                    bankMachinesOnRank[rank.ID()][bankID]->update(command);
             }
             else if (command.is2BankCommand())
             {
-                bankMachines[bank.ID()]->updateState(command);
-                bankMachines[bank.ID() + memSpec.getPer2BankOffset()]->updateState(command);
+                bankMachines[bank.ID()]->update(command);
+                bankMachines[bank.ID() + memSpec.getPer2BankOffset()]->update(command);
             }
             else // if (isBankCommand(command))
-                bankMachines[bank.ID()]->updateState(command);
+                bankMachines[bank.ID()]->update(command);
 
-            refreshManagers[rank.ID()]->updateState(command);
-            powerDownManagers[rank.ID()]->updateState(command);
+            refreshManagers[rank.ID()]->update(command);
+            powerDownManagers[rank.ID()]->update(command);
             checker->insert(command, *trans);
 
             if (command.isCasCommand())
@@ -342,7 +348,7 @@ void Controller::controllerMethod()
                                                 + phyDelayBw + thinkDelayBw);
 
                 sc_time triggerTime = respQueue->getTriggerTime();
-                if (triggerTime != sc_max_time())
+                if (triggerTime != scMaxTime)
                     dataResponseEvent.notify(triggerTime - sc_time_stamp());
 
                 ranksNumberOfPayloads[rank.ID()]--; // TODO: move to a different place?
@@ -359,28 +365,53 @@ void Controller::controllerMethod()
     }
 
     // (6) Restart bank machines, refresh managers and power-down managers to issue new requests for the future
-    sc_time timeForNextTrigger = sc_max_time();
+    sc_time timeForNextTrigger = scMaxTime;
     sc_time localTime;
     for (auto& it : bankMachines)
     {
-        localTime = it->start();
-        if (!(localTime == sc_time_stamp() && readyCmdBlocked))
-            timeForNextTrigger = std::min(timeForNextTrigger, localTime);
+        it->evaluate();
+        commandTuple = it->getNextCommand();
+        Command command = std::get<CommandTuple::Command>(commandTuple);
+        tlm_generic_payload* trans = std::get<CommandTuple::Payload>(commandTuple);
+        if (command != Command::NOP)
+        {
+            localTime = checker->timeToSatisfyConstraints(command, *trans);
+            if (!(localTime == sc_time_stamp() && readyCmdBlocked))
+                timeForNextTrigger = std::min(timeForNextTrigger, localTime);
+        }
     }
     for (auto& it : refreshManagers)
     {
-        localTime = it->start();
-        if (!(localTime == sc_time_stamp() && readyCmdBlocked))
-            timeForNextTrigger = std::min(timeForNextTrigger, localTime);
+        it->evaluate();
+        commandTuple = it->getNextCommand();
+        Command command = std::get<CommandTuple::Command>(commandTuple);
+        tlm_generic_payload* trans = std::get<CommandTuple::Payload>(commandTuple);
+        if (command != Command::NOP)
+        {
+            localTime = checker->timeToSatisfyConstraints(command, *trans);
+            if (!(localTime == sc_time_stamp() && readyCmdBlocked))
+                timeForNextTrigger = std::min(timeForNextTrigger, localTime);
+        }
+        else
+        {
+            timeForNextTrigger = std::min(timeForNextTrigger, it->getTimeForNextTrigger());
+        }
     }
     for (auto& it : powerDownManagers)
     {
-        localTime = it->start();
-        if (!(localTime == sc_time_stamp() && readyCmdBlocked))
-            timeForNextTrigger = std::min(timeForNextTrigger, localTime);
+        it->evaluate();
+        commandTuple = it->getNextCommand();
+        Command command = std::get<CommandTuple::Command>(commandTuple);
+        tlm_generic_payload* trans = std::get<CommandTuple::Payload>(commandTuple);
+        if (command != Command::NOP)
+        {
+            localTime = checker->timeToSatisfyConstraints(command, *trans);
+            if (!(localTime == sc_time_stamp() && readyCmdBlocked))
+                timeForNextTrigger = std::min(timeForNextTrigger, localTime);
+        }
     }
 
-    if (timeForNextTrigger != sc_max_time())
+    if (timeForNextTrigger != scMaxTime)
         controllerEvent.notify(timeForNextTrigger - sc_time_stamp());
 }
 
@@ -459,7 +490,7 @@ void Controller::manageRequests(const sc_time& delay)
 
                 scheduler->storeRequest(*transToAcquire.payload);
                 Bank bank = Bank(decodedAddress.bank);
-                bankMachines[bank.ID()]->start();
+                bankMachines[bank.ID()]->evaluate();
             }
             else
             {
@@ -475,7 +506,7 @@ void Controller::manageRequests(const sc_time& delay)
 
                     scheduler->storeRequest(*childTrans);
                     Bank bank = ControllerExtension::getBank(*childTrans);
-                    bankMachines[bank.ID()]->start();
+                    bankMachines[bank.ID()]->evaluate();
                 }
             }
 
@@ -533,12 +564,12 @@ void Controller::manageResponses()
                     bwDelay = SC_ZERO_TIME;
 
                 sendToFrontend(*transToRelease.payload, bwPhase, bwDelay);
-                transToRelease.arrival = sc_max_time();
+                transToRelease.arrival = scMaxTime;
             }
             else
             {
                 sc_time triggerTime = respQueue->getTriggerTime();
-                if (triggerTime != sc_max_time())
+                if (triggerTime != scMaxTime)
                     dataResponseEvent.notify(triggerTime - sc_time_stamp());
             }
         }
@@ -553,13 +584,13 @@ void Controller::manageResponses()
                 bwDelay = SC_ZERO_TIME;
 
             sendToFrontend(*transToRelease.payload, bwPhase, bwDelay);
-            transToRelease.arrival = sc_max_time();
+            transToRelease.arrival = scMaxTime;
         }
     }
     else
     {
         sc_time triggerTime = respQueue->getTriggerTime();
-        if (triggerTime != sc_max_time())
+        if (triggerTime != scMaxTime)
             dataResponseEvent.notify(triggerTime - sc_time_stamp());
     }
 }

src/libdramsys/DRAMSys/controller/Controller.h

@@ -70,6 +70,7 @@ protected:
 
     std::unique_ptr<SchedulerIF> scheduler;
 
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
     const sc_core::sc_time thinkDelayFw;
     const sc_core::sc_time thinkDelayBw;
     const sc_core::sc_time phyDelayFw;

src/libdramsys/DRAMSys/controller/ManagerIF.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2023, RPTU Kaiserslautern-Landau
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * 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
+ */
+
+#ifndef MANAGERIF_H
+#define MANAGERIF_H
+
+#include "DRAMSys/controller/Command.h"
+
+class ManagerIF
+{
+public:
+    virtual void evaluate() = 0;
+    virtual CommandTuple::Type getNextCommand() = 0;
+    virtual void update(Command) = 0;
+    virtual ~ManagerIF() = default;
+};
+
+#endif // MANAGERIF_H

src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.cpp

@@ -48,11 +48,11 @@ CheckerDDR3::CheckerDDR3(const Configuration& config)
         SC_REPORT_FATAL("CheckerDDR3", "Wrong MemSpec chosen");
 
     lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, sc_max_time()));
-    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), sc_max_time());
-    lastCommandOnBus = sc_max_time();
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
+    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
+    lastCommandOnBus = scMaxTime;
     last4Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
 
     tBURST = memSpec->defaultBurstLength / memSpec->dataRate * memSpec->tCK;
@@ -79,54 +79,54 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command, const tlm_generic
         assert(ControllerExtension::getBurstLength(payload) == 8);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD - memSpec->tAL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP - memSpec->tAL);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD);
 
         lastCommandStart = lastScheduledByCommand[Command::WR];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD);
 
         lastCommandStart = lastScheduledByCommand[Command::WRA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSDLL);
     }
     else if (command == Command::WR || command == Command::WRA)
@@ -134,89 +134,89 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command, const tlm_generic
         assert(ControllerExtension::getBurstLength(payload) == 8);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD - memSpec->tAL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSDLL);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -225,201 +225,201 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tACTPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
     }
     else if (command == Command::PDEP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(tRDPDEN, memSpec->tAL + memSpec->tRTP + memSpec->tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec->tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
     }
     else
         SC_REPORT_FATAL("CheckerDDR3", "Unknown command!");
 
-    if (lastCommandOnBus != sc_max_time())
+    if (lastCommandOnBus != scMaxTime)
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
 
     return earliestTimeToStart;

src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.h

@@ -60,6 +60,7 @@ private:
     // Four activate window
     std::vector<std::queue<sc_core::sc_time>> 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;

src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.cpp

@@ -46,17 +46,17 @@ CheckerDDR4::CheckerDDR4(const Configuration& config)
     memSpec = dynamic_cast<const MemSpecDDR4 *>(config.memSpec.get());
     if (memSpec == nullptr)
         SC_REPORT_FATAL("CheckerDDR4", "Wrong MemSpec chosen");
-
+    
     lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, sc_max_time()));
-    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), sc_max_time());
-    lastCommandOnBus = sc_max_time();
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
+    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
+    lastCommandOnBus = scMaxTime;
     last4Activates = std::vector<std::queue<sc_time>>(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;
@@ -83,70 +83,70 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command, const tlm_generic
         assert(ControllerExtension::getBurstLength(payload) == 8);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD - memSpec->tAL);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP - memSpec->tAL);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_S);
 
         lastCommandStart = lastScheduledByCommand[Command::WR];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_S);
 
         lastCommandStart = lastScheduledByCommand[Command::WRA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSDLL);
     }
     else if (command == Command::WR || command == Command::WRA)
@@ -154,101 +154,101 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command, const tlm_generic
         assert(ControllerExtension::getBurstLength(payload) == 8);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD - memSpec->tAL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSDLL);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD_S);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -257,201 +257,201 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tACTPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
     }
     else if (command == Command::PDEP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(tRDPDEN, memSpec->tAL + memSpec->tRTP + memSpec->tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec->tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
     }
     else
         SC_REPORT_FATAL("CheckerDDR4", "Unknown command!");
 
-    if (lastCommandOnBus != sc_max_time())
+    if (lastCommandOnBus != scMaxTime)
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
 
     return earliestTimeToStart;

src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.h

@@ -41,6 +41,8 @@
 
 #include <queue>
 #include <vector>
+#include <unordered_map>
+#include <utility>
 
 class CheckerDDR4 final : public CheckerIF
 {
@@ -61,6 +63,7 @@ private:
     // Four activate window
     std::vector<std::queue<sc_core::sc_time>> 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;

src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5.cpp

@@ -48,13 +48,13 @@ CheckerGDDR5::CheckerGDDR5(const Configuration& config)
         SC_REPORT_FATAL("CheckerGDDR5", "Wrong MemSpec chosen");
 
     lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, sc_max_time()));
-    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), sc_max_time());
-    lastCommandOnBus = sc_max_time();
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
+    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
+    lastCommandOnBus = scMaxTime;
     last4Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
     last32Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
 
@@ -84,70 +84,70 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command, const tlm_generi
         assert(ControllerExtension::getBurstLength(payload) == 8);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_S);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_S);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tLK);
     }
     else if (command == Command::WR || command == Command::WRA)
@@ -155,109 +155,109 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command, const tlm_generi
         assert(ControllerExtension::getBurstLength(payload) == 8);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tLK);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -269,145 +269,145 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command, const tlm_generi
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (bankwiseRefreshCounter[rank.ID()] == 0)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
@@ -416,7 +416,7 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command, const tlm_generi
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -428,112 +428,112 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command, const tlm_generi
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
     }
     else if (command == Command::PDEP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(memSpec->tRTP + memSpec->tRP, tRDSRE));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else
         SC_REPORT_FATAL("CheckerGDDR5", "Unknown command!");
 
     // Check if command bus is free
-    if (lastCommandOnBus != sc_max_time())
+    if (lastCommandOnBus != scMaxTime)
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
 
     return earliestTimeToStart;

src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5.h

@@ -65,6 +65,7 @@ private:
 
     std::vector<unsigned> bankwiseRefreshCounter;
 
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
     sc_core::sc_time tBURST;
     sc_core::sc_time tRDSRE;
     sc_core::sc_time tWRSRE;

src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5X.cpp

@@ -48,13 +48,13 @@ CheckerGDDR5X::CheckerGDDR5X(const Configuration& config)
         SC_REPORT_FATAL("CheckerGDDR5X", "Wrong MemSpec chosen");
 
     lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, sc_max_time()));
-    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), sc_max_time());
-    lastCommandOnBus = sc_max_time();
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
+    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
+    lastCommandOnBus = scMaxTime;
     last4Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
     last32Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
 
@@ -86,70 +86,70 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command, const tlm_gener
         assert(!(memSpec->dataRate == 8) || (burstLength == 16)); // QDR mode (ODR wrt CK)
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_S);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_S);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tLK);
     }
     else if (command == Command::WR || command == Command::WRA)
@@ -159,109 +159,109 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command, const tlm_gener
         assert(!(memSpec->dataRate == 8) || (burstLength == 16)); // QDR mode (ODR wrt CK)
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tLK);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -273,145 +273,145 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command, const tlm_gener
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (bankwiseRefreshCounter[rank.ID()] == 0)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
@@ -420,7 +420,7 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command, const tlm_gener
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -432,112 +432,112 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command, const tlm_gener
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
     }
     else if (command == Command::PDEP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(memSpec->tRTP + memSpec->tRP, tRDSRE));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else
         SC_REPORT_FATAL("CheckerGDDR5X", "Unknown command!");
 
     // Check if command bus is free
-    if (lastCommandOnBus != sc_max_time())
+    if (lastCommandOnBus != scMaxTime)
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
 
     return earliestTimeToStart;

src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5X.h

@@ -65,6 +65,7 @@ private:
 
     std::vector<unsigned> bankwiseRefreshCounter;
 
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
     sc_core::sc_time tBURST;
     sc_core::sc_time tRDSRE;
     sc_core::sc_time tWRSRE;

src/libdramsys/DRAMSys/controller/checker/CheckerGDDR6.cpp

@@ -48,13 +48,13 @@ CheckerGDDR6::CheckerGDDR6(const Configuration& config)
         SC_REPORT_FATAL("CheckerGDDR6", "Wrong MemSpec chosen");
 
     lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, sc_max_time()));
-    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), sc_max_time());
-    lastCommandOnBus = sc_max_time();
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
+    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
+    lastCommandOnBus = scMaxTime;
     last4Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
 
     bankwiseRefreshCounter = std::vector<unsigned>(memSpec->ranksPerChannel);
@@ -83,70 +83,70 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command, const tlm_generi
         assert(ControllerExtension::getBurstLength(payload) == 16);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_S);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_S);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tLK);
     }
     else if (command == Command::WR || command == Command::WRA)
@@ -154,109 +154,109 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command, const tlm_generi
         assert(ControllerExtension::getBurstLength(payload) == 16);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tLK);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -265,145 +265,145 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command, const tlm_generi
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (bankwiseRefreshCounter[rank.ID()] == 0)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
@@ -412,7 +412,7 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command, const tlm_generi
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -421,140 +421,140 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command, const tlm_generi
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tACTPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPREPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
     }
     else if (command == Command::PDEP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPREPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPREPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDSRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(memSpec->tRTP + memSpec->tRP, tRDSRE));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
     }
     else
         SC_REPORT_FATAL("CheckerGDDR6", "Unknown command!");
 
     // Check if command bus is free
-    if (lastCommandOnBus != sc_max_time())
+    if (lastCommandOnBus != scMaxTime)
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
 
     return earliestTimeToStart;

src/libdramsys/DRAMSys/controller/checker/CheckerGDDR6.h

@@ -63,6 +63,7 @@ private:
 
     std::vector<unsigned> bankwiseRefreshCounter;
 
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
     sc_core::sc_time tBURST;
     sc_core::sc_time tRDSRE;
     sc_core::sc_time tWRSRE;

src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.cpp

@@ -48,14 +48,14 @@ CheckerHBM2::CheckerHBM2(const Configuration& config)
         SC_REPORT_FATAL("CheckerHBM2", "Wrong MemSpec chosen");
 
     lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, sc_max_time()));
-    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), sc_max_time());
-    lastCommandOnRasBus = sc_max_time();
-    lastCommandOnCasBus = sc_max_time();
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
+    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
+    lastCommandOnRasBus = scMaxTime;
+    lastCommandOnCasBus = scMaxTime;
     last4Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
 
     bankwiseRefreshCounter = std::vector<unsigned>(memSpec->ranksPerChannel);
@@ -86,50 +86,50 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
         assert(!(memSpec->ranksPerChannel == 2) || (burstLength == 4)); // Pseudo-channel mode
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRDS);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
@@ -141,35 +141,35 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
         assert(!(memSpec->ranksPerChannel == 2) || (burstLength == 4)); // Pseudo-channel mode
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
@@ -177,55 +177,55 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXP];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS - memSpec->tCK);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -236,19 +236,19 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -256,31 +256,31 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -288,39 +288,39 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXP];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB);
 
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -328,51 +328,51 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXP];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
         {
             if (bankwiseRefreshCounter[rank.ID()] == 0)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB);
@@ -381,7 +381,7 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
         }
 
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -392,23 +392,23 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommand[Command::RD];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE);
 
         lastCommandStart = lastScheduledByCommand[Command::WR];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDE);
 
         lastCommandStart = lastScheduledByCommand[Command::WRA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDE);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -416,7 +416,7 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommand[Command::PDEA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -424,23 +424,23 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PDEP)
     {
         lastCommandStart = lastScheduledByCommand[Command::RD];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDE);
 
         lastCommandStart = lastScheduledByCommand[Command::WRA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDE);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXP];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
 
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -448,7 +448,7 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommand[Command::PDEP];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -456,39 +456,39 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommand[Command::ACT];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(memSpec->tRTP + memSpec->tRP, tRDSRE));
 
         lastCommandStart = lastScheduledByCommand[Command::WRA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommand[Command::PREPB];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommand[Command::PREAB];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXP];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommand[Command::REFAB];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommand[Command::REFPB];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB);
 
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -496,7 +496,7 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommand[Command::SREFEN];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
 
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
@@ -506,12 +506,12 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, const tlm_generic
 
     if (command.isRasCommand())
     {
-        if (lastCommandOnRasBus != sc_max_time())
+        if (lastCommandOnRasBus != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
     }
     else
     {
-        if (lastCommandOnCasBus != sc_max_time())
+        if (lastCommandOnCasBus != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
     }
 

src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.h

@@ -64,6 +64,7 @@ private:
     std::vector<std::queue<sc_core::sc_time>> last4Activates;
     std::vector<unsigned> 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;

src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.cpp

@@ -48,11 +48,11 @@ CheckerLPDDR4::CheckerLPDDR4(const Configuration& config)
         SC_REPORT_FATAL("CheckerLPDDR4", "Wrong MemSpec chosen");
 
     lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, sc_max_time()));
-    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), sc_max_time());
-    lastCommandOnBus = sc_max_time();
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
+    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
+    lastCommandOnBus = scMaxTime;
     last4Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
 
     tBURST = memSpec->defaultBurstLength / memSpec->dataRate * memSpec->tCK;
@@ -87,50 +87,50 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, const tlm_gener
         assert(burstLength <= memSpec->maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE - tRDPRE);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::WR || command == Command::WRA)
@@ -140,93 +140,93 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, const tlm_gener
         assert(burstLength <= memSpec->maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDAACT);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAACT);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb - 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab - 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab - 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb - 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD - 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR - 2 * memSpec->tCK);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -235,141 +235,141 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, const tlm_gener
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
     }
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -378,136 +378,136 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, const tlm_gener
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tACTPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tREFPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else if (command == Command::PDEP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tREFPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tREFPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(tRDPDEN, tRDPRE + memSpec->tRPpb));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec->tRPpb));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        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 != sc_max_time())
+    if (lastCommandOnBus != scMaxTime)
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
 
     return earliestTimeToStart;

src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.h

@@ -60,6 +60,7 @@ private:
     // Four activate window
     std::vector<std::queue<sc_core::sc_time>> 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;

src/libdramsys/DRAMSys/controller/checker/CheckerSTTMRAM.cpp

@@ -48,11 +48,11 @@ CheckerSTTMRAM::CheckerSTTMRAM(const Configuration& config)
         SC_REPORT_FATAL("CheckerSTTMRAM", "Wrong MemSpec chosen");
 
     lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, sc_max_time()));
-    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), sc_max_time());
-    lastCommandOnBus = sc_max_time();
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
+    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
+    lastCommandOnBus = scMaxTime;
     last4Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
 
     tBURST = memSpec->defaultBurstLength / memSpec->dataRate * memSpec->tCK;
@@ -79,56 +79,56 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command, const tlm_gene
         assert(ControllerExtension::getBurstLength(payload) == 8);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD - memSpec->tAL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
 
         lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ?
-                lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+                lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ?
-                lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+                lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP - memSpec->tAL);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD);
 
         lastCommandStart = lastScheduledByCommand[Command::WR];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD);
 
         lastCommandStart = lastScheduledByCommand[Command::WRA];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSDLL);
     }
     else if (command == Command::WR || command == Command::WRA)
@@ -136,85 +136,85 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command, const tlm_gene
         assert(ControllerExtension::getBurstLength(payload) == 8);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD - memSpec->tAL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSDLL);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -223,159 +223,159 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command, const tlm_gene
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tACTPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
     }
     else if (command == Command::PDEP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(tRDPDEN, memSpec->tAL + memSpec->tRTP + memSpec->tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec->tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
     }
     else
         SC_REPORT_FATAL("CheckerSTTMRAM", "Unknown command!");
 
-    if (lastCommandOnBus != sc_max_time())
+    if (lastCommandOnBus != scMaxTime)
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
 
     return earliestTimeToStart;

src/libdramsys/DRAMSys/controller/checker/CheckerSTTMRAM.h

@@ -60,6 +60,7 @@ private:
     // Four activate window
     std::vector<std::queue<sc_core::sc_time>> 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;

src/libdramsys/DRAMSys/controller/checker/CheckerWideIO.cpp

@@ -48,11 +48,11 @@ CheckerWideIO::CheckerWideIO(const Configuration& config)
         SC_REPORT_FATAL("CheckerWideIO", "Wrong MemSpec chosen");
 
     lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, sc_max_time()));
-    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), sc_max_time());
-    lastCommandOnBus = sc_max_time();
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
+    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
+    lastCommandOnBus = scMaxTime;
     last2Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
 
     tBURST = memSpec->defaultBurstLength * memSpec->tCK;
@@ -81,50 +81,50 @@ sc_time CheckerWideIO::timeToSatisfyConstraints(Command command, const tlm_gener
         assert(burstLength <= memSpec->maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE - tBURST);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::WR || command == Command::WRA)
@@ -134,85 +134,85 @@ sc_time CheckerWideIO::timeToSatisfyConstraints(Command command, const tlm_gener
         assert(burstLength <= memSpec->maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
 
         if (last2Activates[rank.ID()].size() >= 2)
@@ -221,182 +221,182 @@ sc_time CheckerWideIO::timeToSatisfyConstraints(Command command, const tlm_gener
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
     }
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else if (command == Command::PDEP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(tRDPDEN, tBURST + memSpec->tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec->tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
     }
     else
         SC_REPORT_FATAL("CheckerWideIO", "Unknown command!");
 
     // Check if command bus is free
-    if (lastCommandOnBus != sc_max_time())
+    if (lastCommandOnBus != scMaxTime)
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
 
     return earliestTimeToStart;

src/libdramsys/DRAMSys/controller/checker/CheckerWideIO.h

@@ -60,6 +60,7 @@ private:
     // Four activate window
     std::vector<std::queue<sc_core::sc_time>> last2Activates;
 
+    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;

src/libdramsys/DRAMSys/controller/checker/CheckerWideIO2.cpp

@@ -48,11 +48,11 @@ CheckerWideIO2::CheckerWideIO2(const Configuration& config)
         SC_REPORT_FATAL("CheckerWideIO2", "Wrong MemSpec chosen");
 
     lastScheduledByCommandAndBank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, sc_max_time()));
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->banksPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<std::vector<sc_time>>
-            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, sc_max_time()));
-    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), sc_max_time());
-    lastCommandOnBus = sc_max_time();
+            (Command::numberOfCommands(), std::vector<sc_time>(memSpec->ranksPerChannel, scMaxTime));
+    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
+    lastCommandOnBus = scMaxTime;
     last4Activates = std::vector<std::queue<sc_time>>(memSpec->ranksPerChannel);
 
     tBURST = memSpec->defaultBurstLength / memSpec->dataRate * memSpec->tCK;
@@ -82,50 +82,50 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command, const tlm_gene
         assert(burstLength <= memSpec->maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-            if (lastCommandStart != sc_max_time())
+            if (lastCommandStart != scMaxTime)
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE - tRDPRE);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRRD_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::WR || command == Command::WRA)
@@ -135,93 +135,93 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command, const tlm_gene
         assert(burstLength <= memSpec->maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR);
 
-        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank.ID()] ? lastScheduledByCommand[Command::RD] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR);
 
-        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::RDA] != lastScheduledByCommandAndRank[Command::RDA][rank.ID()] ? lastScheduledByCommand[Command::RDA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDWR_R);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
 
-        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank.ID()] ? lastScheduledByCommand[Command::WR] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
 
-        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : sc_max_time();
-        if (lastCommandStart != sc_max_time())
+        lastCommandStart = lastScheduledByCommand[Command::WRA] != lastScheduledByCommandAndRank[Command::WRA][rank.ID()] ? lastScheduledByCommand[Command::WRA] : scMaxTime;
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -230,141 +230,141 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command, const tlm_gene
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
     }
     else if(command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
     }
     else if(command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
 
         if (last4Activates[rank.ID()].size() >= 4)
@@ -373,108 +373,108 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command, const tlm_gene
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else if (command == Command::PDEP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tRDPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRAPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(tRDPDEN, tRDPRE + memSpec->tRPpb));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec->tRPpb));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank.ID()];
-        if (lastCommandStart != sc_max_time())
+        if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
     }
     else
         SC_REPORT_FATAL("CheckerWideIO2", "Unknown command!");
 
     // Check if command bus is free
-    if (lastCommandOnBus != sc_max_time())
+    if (lastCommandOnBus != scMaxTime)
         earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
 
     return earliestTimeToStart;

src/libdramsys/DRAMSys/controller/checker/CheckerWideIO2.h

@@ -60,6 +60,7 @@ private:
     // Four activate window
     std::vector<std::queue<sc_core::sc_time>> last4Activates;
 
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
     sc_core::sc_time tBURST;
     sc_core::sc_time tRDPRE;
     sc_core::sc_time tRDPDEN;

src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxOldest.cpp

@@ -45,7 +45,7 @@ CommandTuple::Type CmdMuxOldest::selectCommand(const ReadyCommands &readyCommand
     auto result = readyCommands.cend();
     uint64_t lastPayloadID = UINT64_MAX;
     uint64_t newPayloadID;
-    sc_time lastTimestamp = sc_max_time();
+    sc_time lastTimestamp = scMaxTime;
     sc_time newTimestamp;
 
     for (auto it = readyCommands.cbegin(); it != readyCommands.cend(); it++)
@@ -71,7 +71,7 @@ CommandTuple::Type CmdMuxOldest::selectCommand(const ReadyCommands &readyCommand
             std::get<CommandTuple::Timestamp>(*result) == sc_time_stamp())
         return *result;
     else
-        return {Command::NOP, nullptr, sc_max_time()};
+        return {Command::NOP, nullptr, scMaxTime};
 }
 
 
@@ -101,7 +101,7 @@ CommandTuple::Type CmdMuxOldestRasCas::selectCommand(const ReadyCommands &readyC
 
     uint64_t lastPayloadID = UINT64_MAX;
     uint64_t newPayloadID;
-    sc_time lastTimestamp = sc_max_time();
+    sc_time lastTimestamp = scMaxTime;
     sc_time newTimestamp;
 
     for (auto it = readyRasCommands.cbegin(); it != readyRasCommands.cend(); it++)
@@ -124,7 +124,7 @@ CommandTuple::Type CmdMuxOldestRasCas::selectCommand(const ReadyCommands &readyC
     }
 
     lastPayloadID = UINT64_MAX;
-    lastTimestamp = sc_max_time();
+    lastTimestamp = scMaxTime;
 
     for (auto it = readyCasCommands.cbegin(); it != readyCasCommands.cend(); it++)
     {
@@ -153,7 +153,7 @@ CommandTuple::Type CmdMuxOldestRasCas::selectCommand(const ReadyCommands &readyC
         readyRasCasCommands.emplace_back(*resultCas);
 
     lastPayloadID = UINT64_MAX;
-    lastTimestamp = sc_max_time();
+    lastTimestamp = scMaxTime;
 
     for (auto it = readyRasCasCommands.cbegin(); it != readyRasCasCommands.cend(); it++)
     {
@@ -177,5 +177,5 @@ CommandTuple::Type CmdMuxOldestRasCas::selectCommand(const ReadyCommands &readyC
             std::get<CommandTuple::Timestamp>(*result) == sc_time_stamp())
         return *result;
     else
-        return {Command::NOP, nullptr, sc_max_time()};
+        return {Command::NOP, nullptr, scMaxTime};
 }

src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxOldest.h

@@ -46,6 +46,7 @@ public:
 
 private:
     const MemSpec& memSpec;
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
 };
 
 
@@ -60,6 +61,7 @@ private:
     ReadyCommands readyRasCommands;
     ReadyCommands readyCasCommands;
     ReadyCommands readyRasCasCommands;
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
 };
 
 #endif // CMDMUXOLDEST_H

src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxStrict.cpp

@@ -45,7 +45,7 @@ CommandTuple::Type CmdMuxStrict::selectCommand(const ReadyCommands &readyCommand
     auto result = readyCommands.cend();
     uint64_t lastPayloadID = UINT64_MAX;
     uint64_t newPayloadID;
-    sc_time lastTimestamp = sc_max_time();
+    sc_time lastTimestamp = scMaxTime;
     sc_time newTimestamp;
 
     for (auto it = readyCommands.cbegin(); it != readyCommands.cend(); it++)
@@ -81,7 +81,7 @@ CommandTuple::Type CmdMuxStrict::selectCommand(const ReadyCommands &readyCommand
         return *result;
     }
     else
-        return {Command::NOP, nullptr, sc_max_time()};
+        return {Command::NOP, nullptr, scMaxTime};
 }
 
 
@@ -111,7 +111,7 @@ CommandTuple::Type CmdMuxStrictRasCas::selectCommand(const ReadyCommands &readyC
 
     uint64_t lastPayloadID = UINT64_MAX;
     uint64_t newPayloadID;
-    sc_time lastTimestamp = sc_max_time();
+    sc_time lastTimestamp = scMaxTime;
     sc_time newTimestamp;
 
     for (auto it = readyRasCommands.cbegin(); it != readyRasCommands.cend(); it++)
@@ -152,7 +152,7 @@ CommandTuple::Type CmdMuxStrictRasCas::selectCommand(const ReadyCommands &readyC
         readyRasCasCommands.emplace_back(*resultCas);
 
     lastPayloadID = UINT64_MAX;
-    lastTimestamp = sc_max_time();
+    lastTimestamp = scMaxTime;
 
     for (auto it = readyRasCasCommands.cbegin(); it != readyRasCasCommands.cend(); it++)
     {
@@ -180,5 +180,5 @@ CommandTuple::Type CmdMuxStrictRasCas::selectCommand(const ReadyCommands &readyC
             return *result;
         } 
     else
-        return {Command::NOP, nullptr, sc_max_time()};
+        return {Command::NOP, nullptr, scMaxTime};
 }

src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxStrict.h

@@ -47,6 +47,7 @@ public:
 private:
     uint64_t nextPayloadID = 1;
     const MemSpec& memSpec;
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
 };
 
 class CmdMuxStrictRasCas : public CmdMuxIF
@@ -61,6 +62,7 @@ private:
     ReadyCommands readyRasCommands;
     ReadyCommands readyCasCommands;
     ReadyCommands readyRasCasCommands;
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
 };
 
 #endif // CMDMUXSTRICT_H

src/libdramsys/DRAMSys/controller/powerdown/PowerDownManagerDummy.cpp

@@ -39,10 +39,5 @@ using namespace tlm;
 
 CommandTuple::Type PowerDownManagerDummy::getNextCommand()
 {
-    return {Command::NOP, nullptr, sc_max_time()};
-}
-
-sc_time PowerDownManagerDummy::start()
-{
-    return sc_max_time();
+    return {Command::NOP, nullptr, SC_ZERO_TIME};
 }

src/libdramsys/DRAMSys/controller/powerdown/PowerDownManagerDummy.h

@@ -47,8 +47,8 @@ public:
     void triggerInterruption() override {}
 
     CommandTuple::Type getNextCommand() override;
-    void updateState(Command) override {}
-    sc_core::sc_time start() override;
+    void update(Command) override {}
+    void evaluate() override {}
 };
 
 #endif // POWERDOWNMANAGERDUMMY_H

src/libdramsys/DRAMSys/controller/powerdown/PowerDownManagerIF.h

@@ -35,22 +35,17 @@
 #ifndef POWERDOWNMANAGERIF_H
 #define POWERDOWNMANAGERIF_H
 
+#include "DRAMSys/controller/ManagerIF.h"
 #include "DRAMSys/controller/Command.h"
 
 #include <systemc>
 
-class PowerDownManagerIF
+class PowerDownManagerIF : public ManagerIF
 {
 public:
-    virtual ~PowerDownManagerIF() = default;
-
     virtual void triggerEntry() = 0;
     virtual void triggerExit() = 0;
     virtual void triggerInterruption() = 0;
-
-    virtual CommandTuple::Type getNextCommand() = 0;
-    virtual void updateState(Command) = 0;
-    virtual sc_core::sc_time start() = 0;
 };
 
 #endif // POWERDOWNMANAGERIF_H

src/libdramsys/DRAMSys/controller/powerdown/PowerDownManagerStaggered.cpp

@@ -41,7 +41,7 @@ using namespace tlm;
 
 PowerDownManagerStaggered::PowerDownManagerStaggered(std::vector<BankMachine*>& bankMachinesOnRank,
         Rank rank, CheckerIF& checker)
-    : bankMachinesOnRank(bankMachinesOnRank), checker(checker)
+    : bankMachinesOnRank(bankMachinesOnRank)
 {
     setUpDummy(powerDownPayload, UINT64_MAX - 1, rank);
 }
@@ -74,12 +74,11 @@ void PowerDownManagerStaggered::triggerInterruption()
 
 CommandTuple::Type PowerDownManagerStaggered::getNextCommand()
 {
-    return {nextCommand, &powerDownPayload, std::max(timeToSchedule, sc_time_stamp())};
+    return {nextCommand, &powerDownPayload, SC_ZERO_TIME};
 }
 
-sc_time PowerDownManagerStaggered::start()
+void PowerDownManagerStaggered::evaluate()
 {
-    timeToSchedule = sc_max_time();
     nextCommand = Command::NOP;
 
     if (exitTriggered)
@@ -92,8 +91,6 @@ sc_time PowerDownManagerStaggered::start()
             nextCommand = Command::SREFEX;
         else if (state == State::ExtraRefresh)
             nextCommand = Command::REFAB;
-
-        timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, powerDownPayload);
     }
     else if (entryTriggered)
     {
@@ -106,19 +103,14 @@ sc_time PowerDownManagerStaggered::start()
                 break;
             }
         }
-
-        timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, powerDownPayload);
     }
     else if (enterSelfRefresh)
     {
         nextCommand = Command::SREFEN;
-        timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, powerDownPayload);
     }
-
-    return timeToSchedule;
 }
 
-void PowerDownManagerStaggered::updateState(Command command)
+void PowerDownManagerStaggered::update(Command command)
 {
     switch (command)
     {

src/libdramsys/DRAMSys/controller/powerdown/PowerDownManagerStaggered.h

@@ -54,16 +54,13 @@ public:
     void triggerInterruption() override;
 
     CommandTuple::Type getNextCommand() override;
-    void updateState(Command) override;
-    sc_core::sc_time start() override;
+    void update(Command) override;
+    void evaluate() override;
 
 private:
     enum class State {Idle, ActivePdn, PrechargePdn, SelfRefresh, ExtraRefresh} state = State::Idle;
     tlm::tlm_generic_payload powerDownPayload;
     std::vector<BankMachine*>& bankMachinesOnRank;
-    CheckerIF& checker;
-
-    sc_core::sc_time timeToSchedule = sc_core::sc_max_time();
     Command nextCommand = Command::NOP;
 
     bool controllerIdle = true;

src/libdramsys/DRAMSys/controller/refresh/RefreshManagerAllBank.cpp

@@ -42,8 +42,8 @@ using namespace sc_core;
 using namespace tlm;
 
 RefreshManagerAllBank::RefreshManagerAllBank(const Configuration& config, std::vector<BankMachine*>& bankMachinesOnRank,
-                                             PowerDownManagerIF& powerDownManager, Rank rank, const CheckerIF& checker)
-    : bankMachinesOnRank(bankMachinesOnRank), powerDownManager(powerDownManager), checker(checker),
+                                             PowerDownManagerIF& powerDownManager, Rank rank)
+    : bankMachinesOnRank(bankMachinesOnRank), powerDownManager(powerDownManager),
     memSpec(*config.memSpec), maxPostponed(static_cast<int>(config.refreshMaxPostponed)),
     maxPulledin(-static_cast<int>(config.refreshMaxPulledin)), refreshManagement(config.refreshManagement)
 {
@@ -54,12 +54,11 @@ RefreshManagerAllBank::RefreshManagerAllBank(const Configuration& config, std::v
 
 CommandTuple::Type RefreshManagerAllBank::getNextCommand()
 {
-    return {nextCommand, &refreshPayload, std::max(timeToSchedule, sc_time_stamp())};
+    return {nextCommand, &refreshPayload, SC_ZERO_TIME};
 }
 
-sc_time RefreshManagerAllBank::start()
+void RefreshManagerAllBank::evaluate()
 {
-    timeToSchedule = sc_max_time();
     nextCommand = Command::NOP;
 
     if (sc_time_stamp() >= timeForNextTrigger) // Normal refresh
@@ -67,7 +66,7 @@ sc_time RefreshManagerAllBank::start()
         powerDownManager.triggerInterruption();
 
         if (sleeping)
-            return timeToSchedule;
+            return;
 
         if (sc_time_stamp() >= timeForNextTrigger + memSpec.getRefreshIntervalAB())
         {
@@ -104,8 +103,7 @@ sc_time RefreshManagerAllBank::start()
                 else
                     nextCommand = Command::REFAB;
 
-                timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, refreshPayload);
-                return timeToSchedule;
+                return;
             }
         }
         else // if (state == RmState::Pulledin)
@@ -126,8 +124,7 @@ sc_time RefreshManagerAllBank::start()
             {
                 assert(activatedBanks == 0);
                 nextCommand = Command::REFAB;
-                timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, refreshPayload);
-                return timeToSchedule;
+                return;
             }
         }
     }
@@ -168,15 +165,12 @@ sc_time RefreshManagerAllBank::start()
             else
                 nextCommand = Command::RFMAB;
 
-            timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, refreshPayload);
-            return timeToSchedule;
+            return;
         }
     }
-
-    return timeForNextTrigger;
 }
 
-void RefreshManagerAllBank::updateState(Command command)
+void RefreshManagerAllBank::update(Command command)
 {
     switch (command)
     {
@@ -216,7 +210,7 @@ void RefreshManagerAllBank::updateState(Command command)
             break;
         case Command::SREFEN:
             sleeping = true;
-            timeForNextTrigger = sc_max_time();
+            timeForNextTrigger = scMaxTime;
             break;
         case Command::PDXA: case Command::PDXP:
             sleeping = false;
@@ -225,3 +219,8 @@ void RefreshManagerAllBank::updateState(Command command)
             break;
     }
 }
+
+sc_time RefreshManagerAllBank::getTimeForNextTrigger()
+{
+    return timeForNextTrigger;
+}

src/libdramsys/DRAMSys/controller/refresh/RefreshManagerAllBank.h

@@ -51,11 +51,12 @@ class RefreshManagerAllBank final : public RefreshManagerIF
 {
 public:
     RefreshManagerAllBank(const Configuration& config, std::vector<BankMachine*>& bankMachinesOnRank,
-                          PowerDownManagerIF& powerDownManager, Rank rank, const CheckerIF& checker);
+                          PowerDownManagerIF& powerDownManager, Rank rank);
 
     CommandTuple::Type getNextCommand() override;
-    sc_core::sc_time start() override;
-    void updateState(Command) override;
+    void evaluate() override;
+    void update(Command) override;
+    sc_core::sc_time getTimeForNextTrigger() override;
 
 private:
     enum class State {Regular, Pulledin} state = State::Regular;
@@ -64,8 +65,6 @@ private:
     PowerDownManagerIF& powerDownManager;
     tlm::tlm_generic_payload refreshPayload;
     sc_core::sc_time timeForNextTrigger = sc_core::sc_max_time();
-    sc_core::sc_time timeToSchedule = sc_core::sc_max_time();
-    const CheckerIF& checker;
     Command nextCommand = Command::NOP;
 
     unsigned activatedBanks = 0;
@@ -76,6 +75,7 @@ private:
 
     bool sleeping = false;
     const bool refreshManagement;
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
 };
 
 #endif // REFRESHMANAGERALLBANK_H

src/libdramsys/DRAMSys/controller/refresh/RefreshManagerDummy.cpp

@@ -39,10 +39,10 @@ using namespace tlm;
 
 CommandTuple::Type RefreshManagerDummy::getNextCommand()
 {
-    return {Command::NOP, nullptr, sc_max_time()};
+    return {Command::NOP, nullptr, SC_ZERO_TIME};
 }
 
-sc_time RefreshManagerDummy::start()
+sc_time RefreshManagerDummy::getTimeForNextTrigger()
 {
-    return sc_max_time();
-}
+    return scMaxTime;
+}

src/libdramsys/DRAMSys/controller/refresh/RefreshManagerDummy.h

@@ -43,8 +43,11 @@ class RefreshManagerDummy final : public RefreshManagerIF
 {
 public:
     CommandTuple::Type getNextCommand() override;
-    sc_core::sc_time start() override;
-    void updateState(Command) override {}
+    void evaluate() override {}
+    void update(Command) override {}
+    sc_core::sc_time getTimeForNextTrigger() override;
+private:
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
 };
 
 #endif // REFRESHMANAGERDUMMY_H

src/libdramsys/DRAMSys/controller/refresh/RefreshManagerIF.h

@@ -35,21 +35,17 @@
 #ifndef REFRESHMANAGERIF_H
 #define REFRESHMANAGERIF_H
 
-
+#include "DRAMSys/controller/ManagerIF.h"
 #include "DRAMSys/controller/Command.h"
 #include "DRAMSys/configuration/Configuration.h"
 
 #include <cmath>
 #include <systemc>
 
-class RefreshManagerIF
+class RefreshManagerIF : public ManagerIF
 {
 public:
-    virtual ~RefreshManagerIF() = default;
-
-    virtual CommandTuple::Type getNextCommand() = 0;
-    virtual sc_core::sc_time start() = 0;
-    virtual void updateState(Command) = 0;
+    virtual sc_core::sc_time getTimeForNextTrigger() = 0;
 
 protected:
     static sc_core::sc_time getTimeForFirstTrigger(const sc_core::sc_time& tCK, const sc_core::sc_time &refreshInterval,

src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPer2Bank.cpp

@@ -42,9 +42,8 @@ using namespace tlm;
 
 RefreshManagerPer2Bank::RefreshManagerPer2Bank(const Configuration& config,
                                                std::vector<BankMachine*>& bankMachinesOnRank,
-                                               PowerDownManagerIF& powerDownManager, Rank rank,
-                                               const CheckerIF& checker)
-    : powerDownManager(powerDownManager), checker(checker), memSpec(*config.memSpec),
+                                               PowerDownManagerIF& powerDownManager, Rank rank)
+    : powerDownManager(powerDownManager), memSpec(*config.memSpec),
     maxPostponed(static_cast<int>(config.refreshMaxPostponed * memSpec.banksPerRank / 2)),
     maxPulledin(-static_cast<int>(config.refreshMaxPulledin * memSpec.banksPerRank / 2))
 {
@@ -72,19 +71,18 @@ RefreshManagerPer2Bank::RefreshManagerPer2Bank(const Configuration& config,
 
 CommandTuple::Type RefreshManagerPer2Bank::getNextCommand()
 {
-    return {nextCommand, currentRefreshPayload, std::max(timeToSchedule, sc_time_stamp())};
+    return {nextCommand, currentRefreshPayload, SC_ZERO_TIME};
 }
 
-sc_time RefreshManagerPer2Bank::start()
+void RefreshManagerPer2Bank::evaluate()
 {
-    timeToSchedule = sc_max_time();
     nextCommand = Command::NOP;
 
     if (sc_time_stamp() >= timeForNextTrigger)
     {
         powerDownManager.triggerInterruption();
         if (sleeping)
-            return timeToSchedule;
+            return;
 
         if (sc_time_stamp() >= timeForNextTrigger + memSpec.getRefreshIntervalP2B())
         {
@@ -124,7 +122,7 @@ sc_time RefreshManagerPer2Bank::start()
             {
                 flexibilityCounter++;
                 timeForNextTrigger += memSpec.getRefreshIntervalP2B();
-                return timeForNextTrigger;
+                return;
             }
             else
             {
@@ -147,9 +145,7 @@ sc_time RefreshManagerPer2Bank::start()
                         it->block();
                     skipSelection = true;
                 }
-
-                timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, *currentRefreshPayload);
-                return timeToSchedule;
+                return;
             }
         }
         else // if (state == RmState::Pulledin)
@@ -180,7 +176,7 @@ sc_time RefreshManagerPer2Bank::start()
             {
                 state = State::Regular;
                 timeForNextTrigger += memSpec.getRefreshIntervalP2B();
-                return timeForNextTrigger;
+                return;
             }
             else
             {
@@ -195,17 +191,13 @@ sc_time RefreshManagerPer2Bank::start()
                         break;
                     }
                 }
-
-                timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, *currentRefreshPayload);
-                return timeToSchedule;
+                return;
             }
         }
     }
-    else
-        return timeForNextTrigger;
 }
 
-void RefreshManagerPer2Bank::updateState(Command command)
+void RefreshManagerPer2Bank::update(Command command)
 {
     switch (command)
     {
@@ -241,7 +233,7 @@ void RefreshManagerPer2Bank::updateState(Command command)
             break;
         case Command::SREFEN:
             sleeping = true;
-            timeForNextTrigger = sc_max_time();
+            timeForNextTrigger = scMaxTime;
             break;
         case Command::PDXA: case Command::PDXP:
             sleeping = false;
@@ -250,3 +242,8 @@ void RefreshManagerPer2Bank::updateState(Command command)
             break;
     }
 }
+
+sc_time RefreshManagerPer2Bank::getTimeForNextTrigger()
+{
+    return timeForNextTrigger;
+}

src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPer2Bank.h

@@ -53,11 +53,12 @@ class RefreshManagerPer2Bank final : public RefreshManagerIF
 {
 public:
     RefreshManagerPer2Bank(const Configuration& config, std::vector<BankMachine*>& bankMachinesOnRank,
-                           PowerDownManagerIF& powerDownManager, Rank rank, const CheckerIF& checker);
+                           PowerDownManagerIF& powerDownManager, Rank rank);
 
     CommandTuple::Type getNextCommand() override;
-    sc_core::sc_time start() override;
-    void updateState(Command) override;
+    void evaluate() override;
+    void update(Command) override;
+    sc_core::sc_time getTimeForNextTrigger() override;
 
 private:
     enum class State {Regular, Pulledin} state = State::Regular;
@@ -66,8 +67,6 @@ private:
     std::unordered_map<BankMachine*, tlm::tlm_generic_payload> refreshPayloads;
     tlm::tlm_generic_payload* currentRefreshPayload;
     sc_core::sc_time timeForNextTrigger = sc_core::sc_max_time();
-    sc_core::sc_time timeToSchedule = sc_core::sc_max_time();
-    const CheckerIF& checker;
     Command nextCommand = Command::NOP;
 
     std::list<std::vector<BankMachine*>> remainingBankMachines;
@@ -80,6 +79,8 @@ private:
 
     bool sleeping = false;
     bool skipSelection = false;
+
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
 };
 
 #endif // REFRESHMANAGERPER2BANK_H

src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPerBank.cpp

@@ -41,8 +41,8 @@ using namespace sc_core;
 using namespace tlm;
 
 RefreshManagerPerBank::RefreshManagerPerBank(const Configuration& config, std::vector<BankMachine*>& bankMachinesOnRank,
-                                             PowerDownManagerIF& powerDownManager, Rank rank, const CheckerIF& checker)
-    : powerDownManager(powerDownManager), checker(checker), memSpec(*config.memSpec),
+                                             PowerDownManagerIF& powerDownManager, Rank rank)
+    : powerDownManager(powerDownManager), memSpec(*config.memSpec),
     maxPostponed(static_cast<int>(config.refreshMaxPostponed * memSpec.banksPerRank)),
     maxPulledin(-static_cast<int>(config.refreshMaxPulledin * memSpec.banksPerRank))
 {
@@ -60,19 +60,18 @@ RefreshManagerPerBank::RefreshManagerPerBank(const Configuration& config, std::v
 
 CommandTuple::Type RefreshManagerPerBank::getNextCommand()
 {
-    return {nextCommand, &refreshPayloads.at(*currentIterator), std::max(timeToSchedule, sc_time_stamp())};
+    return {nextCommand, &refreshPayloads.at(*currentIterator), SC_ZERO_TIME};
 }
 
-sc_time RefreshManagerPerBank::start()
+void RefreshManagerPerBank::evaluate()
 {
-    timeToSchedule = sc_max_time();
     nextCommand = Command::NOP;
 
     if (sc_time_stamp() >= timeForNextTrigger)
     {
         powerDownManager.triggerInterruption();
         if (sleeping)
-            return timeToSchedule;
+            return;
 
         if (sc_time_stamp() >= timeForNextTrigger + memSpec.getRefreshIntervalPB())
         {
@@ -104,7 +103,7 @@ sc_time RefreshManagerPerBank::start()
             {
                 flexibilityCounter++;
                 timeForNextTrigger += memSpec.getRefreshIntervalPB();
-                return timeForNextTrigger;
+                return;
             }
             else
             {
@@ -121,9 +120,7 @@ sc_time RefreshManagerPerBank::start()
                         skipSelection = true;
                     }
                 }
-
-                timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, refreshPayloads.at(*currentIterator));
-                return timeToSchedule;
+                return;
             }
         }
         else // if (state == RmState::Pulledin)
@@ -144,7 +141,7 @@ sc_time RefreshManagerPerBank::start()
             {
                 state = State::Regular;
                 timeForNextTrigger += memSpec.getRefreshIntervalPB();
-                return timeForNextTrigger;
+                return;
             }
             else
             {
@@ -153,16 +150,13 @@ sc_time RefreshManagerPerBank::start()
                 else
                     nextCommand = Command::REFPB;
 
-                timeToSchedule = checker.timeToSatisfyConstraints(nextCommand, refreshPayloads.at(*currentIterator));
-                return timeToSchedule;
+                return;
             }
         }
     }
-    else
-        return timeForNextTrigger;
 }
 
-void RefreshManagerPerBank::updateState(Command command)
+void RefreshManagerPerBank::update(Command command)
 {
     switch (command)
     {
@@ -198,7 +192,7 @@ void RefreshManagerPerBank::updateState(Command command)
             break;
         case Command::SREFEN:
             sleeping = true;
-            timeForNextTrigger = sc_max_time();
+            timeForNextTrigger = scMaxTime;
             break;
         case Command::PDXA: case Command::PDXP:
             sleeping = false;
@@ -207,3 +201,8 @@ void RefreshManagerPerBank::updateState(Command command)
             break;
     }
 }
+
+sc_time RefreshManagerPerBank::getTimeForNextTrigger()
+{
+    return timeForNextTrigger;
+}

src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPerBank.h

@@ -53,11 +53,12 @@ class RefreshManagerPerBank final : public RefreshManagerIF
 {
 public:
     RefreshManagerPerBank(const Configuration& config, std::vector<BankMachine *>& bankMachinesOnRank,
-                          PowerDownManagerIF& powerDownManager, Rank rank, const CheckerIF& checker);
+                          PowerDownManagerIF& powerDownManager, Rank rank);
 
     CommandTuple::Type getNextCommand() override;
-    sc_core::sc_time start() override;
-    void updateState(Command) override;
+    void evaluate() override;
+    void update(Command) override;
+    sc_core::sc_time getTimeForNextTrigger() override;
 
 private:
     enum class State {Regular, Pulledin} state = State::Regular;
@@ -65,8 +66,6 @@ private:
     PowerDownManagerIF& powerDownManager;
     std::unordered_map<BankMachine*, tlm::tlm_generic_payload> refreshPayloads;
     sc_core::sc_time timeForNextTrigger = sc_core::sc_max_time();
-    sc_core::sc_time timeToSchedule = sc_core::sc_max_time();
-    const CheckerIF& checker;
     Command nextCommand = Command::NOP;
 
     std::list<BankMachine*> remainingBankMachines;
@@ -79,6 +78,8 @@ private:
 
     bool sleeping = false;
     bool skipSelection = false;
+
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
 };
 
 #endif // REFRESHMANAGERPERBANK_H

src/libdramsys/DRAMSys/controller/refresh/RefreshManagerSameBank.cpp

@@ -42,9 +42,8 @@ using namespace tlm;
 
 RefreshManagerSameBank::RefreshManagerSameBank(const Configuration& config,
                                                std::vector<BankMachine*>& bankMachinesOnRank,
-                                               PowerDownManagerIF& powerDownManager, Rank rank,
-                                               const CheckerIF& checker)
-    : powerDownManager(powerDownManager), checker(checker), memSpec(*config.memSpec),
+                                               PowerDownManagerIF& powerDownManager, Rank rank)
+    : powerDownManager(powerDownManager), memSpec(*config.memSpec),
     maxPostponed(static_cast<int>(config.refreshMaxPostponed * memSpec.banksPerGroup)),
     maxPulledin(-static_cast<int>(config.refreshMaxPulledin * memSpec.banksPerGroup)),
     refreshManagement(config.refreshManagement)
@@ -79,19 +78,18 @@ CommandTuple::Type RefreshManagerSameBank::getNextCommand()
 {
     return {nextCommand,
             &refreshPayloads[currentIterator->front()->getBank().ID() % memSpec.banksPerGroup],
-            std::max(timeToSchedule, sc_time_stamp())};
+            SC_ZERO_TIME};
 }
 
-sc_time RefreshManagerSameBank::start()
+void RefreshManagerSameBank::evaluate()
 {
-    timeToSchedule = sc_max_time();
     nextCommand = Command::NOP;
 
     if (sc_time_stamp() >= timeForNextTrigger)
     {
         powerDownManager.triggerInterruption();
         if (sleeping)
-            return timeToSchedule;
+            return;
 
         if (sc_time_stamp() >= timeForNextTrigger + memSpec.getRefreshIntervalSB())
         {
@@ -152,10 +150,7 @@ sc_time RefreshManagerSameBank::start()
                         it->block();
                     skipSelection = true;
                 }
-
-                timeToSchedule = checker.timeToSatisfyConstraints(nextCommand,
-                        refreshPayloads[currentIterator->front()->getBank().ID() % memSpec.banksPerGroup]);
-                return timeToSchedule;
+                return;
             }
         }
         else // if (state == RmState::Pulledin)
@@ -198,10 +193,7 @@ sc_time RefreshManagerSameBank::start()
                         break;
                     }
                 }
-
-                timeToSchedule = checker.timeToSatisfyConstraints(nextCommand,
-                        refreshPayloads[currentIterator->front()->getBank().ID() % memSpec.banksPerGroup]);
-                return timeToSchedule;
+                return;
             }
         }
     }
@@ -237,9 +229,7 @@ sc_time RefreshManagerSameBank::start()
                 if (groupIt->isActivated())
                     nextCommand = Command::PRESB;
             }
-            timeToSchedule = checker.timeToSatisfyConstraints(nextCommand,
-                    refreshPayloads[currentIterator->front()->getBank().ID() % memSpec.banksPerGroup]);
-            return timeToSchedule;
+            return;
         }
         else if (!imtCandidates.empty())
         {
@@ -274,17 +264,13 @@ sc_time RefreshManagerSameBank::start()
                         break;
                     }
                 }
-                timeToSchedule = checker.timeToSatisfyConstraints(nextCommand,
-                        refreshPayloads[currentIterator->front()->getBank().ID() % memSpec.banksPerGroup]);
-                return timeToSchedule;
+                return;
             }
         }
     }
-
-    return timeForNextTrigger;
 }
 
-void RefreshManagerSameBank::updateState(Command command)
+void RefreshManagerSameBank::update(Command command)
 {
     switch (command)
     {
@@ -320,7 +306,7 @@ void RefreshManagerSameBank::updateState(Command command)
             break;
         case Command::SREFEN:
             sleeping = true;
-            timeForNextTrigger = sc_max_time();
+            timeForNextTrigger = scMaxTime;
             break;
         case Command::PDXA: case Command::PDXP:
             sleeping = false;
@@ -329,3 +315,8 @@ void RefreshManagerSameBank::updateState(Command command)
             break;
     }
 }
+
+sc_time RefreshManagerSameBank::getTimeForNextTrigger()
+{
+    return timeForNextTrigger;
+}

src/libdramsys/DRAMSys/controller/refresh/RefreshManagerSameBank.h

@@ -52,11 +52,12 @@ class RefreshManagerSameBank final : public RefreshManagerIF
 {
 public:
     RefreshManagerSameBank(const Configuration& config, std::vector<BankMachine *>& bankMachinesOnRank,
-                           PowerDownManagerIF& powerDownManager, Rank rank, const CheckerIF& checker);
+                           PowerDownManagerIF& powerDownManager, Rank rank);
 
     CommandTuple::Type getNextCommand() override;
-    sc_core::sc_time start() override;
-    void updateState(Command) override;
+    void evaluate() override;
+    void update(Command) override;
+    sc_core::sc_time getTimeForNextTrigger() override;
 
 private:
     enum class State {Regular, Pulledin} state = State::Regular;
@@ -64,8 +65,6 @@ private:
     PowerDownManagerIF& powerDownManager;
     std::vector<tlm::tlm_generic_payload> refreshPayloads;
     sc_core::sc_time timeForNextTrigger = sc_core::sc_max_time();
-    sc_core::sc_time timeToSchedule = sc_core::sc_max_time();
-    const CheckerIF& checker;
     Command nextCommand = Command::NOP;
 
     std::list<std::vector<BankMachine *>> remainingBankMachines;
@@ -80,6 +79,7 @@ private:
     bool skipSelection = false;
 
     const bool refreshManagement;
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
 };
 
 #endif // REFRESHMANAGERSAMEBANK_H

src/libdramsys/DRAMSys/controller/respqueue/RespQueueFifo.cpp

@@ -64,5 +64,5 @@ sc_time RespQueueFifo::getTriggerTime() const
         if (triggerTime > sc_time_stamp())
             return triggerTime;
     }
-    return sc_max_time();
+    return scMaxTime;
 }

src/libdramsys/DRAMSys/controller/respqueue/RespQueueFifo.h

@@ -51,6 +51,7 @@ public:
 
 private:
     std::queue<std::pair<tlm::tlm_generic_payload*, sc_core::sc_time>> buffer;
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
 };
 
 #endif // RESPQUEUEFIFO_H

src/libdramsys/DRAMSys/controller/respqueue/RespQueueReorder.cpp

@@ -72,5 +72,5 @@ sc_time RespQueueReorder::getTriggerTime() const
                 return triggerTime;
         }
     }
-    return sc_max_time();
+    return scMaxTime;
 }

src/libdramsys/DRAMSys/controller/respqueue/RespQueueReorder.h

@@ -51,6 +51,7 @@ public:
 private:
     uint64_t nextPayloadID = 1;
     std::map<uint64_t, std::pair<tlm::tlm_generic_payload*, sc_core::sc_time>> buffer;
+    const sc_core::sc_time scMaxTime = sc_core::sc_max_time();
 };
 
 #endif // RESPQUEUEREORDER_H