diff --git a/DRAMSys/library/src/configuration/memspec/MemSpecHBM2.cpp b/DRAMSys/library/src/configuration/memspec/MemSpecHBM2.cpp
index 09897b09..784b4f99 100644
--- a/DRAMSys/library/src/configuration/memspec/MemSpecHBM2.cpp
+++ b/DRAMSys/library/src/configuration/memspec/MemSpecHBM2.cpp
@@ -101,9 +101,9 @@ sc_time MemSpecHBM2::getExecutionTime(Command command, const tlm_generic_payload
     else if (command == Command::ACT)
     {
         if (payload.get_command() == TLM_READ_COMMAND)
-            return tRCDRD;
+            return tRCDRD + tCK;
         else
-            return tRCDWR;
+            return tRCDWR + tCK;
     }
     else if (command == Command::RD)
         return tRL + tDQSCK + burstDuration;
diff --git a/DRAMSys/library/src/configuration/memspec/MemSpecLPDDR4.cpp b/DRAMSys/library/src/configuration/memspec/MemSpecLPDDR4.cpp
index c4d2050e..915c14c4 100644
--- a/DRAMSys/library/src/configuration/memspec/MemSpecLPDDR4.cpp
+++ b/DRAMSys/library/src/configuration/memspec/MemSpecLPDDR4.cpp
@@ -107,23 +107,23 @@ sc_time MemSpecLPDDR4::getRefreshIntervalPB() const
 sc_time MemSpecLPDDR4::getExecutionTime(Command command, const tlm_generic_payload &) const
 {
     if (command == Command::PRE)
-        return tRPpb;
+        return tRPpb + tCK;
     else if (command == Command::PREA)
-        return tRPab;
+        return tRPab + tCK;
     else if (command == Command::ACT)
-        return tRCD;
+        return tRCD + 3 * tCK;
     else if (command == Command::RD)
-        return tRL + tDQSCK + burstDuration;
+        return tRL + tDQSCK + burstDuration + 3 * tCK;
     else if (command == Command::RDA)
-        return burstDuration + tRTP - 8 * tCK + tRPpb;
+        return burstDuration + tRTP - 5 * tCK + tRPpb;
     else if (command == Command::WR)
-        return tWL + tDQSS + tDQS2DQ + burstDuration;
+        return tWL + tDQSS + tDQS2DQ + burstDuration + 3 * tCK;
     else if (command == Command::WRA)
-        return tWL + tCK + burstDuration + tWR + tRPpb;
+        return tWL + 4 * tCK + burstDuration + tWR + tRPpb;
     else if (command == Command::REFA)
-        return tRFCab;
+        return tRFCab + tCK;
     else if (command == Command::REFB)
-        return tRFCpb;
+        return tRFCpb + tCK;
     else
     {
         SC_REPORT_FATAL("getExecutionTime",
@@ -135,11 +135,11 @@ sc_time MemSpecLPDDR4::getExecutionTime(Command command, const tlm_generic_paylo
 TimeInterval MemSpecLPDDR4::getIntervalOnDataStrobe(Command command) const
 {
     if (command == Command::RD || command == Command::RDA)
-        return TimeInterval(sc_time_stamp() + tRL + tDQSCK,
-                            sc_time_stamp() + tRL + tDQSCK + burstDuration);
+        return TimeInterval(sc_time_stamp() + tRL + tDQSCK + 3 * tCK,
+                            sc_time_stamp() + tRL + tDQSCK + burstDuration + 3 * tCK);
     else if (command == Command::WR || command == Command::WRA)
-        return TimeInterval(sc_time_stamp() + tWL + tDQSS + tDQS2DQ,
-                            sc_time_stamp() + tWL + tDQSS + tDQS2DQ + burstDuration);
+        return TimeInterval(sc_time_stamp() + tWL + tDQSS + tDQS2DQ + 3 * tCK,
+                            sc_time_stamp() + tWL + tDQSS + tDQS2DQ + burstDuration + 3 * tCK);
     else
     {
         SC_REPORT_FATAL("MemSpecLPDDR4", "Method was called with invalid argument");
diff --git a/DRAMSys/library/src/controller/checker/CheckerHBM2.cpp b/DRAMSys/library/src/controller/checker/CheckerHBM2.cpp
index d1c316b0..a9dc4ec6 100644
--- a/DRAMSys/library/src/controller/checker/CheckerHBM2.cpp
+++ b/DRAMSys/library/src/controller/checker/CheckerHBM2.cpp
@@ -71,7 +71,7 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, Rank rank, BankGr
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankgroup.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -115,12 +115,14 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, Rank rank, BankGr
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
         if (lastCommandStart != SC_ZERO_TIME)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
     }
     else if (command == Command::WR || command == Command::WRA)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -149,6 +151,8 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, Rank rank, BankGr
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
         if (lastCommandStart != SC_ZERO_TIME)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
     }
     else if (command == Command::ACT)
     {
@@ -166,52 +170,54 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, Rank rank, BankGr
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PRE][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXP];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFB][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFB][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD - memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS - memSpec->tCK);
 
         if (last4Activates[rank.ID()].size() >= 4)
-            earliestTimeToStart = std::max(earliestTimeToStart, last4Activates[rank.ID()].front() + memSpec->tFAW);
+            earliestTimeToStart = std::max(earliestTimeToStart, last4Activates[rank.ID()].front() + memSpec->tFAW -  memSpec->tCK);
+
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
     }
     else if (command == Command::PRE)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -224,12 +230,14 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, Rank rank, BankGr
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
         if (lastCommandStart != SC_ZERO_TIME)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
     }
     else if (command == Command::PREA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -254,12 +262,14 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, Rank rank, BankGr
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFB][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB);
+
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
     }
     else if (command == Command::REFA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -292,20 +302,22 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, Rank rank, BankGr
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
         if (lastCommandStart != SC_ZERO_TIME)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
     }
     else if (command == Command::REFB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankgroup.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -354,6 +366,8 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, Rank rank, BankGr
 
         if (last4Activates[rank.ID()].size() >= 4)
             earliestTimeToStart = std::max(earliestTimeToStart, last4Activates[rank.ID()].front() + memSpec->tFAW);
+
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
     }
     else if (command == Command::PDEA)
     {
@@ -376,12 +390,16 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, Rank rank, BankGr
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
         if (lastCommandStart != SC_ZERO_TIME)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommand[Command::PDEA];
         if (lastCommandStart != SC_ZERO_TIME)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
     }
     else if (command == Command::PDEP)
     {
@@ -404,18 +422,22 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, Rank rank, BankGr
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
         if (lastCommandStart != SC_ZERO_TIME)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommand[Command::PDEP];
         if (lastCommandStart != SC_ZERO_TIME)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommand[Command::ACT];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -448,22 +470,20 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command, Rank rank, BankGr
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
         if (lastCommandStart != SC_ZERO_TIME)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommand[Command::SREFEN];
         if (lastCommandStart != SC_ZERO_TIME)
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
+
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
     }
     else
         SC_REPORT_FATAL("CheckerHBM2", "Unknown command!");
 
-    // Check if command bus is free
-    if (isRasCommand(command))
-        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->getCommandLength(command));
-    else
-        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
-
     return earliestTimeToStart;
 }
 
@@ -477,16 +497,18 @@ void CheckerHBM2::insert(Command command, Rank rank, BankGroup bankgroup, Bank b
     lastScheduledByCommandAndRank[command][rank.ID()] = sc_time_stamp();
     lastScheduledByCommand[command] = sc_time_stamp();
 
-    if (isRasCommand(command))
-        lastCommandOnRasBus = sc_time_stamp();
-    else
+    if (isCasCommand(command))
         lastCommandOnCasBus = sc_time_stamp();
+    else if (command == Command::ACT)
+        lastCommandOnRasBus = sc_time_stamp() + memSpec->tCK;
+    else
+        lastCommandOnRasBus = sc_time_stamp();
 
     if (command == Command::ACT || command == Command::REFB)
     {
         if (last4Activates[rank.ID()].size() == 4)
             last4Activates[rank.ID()].pop();
-        last4Activates[rank.ID()].push(sc_time_stamp());
+        last4Activates[rank.ID()].push(lastCommandOnRasBus);
     }
 
     if (command == Command::REFB)
diff --git a/DRAMSys/library/src/controller/checker/CheckerLPDDR4.cpp b/DRAMSys/library/src/controller/checker/CheckerLPDDR4.cpp
index 57c95988..3dc894f9 100644
--- a/DRAMSys/library/src/controller/checker/CheckerLPDDR4.cpp
+++ b/DRAMSys/library/src/controller/checker/CheckerLPDDR4.cpp
@@ -54,16 +54,16 @@ CheckerLPDDR4::CheckerLPDDR4()
     tRDWR_R = memSpec->tRL + tBURST + memSpec->tRTRS - memSpec->tWL;
     tWRRD = memSpec->tWL + memSpec->tCK + tBURST + memSpec->tWTR;
     tWRRD_R = memSpec->tWL + tBURST + memSpec->tRTRS - memSpec->tRL;
-    tRDPRE = memSpec->tRTP + tBURST - 8 * memSpec->tCK;
+    tRDPRE = memSpec->tRTP + tBURST - 6 * memSpec->tCK;
     tRDAACT = memSpec->tRTP + tBURST - 8 * memSpec->tCK + memSpec->tRPpb;
-    tWRPRE = memSpec->tWL + tBURST + memSpec->tCK + memSpec->tWR;
+    tWRPRE = memSpec->tWL + tBURST + memSpec->tCK + memSpec->tWR + 2 * memSpec->tCK;
     tWRAACT = memSpec->tWL + tBURST + memSpec->tCK + memSpec->tWR + memSpec->tRPpb;
-    tACTPDEN = memSpec->tCMDCKE;
-    tPRPDEN = memSpec->tCMDCKE;
-    tRDPDEN = memSpec->tRL + memSpec->tDQSCK + tBURST + memSpec->tRPST;
-    tWRPDEN = memSpec->tWL + (std::ceil(memSpec->tDQSS / memSpec->tCK) + std::ceil(memSpec->tDQS2DQ / memSpec->tCK)) * memSpec->tCK + tBURST + memSpec->tWR;
-    tWRAPDEN = memSpec->tWL + (std::ceil(memSpec->tDQSS / memSpec->tCK) + std::ceil(memSpec->tDQS2DQ / memSpec->tCK)) * memSpec->tCK + tBURST + memSpec->tWR + 2 * memSpec->tCK;
-    tREFPDEN = memSpec->tCMDCKE;
+    tACTPDEN = 3 * memSpec->tCK + memSpec->tCMDCKE;
+    tPRPDEN = memSpec->tCK + memSpec->tCMDCKE;
+    tRDPDEN = 3 * memSpec->tCK + memSpec->tRL + memSpec->tDQSCK + tBURST + memSpec->tRPST;
+    tWRPDEN = 3 * memSpec->tCK + memSpec->tWL + (std::ceil(memSpec->tDQSS / memSpec->tCK) + std::ceil(memSpec->tDQS2DQ / memSpec->tCK)) * memSpec->tCK + tBURST + memSpec->tWR;
+    tWRAPDEN = 3 * memSpec->tCK + memSpec->tWL + (std::ceil(memSpec->tDQSS / memSpec->tCK) + std::ceil(memSpec->tDQS2DQ / memSpec->tCK)) * memSpec->tCK + tBURST + memSpec->tWR + 2 * memSpec->tCK;
+    tREFPDEN = memSpec->tCK + memSpec->tCMDCKE;
 }
 
 sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, BankGroup, Bank bank) const
@@ -118,7 +118,7 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, Bank
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP + 3 * memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::WR || command == Command::WRA)
     {
@@ -160,7 +160,7 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, Bank
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP + 3 * memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::ACT)
     {
@@ -182,44 +182,44 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, Bank
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PRE][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb - 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab - 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP + 3 * memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP + 3 * memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab - 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFB][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb - 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFB][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD - 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR - 2 * memSpec->tCK);
 
         if (last4Activates[rank.ID()].size() >= 4)
-            earliestTimeToStart = std::max(earliestTimeToStart, last4Activates[rank.ID()].front() + memSpec->tFAW);
+            earliestTimeToStart = std::max(earliestTimeToStart, last4Activates[rank.ID()].front() + memSpec->tFAW - 3 * memSpec->tCK);
     }
     else if (command == Command::PRE)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -235,13 +235,13 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, Bank
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
     }
     else if (command == Command::PREA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -265,7 +265,7 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, Bank
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFB][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -275,7 +275,7 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, Bank
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -295,7 +295,7 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, Bank
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -313,11 +313,11 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, Bank
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -337,11 +337,11 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, Bank
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -356,7 +356,7 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, Bank
             earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
 
         if (last4Activates[rank.ID()].size() >= 4)
-            earliestTimeToStart = std::max(earliestTimeToStart, last4Activates[rank.ID()].front() + memSpec->tFAW);
+            earliestTimeToStart = std::max(earliestTimeToStart, last4Activates[rank.ID()].front() + memSpec->tFAW - memSpec->tCK);
     }
     else if (command == Command::PDEA)
     {
@@ -446,7 +446,7 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, Bank
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + 2 * memSpec->tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -466,7 +466,7 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, Bank
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFA][rank.ID()];
         if (lastCommandStart != SC_ZERO_TIME)
@@ -490,7 +490,7 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command, Rank rank, Bank
         SC_REPORT_FATAL("CheckerLPDDR4", "Unknown command!");
 
     // Check if command bus is free
-    earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->getCommandLength(command));
+    earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
 
     return earliestTimeToStart;
 }
@@ -504,12 +504,12 @@ void CheckerLPDDR4::insert(Command command, Rank rank, BankGroup, Bank bank)
     lastScheduledByCommandAndRank[command][rank.ID()] = sc_time_stamp();
     lastScheduledByCommand[command] = sc_time_stamp();
 
-    lastCommandOnBus = sc_time_stamp();
+    lastCommandOnBus = sc_time_stamp() + memSpec->getCommandLength(command) - memSpec->tCK;
 
     if (command == Command::ACT || command == Command::REFB)
     {
         if (last4Activates[rank.ID()].size() == 4)
             last4Activates[rank.ID()].pop();
-        last4Activates[rank.ID()].push(sc_time_stamp());
+        last4Activates[rank.ID()].push(lastCommandOnBus);
     }
 }
diff --git a/DRAMSys/traceAnalyzer/businessObjects/phases/phasefactory.cpp b/DRAMSys/traceAnalyzer/businessObjects/phases/phasefactory.cpp
index f11e2072..9156a5d8 100644
--- a/DRAMSys/traceAnalyzer/businessObjects/phases/phasefactory.cpp
+++ b/DRAMSys/traceAnalyzer/businessObjects/phases/phasefactory.cpp
@@ -60,49 +60,49 @@ shared_ptr<Phase> PhaseFactory::CreatePhase(ID id, const QString &dbPhaseName,
                 {Timespan(span.Begin(), span.Begin() + clk)}, std::shared_ptr<Timespan>()));
     else if (dbPhaseName == "PRE")
         return shared_ptr<Phase>(new PRE(id, span, trans,
-                {Timespan(span.Begin() - clk * (cl.PRE - 1), span.Begin() + clk)}, std::shared_ptr<Timespan>()));
+                {Timespan(span.Begin(), span.Begin() + clk * cl.PRE)}, std::shared_ptr<Timespan>()));
     else if (dbPhaseName == "ACTB")
         return shared_ptr<Phase>(new ACTB(id, span, trans,
                 {Timespan(span.Begin(), span.Begin() + clk)}, std::shared_ptr<Timespan>()));
     else if (dbPhaseName == "ACT")
         return shared_ptr<Phase>(new ACT(id, span, trans,
-                {Timespan(span.Begin() - clk * (cl.ACT - 1), span.Begin() + clk)}, std::shared_ptr<Timespan>()));
+                {Timespan(span.Begin(), span.Begin() + clk * cl.ACT)}, std::shared_ptr<Timespan>()));
     else if (dbPhaseName == "PREA")
         return shared_ptr<Phase>(new PRECHARGE_ALL(id, span, trans,
-                {Timespan(span.Begin() - clk * (cl.PREA - 1), span.Begin() + clk)}, std::shared_ptr<Timespan>()));
+                {Timespan(span.Begin(), span.Begin() + clk * cl.PREA)}, std::shared_ptr<Timespan>()));
     else if (dbPhaseName == "REFA")
         return shared_ptr<Phase>(new REFA(id, span, trans,
-                {Timespan(span.Begin() - clk * (cl.REFA - 1), span.Begin() + clk)}, std::shared_ptr<Timespan>()));
+                {Timespan(span.Begin(), span.Begin() + clk * cl.REFA)}, std::shared_ptr<Timespan>()));
     else if (dbPhaseName == "REFB")
         return shared_ptr<Phase>(new REFB(id, span, trans,
-                {Timespan(span.Begin() - clk * (cl.REFB - 1), span.Begin() + clk)}, std::shared_ptr<Timespan>()));
+                {Timespan(span.Begin(), span.Begin() + clk * cl.REFB)}, std::shared_ptr<Timespan>()));
     else if (dbPhaseName == "RD")
-        return shared_ptr<Phase>(new RD(id, span, trans, {Timespan(span.Begin() - clk * (cl.RD - 1), span.Begin() + clk)},
+        return shared_ptr<Phase>(new RD(id, span, trans, {Timespan(span.Begin(), span.Begin() + clk * cl.RD)},
                 std::shared_ptr<Timespan>(new Timespan(trans->SpanOnDataStrobe()))));
     else if (dbPhaseName == "RDA")
-        return shared_ptr<Phase>(new RDA(id, span, trans, {Timespan(span.Begin() - clk * (cl.RDA - 1), span.Begin() + clk)},
+        return shared_ptr<Phase>(new RDA(id, span, trans, {Timespan(span.Begin(), span.Begin() + clk * cl.RDA)},
                 std::shared_ptr<Timespan>(new Timespan(trans->SpanOnDataStrobe()))));
     else if (dbPhaseName == "WR")
-        return shared_ptr<Phase>(new WR(id, span, trans, {Timespan(span.Begin() - clk * (cl.WR - 1), span.Begin() + clk)},
+        return shared_ptr<Phase>(new WR(id, span, trans, {Timespan(span.Begin(), span.Begin() + clk * cl.WR)},
                 std::shared_ptr<Timespan>(new Timespan(trans->SpanOnDataStrobe()))));
     else if (dbPhaseName == "WRA")
-        return shared_ptr<Phase>(new WRA(id, span, trans, {Timespan(span.Begin() - clk * (cl.WRA - 1), span.Begin() + clk)},
+        return shared_ptr<Phase>(new WRA(id, span, trans, {Timespan(span.Begin(), span.Begin() + clk * cl.WRA)},
                 std::shared_ptr<Timespan>(new Timespan(trans->SpanOnDataStrobe()))));
     else if (dbPhaseName == "PDNA")
-        return shared_ptr<Phase>(new PDNA(id, span, trans, {Timespan(span.Begin() - clk * (cl.PDEA - 1), span.Begin() + clk),
-                Timespan(span.End() - clk * (cl.PDXA - 1), span.End() + clk)}, std::shared_ptr<Timespan>()));
+        return shared_ptr<Phase>(new PDNA(id, span, trans, {Timespan(span.Begin(), span.Begin() + clk * cl.PDEA),
+                Timespan(span.End() - clk * cl.PDXA, span.End())}, std::shared_ptr<Timespan>()));
     else if (dbPhaseName == "PDNAB")
         return shared_ptr<Phase>(new PDNAB(id, span, trans, {Timespan(span.Begin(), span.Begin() + clk),
                 Timespan(span.End() - clk, span.End())}, std::shared_ptr<Timespan>()));
     else if (dbPhaseName == "PDNP")
-        return shared_ptr<Phase>(new PDNP(id, span, trans, {Timespan(span.Begin() - clk * (cl.PDEP - 1), span.Begin() + clk),
-                Timespan(span.End() - clk * (cl.PDXP - 1), span.End() + clk)}, std::shared_ptr<Timespan>()));
+        return shared_ptr<Phase>(new PDNP(id, span, trans, {Timespan(span.Begin(), span.Begin() + clk * cl.PDEP),
+                Timespan(span.End() - clk * cl.PDXP, span.End())}, std::shared_ptr<Timespan>()));
     else if (dbPhaseName == "PDNPB")
         return shared_ptr<Phase>(new PDNPB(id, span, trans, {Timespan(span.Begin(), span.Begin() + clk),
                 Timespan(span.End() - clk, span.End())}, std::shared_ptr<Timespan>()));
     else if (dbPhaseName == "SREF")
-        return shared_ptr<Phase>(new SREF(id, span, trans, {Timespan(span.Begin() - clk * (cl.SREFEN - 1), span.Begin() + clk),
-                Timespan(span.End() - clk * (cl.SREFEX - 1), span.End() + clk)}, std::shared_ptr<Timespan>()));
+        return shared_ptr<Phase>(new SREF(id, span, trans, {Timespan(span.Begin(), span.Begin() + clk * cl.SREFEN),
+                Timespan(span.End() - clk * cl.SREFEX, span.End())}, std::shared_ptr<Timespan>()));
     else if (dbPhaseName == "SREFB")
         return shared_ptr<Phase>(new SREFB(id, span, trans, {Timespan(span.Begin(), span.Begin() + clk),
                 Timespan(span.End() - clk, span.End())}, std::shared_ptr<Timespan>()));