diff --git a/extensions/standards/DDR5/DRAMSys/configuration/memspec/MemSpecDDR5.cpp b/extensions/standards/DDR5/DRAMSys/configuration/memspec/MemSpecDDR5.cpp
index 8dbb787d..950c7cfc 100644
--- a/extensions/standards/DDR5/DRAMSys/configuration/memspec/MemSpecDDR5.cpp
+++ b/extensions/standards/DDR5/DRAMSys/configuration/memspec/MemSpecDDR5.cpp
@@ -46,9 +46,8 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpecDDR5::MemSpecDDR5(const DRAMSys::Config::MemSpec& memSpec) :
+MemSpecDDR5::MemSpecDDR5(const Config::MemSpec& memSpec) :
     MemSpec(memSpec,
-            MemoryType::DDR5,
             memSpec.memarchitecturespec.entries.at("nbrOfChannels"),
             1,
             memSpec.memarchitecturespec.entries.at("nbrOfRanks"),
diff --git a/extensions/standards/DDR5/DRAMSys/configuration/memspec/MemSpecDDR5.h b/extensions/standards/DDR5/DRAMSys/configuration/memspec/MemSpecDDR5.h
index 438beca6..9546eb92 100644
--- a/extensions/standards/DDR5/DRAMSys/configuration/memspec/MemSpecDDR5.h
+++ b/extensions/standards/DDR5/DRAMSys/configuration/memspec/MemSpecDDR5.h
@@ -46,7 +46,7 @@ namespace DRAMSys
 class MemSpecDDR5 final : public MemSpec
 {
 public:
-    explicit MemSpecDDR5(const DRAMSys::Config::MemSpec& memSpec);
+    explicit MemSpecDDR5(const Config::MemSpec& memSpec);
 
     const unsigned dimmRanksPerChannel;
     const unsigned physicalRanksPerDimmRank;
diff --git a/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.cpp b/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.cpp
index 88864358..6a5c9c96 100644
--- a/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.cpp
+++ b/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.cpp
@@ -44,92 +44,89 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-CheckerDDR5::CheckerDDR5(const Configuration& config)
+CheckerDDR5::CheckerDDR5(const MemSpecDDR5& memSpec)
+    : memSpec(memSpec)
 {
-    memSpec = dynamic_cast<const MemSpecDDR5*>(config.memSpec.get());
-    if (memSpec == nullptr)
-        SC_REPORT_FATAL("CheckerDDR5", "Wrong MemSpec chosen");
-
     lastScheduledByCommandAndDimmRank = std::vector<ControllerVector<DimmRank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<DimmRank, sc_time>(memSpec->dimmRanksPerChannel, scMaxTime));
+        ControllerVector<DimmRank, sc_time>(memSpec.dimmRanksPerChannel, scMaxTime));
     lastScheduledByCommandAndPhysicalRank = std::vector<ControllerVector<PhysicalRank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<PhysicalRank, sc_time>(memSpec->physicalRanksPerChannel, scMaxTime));
+        ControllerVector<PhysicalRank, sc_time>(memSpec.physicalRanksPerChannel, scMaxTime));
     lastScheduledByCommandAndLogicalRank = std::vector<ControllerVector<LogicalRank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<LogicalRank, sc_time>(memSpec->logicalRanksPerChannel, scMaxTime));
+        ControllerVector<LogicalRank, sc_time>(memSpec.logicalRanksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<BankGroup, sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
+        ControllerVector<BankGroup, sc_time>(memSpec.bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
+        ControllerVector<Bank, sc_time>(memSpec.banksPerChannel, scMaxTime));
     lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
     // Required for Same Bank Refresh
     lastScheduledByCommandAndBankInGroup = std::vector<ControllerVector<Bank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Bank, sc_time>(memSpec->ranksPerChannel * memSpec->banksPerGroup,
+        ControllerVector<Bank, sc_time>(memSpec.ranksPerChannel * memSpec.banksPerGroup,
                                         scMaxTime));
     lastCommandOnBus = scMaxTime;
     dummyCommandOnBus.start = scMaxTime;
     dummyCommandOnBus.end = scMaxTime;
 
     last4ActivatesLogical =
-        ControllerVector<LogicalRank, std::queue<sc_time>>(memSpec->logicalRanksPerChannel);
+        ControllerVector<LogicalRank, std::queue<sc_time>>(memSpec.logicalRanksPerChannel);
     last4ActivatesPhysical =
-        ControllerVector<PhysicalRank, std::queue<sc_time>>(memSpec->physicalRanksPerChannel);
+        ControllerVector<PhysicalRank, std::queue<sc_time>>(memSpec.physicalRanksPerChannel);
 
     lastBurstLengthByCommandAndDimmRank = std::vector<ControllerVector<DimmRank, uint8_t>>(
-        Command::WRA + 1, ControllerVector<DimmRank, uint8_t>(memSpec->dimmRanksPerChannel));
+        Command::WRA + 1, ControllerVector<DimmRank, uint8_t>(memSpec.dimmRanksPerChannel));
     lastBurstLengthByCommandAndPhysicalRank = std::vector<ControllerVector<PhysicalRank, uint8_t>>(
         Command::WRA + 1,
-        ControllerVector<PhysicalRank, uint8_t>(memSpec->physicalRanksPerChannel));
+        ControllerVector<PhysicalRank, uint8_t>(memSpec.physicalRanksPerChannel));
     lastBurstLengthByCommandAndLogicalRank = std::vector<ControllerVector<LogicalRank, uint8_t>>(
-        Command::WRA + 1, ControllerVector<LogicalRank, uint8_t>(memSpec->logicalRanksPerChannel));
+        Command::WRA + 1, ControllerVector<LogicalRank, uint8_t>(memSpec.logicalRanksPerChannel));
     lastBurstLengthByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, uint8_t>>(
-        Command::WRA + 1, ControllerVector<BankGroup, uint8_t>(memSpec->bankGroupsPerChannel));
+        Command::WRA + 1, ControllerVector<BankGroup, uint8_t>(memSpec.bankGroupsPerChannel));
     lastBurstLengthByCommandAndBank = std::vector<ControllerVector<Bank, uint8_t>>(
-        Command::WRA + 1, ControllerVector<Bank, uint8_t>(memSpec->banksPerChannel));
+        Command::WRA + 1, ControllerVector<Bank, uint8_t>(memSpec.banksPerChannel));
     lastBurstLengthByCommand = std::vector<uint8_t>(Command::WRA + 1);
     lastBurstLengthByCommandAndBankInGroup = std::vector<ControllerVector<Bank, uint8_t>>(
         Command::WRA + 1,
-        ControllerVector<Bank, uint8_t>(memSpec->ranksPerChannel * memSpec->banksPerGroup));
+        ControllerVector<Bank, uint8_t>(memSpec.ranksPerChannel * memSpec.banksPerGroup));
 
-    cmdLengthDiff = memSpec->cmdMode * memSpec->tCK;
+    cmdLengthDiff = memSpec.cmdMode * memSpec.tCK;
 
-    tBURST16 = 8 * memSpec->tCK;
-    tBURST32 = 16 * memSpec->tCK;
-    tWTRA = memSpec->tWR - memSpec->tRTP;
-    tWRRDA = memSpec->tWL + tBURST16 + tWTRA; // tWTRA = tWR - tRTP
-    tWRPRE = memSpec->tWL + tBURST16 + memSpec->tWR;
-    tRDAACT = memSpec->tRTP + memSpec->tRP;
-    tWRAACT = tWRPRE + memSpec->tRP;
-    tCCD_L_RTW_slr = memSpec->tRL - memSpec->tWL + tBURST16 + 2 * memSpec->tCK - memSpec->tRDDQS +
-                     memSpec->tRPST + memSpec->tWPRE;
-    tCCD_S_RTW_slr = memSpec->tRL - memSpec->tWL + tBURST16 + 2 * memSpec->tCK - memSpec->tRDDQS +
-                     memSpec->tRPST + memSpec->tWPRE;
-    tCCD_RTW_dlr = memSpec->tRL - memSpec->tWL + tBURST16 + 2 * memSpec->tCK - memSpec->tRDDQS +
-                   memSpec->tRPST + memSpec->tWPRE;
-    tRDRD_dpr = tBURST16 + memSpec->tRTRS;
-    tRDRD_ddr = tBURST16 + memSpec->tRTRS;
-    tRDWR_dpr = memSpec->tRL - memSpec->tWL + tBURST16 + memSpec->tRTRS - memSpec->tRDDQS +
-                memSpec->tRPST + memSpec->tWPRE;
-    tRDWR_ddr = memSpec->tRL - memSpec->tWL + tBURST16 + memSpec->tRTRS - memSpec->tRDDQS +
-                memSpec->tRPST + memSpec->tWPRE;
-    tCCD_L_WTR_slr = memSpec->tWL + tBURST16 + memSpec->tWTR_L;
-    tCCD_M_WTR_slr = memSpec->tWL + tBURST16 + memSpec->tWTR_M; // tWTR_M is max(16nck, 10ns)
-    tCCD_S_WTR_slr = memSpec->tWL + tBURST16 + memSpec->tWTR_S;
-    tCCD_WTR_dlr = memSpec->tWL + tBURST16 + memSpec->tWTR_S;
-    tWRWR_dpr = std::max(memSpec->tCCD_WR_dpr, tBURST16 + memSpec->tRTRS);
-    tWRWR_ddr = tBURST16 + memSpec->tRTRS;
-    tWRRD_dpr = memSpec->tWL - memSpec->tRL + tBURST16 + memSpec->tRTRS + memSpec->tRDDQS +
-                memSpec->tWPST + memSpec->tRPRE;
-    tWRRD_ddr = memSpec->tWL - memSpec->tRL + tBURST16 + memSpec->tRTRS + memSpec->tRDDQS +
-                memSpec->tWPST + memSpec->tRPRE;
-    tRDPDEN = memSpec->tRL + tBURST16 + cmdLengthDiff;
-    tWRPDEN = memSpec->tWL + tBURST16 + memSpec->tWR + cmdLengthDiff;
-    tWRAPDEN = memSpec->tWL + tBURST16 + memSpec->tWR + cmdLengthDiff;
+    tBURST16 = 8 * memSpec.tCK;
+    tBURST32 = 16 * memSpec.tCK;
+    tWTRA = memSpec.tWR - memSpec.tRTP;
+    tWRRDA = memSpec.tWL + tBURST16 + tWTRA; // tWTRA = tWR - tRTP
+    tWRPRE = memSpec.tWL + tBURST16 + memSpec.tWR;
+    tRDAACT = memSpec.tRTP + memSpec.tRP;
+    tWRAACT = tWRPRE + memSpec.tRP;
+    tCCD_L_RTW_slr = memSpec.tRL - memSpec.tWL + tBURST16 + 2 * memSpec.tCK - memSpec.tRDDQS +
+                     memSpec.tRPST + memSpec.tWPRE;
+    tCCD_S_RTW_slr = memSpec.tRL - memSpec.tWL + tBURST16 + 2 * memSpec.tCK - memSpec.tRDDQS +
+                     memSpec.tRPST + memSpec.tWPRE;
+    tCCD_RTW_dlr = memSpec.tRL - memSpec.tWL + tBURST16 + 2 * memSpec.tCK - memSpec.tRDDQS +
+                   memSpec.tRPST + memSpec.tWPRE;
+    tRDRD_dpr = tBURST16 + memSpec.tRTRS;
+    tRDRD_ddr = tBURST16 + memSpec.tRTRS;
+    tRDWR_dpr = memSpec.tRL - memSpec.tWL + tBURST16 + memSpec.tRTRS - memSpec.tRDDQS +
+                memSpec.tRPST + memSpec.tWPRE;
+    tRDWR_ddr = memSpec.tRL - memSpec.tWL + tBURST16 + memSpec.tRTRS - memSpec.tRDDQS +
+                memSpec.tRPST + memSpec.tWPRE;
+    tCCD_L_WTR_slr = memSpec.tWL + tBURST16 + memSpec.tWTR_L;
+    tCCD_M_WTR_slr = memSpec.tWL + tBURST16 + memSpec.tWTR_M; // tWTR_M is max(16nck, 10ns)
+    tCCD_S_WTR_slr = memSpec.tWL + tBURST16 + memSpec.tWTR_S;
+    tCCD_WTR_dlr = memSpec.tWL + tBURST16 + memSpec.tWTR_S;
+    tWRWR_dpr = std::max(memSpec.tCCD_WR_dpr, tBURST16 + memSpec.tRTRS);
+    tWRWR_ddr = tBURST16 + memSpec.tRTRS;
+    tWRRD_dpr = memSpec.tWL - memSpec.tRL + tBURST16 + memSpec.tRTRS + memSpec.tRDDQS +
+                memSpec.tWPST + memSpec.tRPRE;
+    tWRRD_ddr = memSpec.tWL - memSpec.tRL + tBURST16 + memSpec.tRTRS + memSpec.tRDDQS +
+                memSpec.tWPST + memSpec.tRPRE;
+    tRDPDEN = memSpec.tRL + tBURST16 + cmdLengthDiff;
+    tWRPDEN = memSpec.tWL + tBURST16 + memSpec.tWR + cmdLengthDiff;
+    tWRAPDEN = memSpec.tWL + tBURST16 + memSpec.tWR + cmdLengthDiff;
 }
 
 sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
@@ -137,13 +134,13 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
 {
     LogicalRank logicalRank = LogicalRank(ControllerExtension::getRank(payload));
     PhysicalRank physicalRank =
-        PhysicalRank(static_cast<std::size_t>(logicalRank) / memSpec->logicalRanksPerPhysicalRank);
+        PhysicalRank(static_cast<std::size_t>(logicalRank) / memSpec.logicalRanksPerPhysicalRank);
     DimmRank dimmRank =
-        DimmRank(static_cast<std::size_t>(physicalRank) / memSpec->physicalRanksPerDimmRank);
+        DimmRank(static_cast<std::size_t>(physicalRank) / memSpec.physicalRanksPerDimmRank);
     BankGroup bankGroup = ControllerExtension::getBankGroup(payload);
     Bank bank = ControllerExtension::getBank(payload);
-    Bank bankInGroup = Bank(static_cast<std::size_t>(logicalRank) * memSpec->banksPerGroup +
-                            static_cast<std::size_t>(bank) % memSpec->banksPerGroup);
+    Bank bankInGroup = Bank(static_cast<std::size_t>(logicalRank) * memSpec.banksPerGroup +
+                            static_cast<std::size_t>(bank) % memSpec.banksPerGroup);
 
     sc_time lastCommandStart;
     sc_time earliestTimeToStart = sc_time_stamp();
@@ -152,27 +149,27 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
         assert((burstLength == 16) || (burstLength == 32));
-        assert(!(burstLength == 32) || (memSpec->bitWidth == 4));
-        assert(burstLength <= memSpec->maxBurstLength);
+        assert(!(burstLength == 32) || (memSpec.bitWidth == 4));
+        assert(burstLength <= memSpec.maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_L_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L_slr);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_M_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_M_slr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RD][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RD][physicalRank];
         if (lastCommandStart != scMaxTime)
@@ -181,7 +178,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST32);
 
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_dlr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_dlr);
         }
 
         lastCommandStart = lastScheduledByCommand[Command::RD];
@@ -213,12 +210,12 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_M_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_M_slr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RDA][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RDA][physicalRank];
         if (lastCommandStart != scMaxTime)
@@ -227,7 +224,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST32);
 
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_dlr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_dlr);
         }
 
         lastCommandStart = lastScheduledByCommand[Command::RDA];
@@ -403,12 +400,12 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
         assert((burstLength == 16) || (burstLength == 32));
-        assert(!(burstLength == 32) || (memSpec->bitWidth == 4));
-        assert(burstLength <= memSpec->maxBurstLength);
+        assert(!(burstLength == 32) || (memSpec.bitWidth == 4));
+        assert(burstLength <= memSpec.maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
         if (lastCommandStart != scMaxTime)
@@ -528,7 +525,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
             }
         }
 
-        if (memSpec->requiresMaskedWrite(payload)) // second WR requires RMW
+        if (memSpec.requiresMaskedWrite(payload)) // second WR requires RMW
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
             if (lastCommandStart != scMaxTime)
@@ -536,12 +533,12 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
                 if (lastBurstLengthByCommandAndBank[Command::WR][bank] == 32)
                 {
                     earliestTimeToStart = std::max(
-                        earliestTimeToStart, lastCommandStart + tBURST16 + memSpec->tCCD_L_WR_slr);
+                        earliestTimeToStart, lastCommandStart + tBURST16 + memSpec.tCCD_L_WR_slr);
                 }
                 else
                 {
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_L_WR_slr);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L_WR_slr);
                 }
             }
 
@@ -552,12 +549,12 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
                 if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup] == 32)
                 {
                     earliestTimeToStart = std::max(
-                        earliestTimeToStart, lastCommandStart + tBURST16 + memSpec->tCCD_M_WR_slr);
+                        earliestTimeToStart, lastCommandStart + tBURST16 + memSpec.tCCD_M_WR_slr);
                 }
                 else
                 {
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_M_WR_slr);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_M_WR_slr);
                 }
             }
         }
@@ -569,12 +566,12 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
                 if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup] == 32)
                 {
                     earliestTimeToStart = std::max(
-                        earliestTimeToStart, lastCommandStart + tBURST16 + memSpec->tCCD_L_WR2_slr);
+                        earliestTimeToStart, lastCommandStart + tBURST16 + memSpec.tCCD_L_WR2_slr);
                 }
                 else
                 {
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_L_WR2_slr);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L_WR2_slr);
                 }
             }
         }
@@ -582,7 +579,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WR][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S_WR_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S_WR_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::WR][physicalRank];
         if (lastCommandStart != scMaxTime)
@@ -591,7 +588,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST32);
 
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_WR_dlr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_WR_dlr);
         }
 
         lastCommandStart = lastScheduledByCommand[Command::WR];
@@ -620,7 +617,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
             }
         }
 
-        if (memSpec->requiresMaskedWrite(payload)) // second WR requires RMW
+        if (memSpec.requiresMaskedWrite(payload)) // second WR requires RMW
         {
             lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
             if (lastCommandStart != scMaxTime)
@@ -628,12 +625,12 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
                 if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup] == 32)
                 {
                     earliestTimeToStart = std::max(
-                        earliestTimeToStart, lastCommandStart + tBURST16 + memSpec->tCCD_M_WR_slr);
+                        earliestTimeToStart, lastCommandStart + tBURST16 + memSpec.tCCD_M_WR_slr);
                 }
                 else
                 {
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_M_WR_slr);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_M_WR_slr);
                 }
             }
         }
@@ -645,12 +642,12 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
                 if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup] == 32)
                 {
                     earliestTimeToStart = std::max(
-                        earliestTimeToStart, lastCommandStart + tBURST16 + memSpec->tCCD_L_WR2_slr);
+                        earliestTimeToStart, lastCommandStart + tBURST16 + memSpec.tCCD_L_WR2_slr);
                 }
                 else
                 {
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_L_WR2_slr);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L_WR2_slr);
                 }
             }
         }
@@ -658,7 +655,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WRA][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S_WR_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S_WR_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::WRA][physicalRank];
         if (lastCommandStart != scMaxTime)
@@ -667,7 +664,7 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
                 earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + tBURST32);
 
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_WR_dlr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_WR_dlr);
         }
 
         lastCommandStart = lastScheduledByCommand[Command::WRA];
@@ -700,22 +697,22 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD_L_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD_L_slr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::ACT][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD_S_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD_S_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::ACT][physicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD_dlr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD_dlr);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
@@ -734,83 +731,83 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::PREAB][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::PRESB][bankInGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFAB][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_slr - cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_slr - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMAB][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_slr - cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_slr - cmdLengthDiff);
 
         // TODO: No tRFC_dlr and tRFC_dpr between REFAB and ACT?
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::REFSB][bankInGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart,
-                                           lastCommandStart + memSpec->tRFCsb_slr - cmdLengthDiff);
+                                           lastCommandStart + memSpec.tRFCsb_slr - cmdLengthDiff);
 
         // TODO: No tRFCsb_dlr between REFSB and ACT?
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFSB][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, lastCommandStart + memSpec->tREFSBRD_slr - cmdLengthDiff);
+                earliestTimeToStart, lastCommandStart + memSpec.tREFSBRD_slr - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::REFSB][physicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, lastCommandStart + memSpec->tREFSBRD_dlr - cmdLengthDiff);
+                earliestTimeToStart, lastCommandStart + memSpec.tREFSBRD_dlr - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::RFMSB][bankInGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart,
-                                           lastCommandStart + memSpec->tRFCsb_slr - cmdLengthDiff);
+                                           lastCommandStart + memSpec.tRFCsb_slr - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMSB][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, lastCommandStart + memSpec->tREFSBRD_slr - cmdLengthDiff);
+                earliestTimeToStart, lastCommandStart + memSpec.tREFSBRD_slr - cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RFMSB][physicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, lastCommandStart + memSpec->tREFSBRD_dlr - cmdLengthDiff);
+                earliestTimeToStart, lastCommandStart + memSpec.tREFSBRD_dlr - cmdLengthDiff);
 
         if (last4ActivatesLogical[logicalRank].size() >= 4)
             earliestTimeToStart = std::max(earliestTimeToStart,
                                            last4ActivatesLogical[logicalRank].front() +
-                                               memSpec->tFAW_slr - memSpec->longCmdOffset);
+                                               memSpec.tFAW_slr - memSpec.longCmdOffset);
 
         if (last4ActivatesPhysical[physicalRank].size() >= 4)
             earliestTimeToStart = std::max(earliestTimeToStart,
                                            last4ActivatesPhysical[physicalRank].front() +
-                                               memSpec->tFAW_dlr - memSpec->longCmdOffset);
+                                               memSpec.tFAW_dlr - memSpec.longCmdOffset);
     }
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
         if (lastCommandStart != scMaxTime)
@@ -825,32 +822,32 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREPB][physicalRank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREAB][physicalRank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PRESB][physicalRank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::ACT][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RD][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RDA][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::WR][logicalRank];
         if (lastCommandStart != scMaxTime)
@@ -876,11 +873,11 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREPB][physicalRank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREAB][physicalRank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         // PRESB tPPD
     }
@@ -889,17 +886,17 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::ACT][bankInGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::RD][bankInGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::RDA][bankInGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::WR][bankInGroup];
         if (lastCommandStart != scMaxTime)
@@ -925,20 +922,20 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PREPB][physicalRank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         // PREA tRP
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::PRESB][physicalRank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
     }
     else if (command == Command::REFAB || command == Command::RFMAB)
     {
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::ACT][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RDA][physicalRank];
         if (lastCommandStart != scMaxTime)
@@ -951,49 +948,49 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndLogicalRank[Command::WRA][logicalRank] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + tWRPRE + tBURST16 + memSpec->tRP + cmdLengthDiff);
+                             lastCommandStart + tWRPRE + tBURST16 + memSpec.tRP + cmdLengthDiff);
             else
                 earliestTimeToStart = std::max(
-                    earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP + cmdLengthDiff);
+                    earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP + cmdLengthDiff);
         }
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::PREPB][logicalRank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::PREAB][logicalRank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFAB][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::REFAB][physicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dlr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dlr);
 
         lastCommandStart = lastScheduledByCommandAndDimmRank[Command::REFAB][dimmRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dpr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dpr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMAB][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RFMAB][physicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dlr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dlr);
 
         lastCommandStart = lastScheduledByCommandAndDimmRank[Command::RFMAB][dimmRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dpr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dpr);
 
         // REFSB tRFCsb_slr/dlr
         // PRESB tRP
@@ -1003,12 +1000,12 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::ACT][bankInGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + cmdLengthDiff);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::ACT][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart,
-                                           lastCommandStart + memSpec->tRRD_L_slr + cmdLengthDiff);
+                                           lastCommandStart + memSpec.tRRD_L_slr + cmdLengthDiff);
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::RDA][bankInGroup];
         if (lastCommandStart != scMaxTime)
@@ -1028,88 +1025,88 @@ sc_time CheckerDDR5::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::PREPB][bankInGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         // PREA tRP
 
         lastCommandStart = lastScheduledByCommandAndBankInGroup[Command::PRESB][bankInGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFAB][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_slr);
 
         // TODO: check this
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::REFAB][physicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dlr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dlr);
 
         // TODO: check this
         lastCommandStart = lastScheduledByCommandAndDimmRank[Command::REFAB][dimmRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dpr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dpr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMAB][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_slr);
 
         // TODO: check this
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RFMAB][physicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dlr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dlr);
 
         // TODO: check this
         lastCommandStart = lastScheduledByCommandAndDimmRank[Command::RFMAB][dimmRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC_dpr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC_dpr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::REFSB][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCsb_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCsb_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::REFSB][physicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCsb_dlr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCsb_dlr);
 
         lastCommandStart = lastScheduledByCommandAndLogicalRank[Command::RFMSB][logicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCsb_slr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCsb_slr);
 
         lastCommandStart = lastScheduledByCommandAndPhysicalRank[Command::RFMSB][physicalRank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCsb_dlr);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCsb_dlr);
 
         if (last4ActivatesLogical[logicalRank].size() >= 4)
             earliestTimeToStart = std::max(earliestTimeToStart,
                                            last4ActivatesLogical[logicalRank].front() +
-                                               memSpec->tFAW_slr - memSpec->shortCmdOffset);
+                                               memSpec.tFAW_slr - memSpec.shortCmdOffset);
 
         if (last4ActivatesPhysical[physicalRank].size() >= 4)
             earliestTimeToStart = std::max(earliestTimeToStart,
                                            last4ActivatesPhysical[physicalRank].front() +
-                                               memSpec->tFAW_dlr - memSpec->shortCmdOffset);
+                                               memSpec.tFAW_dlr - memSpec.shortCmdOffset);
     }
     else
         SC_REPORT_FATAL("CheckerDDR5", "Unknown command!");
 
     if (lastCommandOnBus != scMaxTime)
-        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK);
 
     if (dummyCommandOnBus.start != scMaxTime)
     {
         TimeInterval currentCommandOnBus(earliestTimeToStart,
-                                         earliestTimeToStart + memSpec->getCommandLength(command));
+                                         earliestTimeToStart + memSpec.getCommandLength(command));
         if (currentCommandOnBus.intersects(dummyCommandOnBus))
             earliestTimeToStart = dummyCommandOnBus.end;
     }
@@ -1121,13 +1118,13 @@ void CheckerDDR5::insert(Command command, const tlm_generic_payload& payload)
 {
     LogicalRank logicalRank = LogicalRank(ControllerExtension::getRank(payload));
     PhysicalRank physicalRank =
-        PhysicalRank(static_cast<std::size_t>(logicalRank) / memSpec->logicalRanksPerPhysicalRank);
+        PhysicalRank(static_cast<std::size_t>(logicalRank) / memSpec.logicalRanksPerPhysicalRank);
     DimmRank dimmRank =
-        DimmRank(static_cast<std::size_t>(physicalRank) / memSpec->physicalRanksPerDimmRank);
+        DimmRank(static_cast<std::size_t>(physicalRank) / memSpec.physicalRanksPerDimmRank);
     BankGroup bankGroup = ControllerExtension::getBankGroup(payload);
     Bank bank = ControllerExtension::getBank(payload);
-    Bank bankInGroup = Bank(static_cast<std::size_t>(logicalRank) * memSpec->banksPerGroup +
-                            static_cast<std::size_t>(bank) % memSpec->banksPerGroup);
+    Bank bankInGroup = Bank(static_cast<std::size_t>(logicalRank) * memSpec.banksPerGroup +
+                            static_cast<std::size_t>(bank) % memSpec.banksPerGroup);
     unsigned burstLength = ControllerExtension::getBurstLength(payload);
 
     // Hack: Convert MWR to WR and MWRA to WRA
@@ -1161,11 +1158,11 @@ void CheckerDDR5::insert(Command command, const tlm_generic_payload& payload)
         if (burstLength == 32)
         {
             dummyCommandOnBus.start = sc_time_stamp() + tBURST16;
-            dummyCommandOnBus.end = sc_time_stamp() + tBURST16 + memSpec->getCommandLength(command);
+            dummyCommandOnBus.end = sc_time_stamp() + tBURST16 + memSpec.getCommandLength(command);
         }
     }
 
-    lastCommandOnBus = sc_time_stamp() + memSpec->getCommandLength(command) - memSpec->tCK;
+    lastCommandOnBus = sc_time_stamp() + memSpec.getCommandLength(command) - memSpec.tCK;
 
     if (command == Command::ACT || command == Command::REFSB || command == Command::RFMSB)
     {
diff --git a/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.h b/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.h
index 68aa6d75..ac069d0c 100644
--- a/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.h
+++ b/extensions/standards/DDR5/DRAMSys/controller/checker/CheckerDDR5.h
@@ -41,7 +41,6 @@
 #include <DRAMSys/controller/checker/CheckerIF.h>
 
 #include <DRAMSys/common/utils.h>
-#include <DRAMSys/configuration/Configuration.h>
 #include <DRAMSys/configuration/memspec/MemSpecDDR5.h>
 
 namespace DRAMSys
@@ -50,14 +49,14 @@ namespace DRAMSys
 class CheckerDDR5 final : public CheckerIF
 {
 public:
-    explicit CheckerDDR5(const Configuration& config);
+    explicit CheckerDDR5(const MemSpecDDR5& memSpec);
     sc_core::sc_time
     timeToSatisfyConstraints(Command command,
                              const tlm::tlm_generic_payload& payload) const override;
     void insert(Command command, const tlm::tlm_generic_payload& payload) override;
 
 private:
-    const MemSpecDDR5* memSpec;
+    const MemSpecDDR5& memSpec;
 
     std::vector<ControllerVector<DimmRank, sc_core::sc_time>> lastScheduledByCommandAndDimmRank;
     std::vector<ControllerVector<PhysicalRank, sc_core::sc_time>>
diff --git a/extensions/standards/HBM3/DRAMSys/configuration/memspec/MemSpecHBM3.cpp b/extensions/standards/HBM3/DRAMSys/configuration/memspec/MemSpecHBM3.cpp
index 21237812..255e43ba 100644
--- a/extensions/standards/HBM3/DRAMSys/configuration/memspec/MemSpecHBM3.cpp
+++ b/extensions/standards/HBM3/DRAMSys/configuration/memspec/MemSpecHBM3.cpp
@@ -45,9 +45,8 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpecHBM3::MemSpecHBM3(const DRAMSys::Config::MemSpec& memSpec) :
+MemSpecHBM3::MemSpecHBM3(const Config::MemSpec& memSpec) :
     MemSpec(memSpec,
-            MemoryType::HBM3,
             memSpec.memarchitecturespec.entries.at("nbrOfChannels"),
             memSpec.memarchitecturespec.entries.at("nbrOfPseudoChannels"),
             memSpec.memarchitecturespec.entries.at("nbrOfPseudoChannels"),
diff --git a/extensions/standards/HBM3/DRAMSys/configuration/memspec/MemSpecHBM3.h b/extensions/standards/HBM3/DRAMSys/configuration/memspec/MemSpecHBM3.h
index 9c35964a..1f0d31fc 100644
--- a/extensions/standards/HBM3/DRAMSys/configuration/memspec/MemSpecHBM3.h
+++ b/extensions/standards/HBM3/DRAMSys/configuration/memspec/MemSpecHBM3.h
@@ -46,7 +46,7 @@ namespace DRAMSys
 class MemSpecHBM3 final : public MemSpec
 {
 public:
-    explicit MemSpecHBM3(const DRAMSys::Config::MemSpec& memSpec);
+    explicit MemSpecHBM3(const Config::MemSpec& memSpec);
 
     const unsigned RAAIMT;
     const unsigned RAAMMT;
diff --git a/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.cpp b/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.cpp
index 0f78ef8b..c262bedf 100644
--- a/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.cpp
+++ b/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.cpp
@@ -44,35 +44,32 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-CheckerHBM3::CheckerHBM3(const Configuration& config)
+CheckerHBM3::CheckerHBM3(const MemSpecHBM3& memSpec)
+    : memSpec(memSpec)
 {
-    memSpec = dynamic_cast<const MemSpecHBM3*>(config.memSpec.get());
-    if (memSpec == nullptr)
-        SC_REPORT_FATAL("CheckerHBM3", "Wrong MemSpec chosen");
-
     lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
+        ControllerVector<Bank, sc_time>(memSpec.banksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<BankGroup, sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
+        ControllerVector<BankGroup, sc_time>(memSpec.bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
+        ControllerVector<Rank, sc_time>(memSpec.ranksPerChannel, scMaxTime));
     lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
     lastCommandOnRasBus = scMaxTime;
     lastCommandOnCasBus = scMaxTime;
-    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
+    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec.ranksPerChannel);
 
-    bankwiseRefreshCounter = ControllerVector<Rank, unsigned>(memSpec->ranksPerChannel);
+    bankwiseRefreshCounter = ControllerVector<Rank, unsigned>(memSpec.ranksPerChannel);
 
-    tRDPDE = memSpec->tRL + memSpec->tPL + 2 * memSpec->tCK;
-    tRDSRE = memSpec->tRL + memSpec->tPL + 3 * memSpec->tCK;
-    tWRPRE = memSpec->tWL + 2 * memSpec->tCK + memSpec->tWR;
-    tWRPDE = memSpec->tWL + memSpec->tPL + 3 * memSpec->tCK + memSpec->tWR;
-    tWRAPDE = memSpec->tWL + memSpec->tPL + 3 * memSpec->tCK + memSpec->tWR;
-    tWRRDS = memSpec->tWL + 2 * memSpec->tCK + memSpec->tWTRS;
-    tWRRDL = memSpec->tWL + 2 * memSpec->tCK + memSpec->tWTRL;
+    tRDPDE = memSpec.tRL + memSpec.tPL + 2 * memSpec.tCK;
+    tRDSRE = memSpec.tRL + memSpec.tPL + 3 * memSpec.tCK;
+    tWRPRE = memSpec.tWL + 2 * memSpec.tCK + memSpec.tWR;
+    tWRPDE = memSpec.tWL + memSpec.tPL + 3 * memSpec.tCK + memSpec.tWR;
+    tWRAPDE = memSpec.tWL + memSpec.tPL + 3 * memSpec.tCK + memSpec.tWR;
+    tWRRDS = memSpec.tWL + 2 * memSpec.tCK + memSpec.tWTRS;
+    tWRRDL = memSpec.tWL + 2 * memSpec.tCK + memSpec.tWTRL;
 }
 
 sc_time CheckerHBM3::timeToSatisfyConstraints(Command command,
@@ -90,11 +87,11 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
         if (lastCommandStart != scMaxTime)
@@ -102,42 +99,42 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         if (lastCommandOnRasBus != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK / 2);
+                std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK / 2);
     }
     else if (command == Command::RD)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDRD + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
         if (lastCommandStart != scMaxTime)
@@ -157,78 +154,78 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         if (lastCommandOnCasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec.tCK);
     }
     else if (command == Command::WR)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDWR + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         if (lastCommandOnCasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec.tCK);
     }
     else if (command == Command::RDA)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDRD + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + memSpec->tWL + 2 * memSpec->tCK +
-                             std::max(memSpec->tWR - memSpec->tRTP, memSpec->tWTRL));
+                         lastCommandStart + memSpec.tWL + 2 * memSpec.tCK +
+                             std::max(memSpec.tWR - memSpec.tRTP, memSpec.tWTRL));
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
         if (lastCommandStart != scMaxTime)
@@ -248,205 +245,205 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         if (lastCommandOnCasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec.tCK);
     }
     else if (command == Command::WRA)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDWR + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         if (lastCommandOnCasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec.tCK);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + memSpec->tRTP + memSpec->tRP - memSpec->tCK);
+                         lastCommandStart + memSpec.tRTP + memSpec.tRP - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart,
-                                           lastCommandStart + tWRPRE + memSpec->tRP - memSpec->tCK);
+                                           lastCommandStart + tWRPRE + memSpec.tRP - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::REFPB][bankGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS - memSpec.tCK);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
 
         if (lastCommandOnRasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         if (lastCommandOnRasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
@@ -458,227 +455,227 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         if (lastCommandOnRasBus != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK / 2);
+                std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK / 2);
     }
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
         {
             if (bankwiseRefreshCounter[rank] == 0)
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
             else
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD);
         }
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
 
         if (lastCommandOnRasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + std::max(memSpec->tRTP + memSpec->tRP, tRDSRE));
+                         lastCommandStart + std::max(memSpec.tRTP + memSpec.tRP, tRDSRE));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         if (lastCommandOnRasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK);
     }
     else if (command == Command::RFMAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         if (lastCommandOnRasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK);
     }
     else if (command == Command::RFMAB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RFMPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RFMPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD);
 
         if (lastCommandOnRasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK);
     }
     else if (command == Command::PDEA)
     {
@@ -700,10 +697,10 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
 
         if (lastCommandOnRasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK);
     }
     else if (command == Command::PDEP)
     {
@@ -721,41 +718,41 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         if (lastCommandOnRasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
 
         if (lastCommandOnRasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
 
         if (lastCommandOnRasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKESR);
 
         if (lastCommandOnRasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK);
     }
     else
     {
@@ -764,7 +761,7 @@ sc_time CheckerHBM3::timeToSatisfyConstraints(Command command,
 
     // Don't issue commands at half cycles.
     if (command != Command::PREAB && command != Command::PREPB && !isFullCycle(earliestTimeToStart))
-        earliestTimeToStart += memSpec->tCK / 2;
+        earliestTimeToStart += memSpec.tCK / 2;
 
     return earliestTimeToStart;
 }
@@ -787,7 +784,7 @@ void CheckerHBM3::insert(Command command, const tlm_generic_payload& payload)
     if (command.isCasCommand())
         lastCommandOnCasBus = sc_time_stamp();
     else if (command == Command::ACT)
-        lastCommandOnRasBus = sc_time_stamp() + memSpec->tCK;
+        lastCommandOnRasBus = sc_time_stamp() + memSpec.tCK;
     else
         lastCommandOnRasBus = sc_time_stamp();
 
@@ -799,13 +796,13 @@ void CheckerHBM3::insert(Command command, const tlm_generic_payload& payload)
     }
 
     if (command == Command::REFPB)
-        bankwiseRefreshCounter[rank] = (bankwiseRefreshCounter[rank] + 1) % memSpec->banksPerRank;
+        bankwiseRefreshCounter[rank] = (bankwiseRefreshCounter[rank] + 1) % memSpec.banksPerRank;
 }
 
 bool CheckerHBM3::isFullCycle(const sc_core::sc_time& time) const
 {
-    sc_time aligedAtHalfCycle = std::floor((time * 2 / memSpec->tCK + 0.5)) / 2 * memSpec->tCK;
-    return sc_time::from_value(aligedAtHalfCycle.value() % memSpec->tCK.value()) == SC_ZERO_TIME;
+    sc_time aligedAtHalfCycle = std::floor((time * 2 / memSpec.tCK + 0.5)) / 2 * memSpec.tCK;
+    return sc_time::from_value(aligedAtHalfCycle.value() % memSpec.tCK.value()) == SC_ZERO_TIME;
 }
 
 } // namespace DRAMSys
diff --git a/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.h b/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.h
index 3a6dcfa8..ff928e83 100644
--- a/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.h
+++ b/extensions/standards/HBM3/DRAMSys/controller/checker/CheckerHBM3.h
@@ -41,7 +41,6 @@
 #include <DRAMSys/controller/checker/CheckerIF.h>
 
 #include <DRAMSys/common/utils.h>
-#include <DRAMSys/configuration/Configuration.h>
 #include <DRAMSys/configuration/memspec/MemSpecHBM3.h>
 
 namespace DRAMSys
@@ -50,7 +49,7 @@ namespace DRAMSys
 class CheckerHBM3 final : public CheckerIF
 {
 public:
-    explicit CheckerHBM3(const Configuration& config);
+    explicit CheckerHBM3(const MemSpecHBM3& memSpec);
     sc_core::sc_time
     timeToSatisfyConstraints(Command command,
                              const tlm::tlm_generic_payload& payload) const override;
@@ -59,7 +58,7 @@ public:
 private:
     bool isFullCycle(const sc_core::sc_time& time) const;
 
-    const MemSpecHBM3* memSpec;
+    const MemSpecHBM3& memSpec;
 
     std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
     std::vector<ControllerVector<BankGroup, sc_core::sc_time>> lastScheduledByCommandAndBankGroup;
diff --git a/extensions/standards/LPDDR5/DRAMSys/configuration/memspec/MemSpecLPDDR5.cpp b/extensions/standards/LPDDR5/DRAMSys/configuration/memspec/MemSpecLPDDR5.cpp
index 6506ab5e..4b2d37fb 100644
--- a/extensions/standards/LPDDR5/DRAMSys/configuration/memspec/MemSpecLPDDR5.cpp
+++ b/extensions/standards/LPDDR5/DRAMSys/configuration/memspec/MemSpecLPDDR5.cpp
@@ -45,9 +45,8 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpecLPDDR5::MemSpecLPDDR5(const DRAMSys::Config::MemSpec& memSpec) :
+MemSpecLPDDR5::MemSpecLPDDR5(const Config::MemSpec& memSpec) :
     MemSpec(memSpec,
-            MemoryType::LPDDR5,
             memSpec.memarchitecturespec.entries.at("nbrOfChannels"),
             1,
             memSpec.memarchitecturespec.entries.at("nbrOfRanks"),
diff --git a/extensions/standards/LPDDR5/DRAMSys/configuration/memspec/MemSpecLPDDR5.h b/extensions/standards/LPDDR5/DRAMSys/configuration/memspec/MemSpecLPDDR5.h
index e0503b9d..823b05a3 100644
--- a/extensions/standards/LPDDR5/DRAMSys/configuration/memspec/MemSpecLPDDR5.h
+++ b/extensions/standards/LPDDR5/DRAMSys/configuration/memspec/MemSpecLPDDR5.h
@@ -47,7 +47,7 @@ namespace DRAMSys
 class MemSpecLPDDR5 final : public MemSpec
 {
 public:
-    explicit MemSpecLPDDR5(const DRAMSys::Config::MemSpec& memSpec);
+    explicit MemSpecLPDDR5(const Config::MemSpec& memSpec);
 
     // Memspec Variables:
     const sc_core::sc_time tREFI;
diff --git a/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.cpp b/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.cpp
index f18cc42f..504cb391 100644
--- a/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.cpp
+++ b/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.cpp
@@ -44,38 +44,33 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-CheckerLPDDR5::CheckerLPDDR5(const Configuration& config)
+CheckerLPDDR5::CheckerLPDDR5(const MemSpecLPDDR5& memSpec)
+    : memSpec(memSpec)
 {
-    memSpec = dynamic_cast<const MemSpecLPDDR5*>(config.memSpec.get());
-    if (memSpec == nullptr)
-        SC_REPORT_FATAL("CheckerLPDDR5", "Wrong MemSpec chosen");
-    else
-    {
-        lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
-            Command::numberOfCommands(),
-            ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
-        lastScheduledByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, sc_time>>(
-            Command::numberOfCommands(),
-            ControllerVector<BankGroup, sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
-        lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
-            Command::numberOfCommands(),
-            ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
-        lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
-        lastCommandOnBus = scMaxTime;
+    lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
+        Command::numberOfCommands(),
+        ControllerVector<Rank, sc_time>(memSpec.ranksPerChannel, scMaxTime));
+    lastScheduledByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, sc_time>>(
+        Command::numberOfCommands(),
+        ControllerVector<BankGroup, sc_time>(memSpec.bankGroupsPerChannel, scMaxTime));
+    lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
+        Command::numberOfCommands(),
+        ControllerVector<Bank, sc_time>(memSpec.banksPerChannel, scMaxTime));
+    lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
+    lastCommandOnBus = scMaxTime;
 
-        last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
+    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec.ranksPerChannel);
 
-        lastBurstLengthByCommandAndRank = std::vector<ControllerVector<Rank, uint8_t>>(
-            Command::WRA + 1, ControllerVector<Rank, uint8_t>(memSpec->ranksPerChannel));
-        lastBurstLengthByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, uint8_t>>(
-            Command::WRA + 1, ControllerVector<BankGroup, uint8_t>(memSpec->bankGroupsPerChannel));
-        lastBurstLengthByCommandAndBank = std::vector<ControllerVector<Bank, uint8_t>>(
-            Command::WRA + 1, ControllerVector<Bank, uint8_t>(memSpec->banksPerChannel));
-        lastBurstLengthByCommand = std::vector<uint8_t>(Command::WRA + 1);
+    lastBurstLengthByCommandAndRank = std::vector<ControllerVector<Rank, uint8_t>>(
+        Command::WRA + 1, ControllerVector<Rank, uint8_t>(memSpec.ranksPerChannel));
+    lastBurstLengthByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, uint8_t>>(
+        Command::WRA + 1, ControllerVector<BankGroup, uint8_t>(memSpec.bankGroupsPerChannel));
+    lastBurstLengthByCommandAndBank = std::vector<ControllerVector<Bank, uint8_t>>(
+        Command::WRA + 1, ControllerVector<Bank, uint8_t>(memSpec.banksPerChannel));
+    lastBurstLengthByCommand = std::vector<uint8_t>(Command::WRA + 1);
 
-        tBURST16 = 16 / memSpec->dataRate * memSpec->tCK;
-        tBURST32 = 32 / memSpec->dataRate * memSpec->tCK;
-    }
+    tBURST16 = 16 / memSpec.dataRate * memSpec.tCK;
+    tBURST32 = 32 / memSpec.dataRate * memSpec.tCK;
 }
 
 sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
@@ -92,26 +87,26 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
     if (command == Command::RD || command == Command::RDA)
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
-        assert(!(memSpec->bankMode == MemSpecLPDDR5::BankMode::M8B) ||
+        assert(!(memSpec.bankMode == MemSpecLPDDR5::BankMode::M8B) ||
                (burstLength == 32)); // 8B mode -> BL32
-        assert(!(memSpec->bankMode == MemSpecLPDDR5::BankMode::MBG) ||
-               (memSpec->dataRate == 8)); // BG mode -> 4:1 ratio
-        assert(burstLength <= memSpec->maxBurstLength);
+        assert(!(memSpec.bankMode == MemSpecLPDDR5::BankMode::MBG) ||
+               (memSpec.dataRate == 8)); // BG mode -> 4:1 ratio
+        assert(burstLength <= memSpec.maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD_L + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD_L + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
         if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::RD][bankGroup] == 32)
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_32);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_L_32);
             else
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_16);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_L_16);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
@@ -120,17 +115,17 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndRank[Command::RD][rank] == 32)
             {
                 // TODO: model BG mode BL32 interleaved burst, remove this fix
-                if (memSpec->bankMode == MemSpecLPDDR5::BankMode::MBG)
+                if (memSpec.bankMode == MemSpecLPDDR5::BankMode::MBG)
                     earliestTimeToStart =
                         std::max(earliestTimeToStart,
-                                 lastCommandStart + memSpec->BL_n_S_32 + 2 * memSpec->tCK);
+                                 lastCommandStart + memSpec.BL_n_S_32 + 2 * memSpec.tCK);
                 else
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_S_32);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_32);
             }
             else
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_S_16);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_16);
         }
 
         lastCommandStart =
@@ -141,12 +136,12 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
         {
             if (lastBurstLengthByCommand[Command::RD] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_32 +
-                                                   memSpec->tCK + memSpec->tRPST + memSpec->tRPRE);
+                                               lastCommandStart + memSpec.BL_n_min_32 +
+                                                   memSpec.tCK + memSpec.tRPST + memSpec.tRPRE);
             else
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_16 +
-                                                   memSpec->tCK + memSpec->tRPST + memSpec->tRPRE);
+                                               lastCommandStart + memSpec.BL_n_min_16 +
+                                                   memSpec.tCK + memSpec.tRPST + memSpec.tRPRE);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
@@ -154,10 +149,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::RDA][bankGroup] == 32)
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_32);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_L_32);
             else
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_16);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_L_16);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
@@ -166,17 +161,17 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndRank[Command::RDA][rank] == 32)
             {
                 // TODO: model BG mode BL32 interleaved burst, remove this fix
-                if (memSpec->bankMode == MemSpecLPDDR5::BankMode::MBG)
+                if (memSpec.bankMode == MemSpecLPDDR5::BankMode::MBG)
                     earliestTimeToStart =
                         std::max(earliestTimeToStart,
-                                 lastCommandStart + memSpec->BL_n_S_32 + 2 * memSpec->tCK);
+                                 lastCommandStart + memSpec.BL_n_S_32 + 2 * memSpec.tCK);
                 else
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_S_32);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_32);
             }
             else
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_S_16);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_16);
         }
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] !=
@@ -188,12 +183,12 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             // TODO: BG mode with BL32
             if (lastBurstLengthByCommand[Command::RDA] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_32 +
-                                                   memSpec->tCK + memSpec->tRPST + memSpec->tRPRE);
+                                               lastCommandStart + memSpec.BL_n_min_32 +
+                                                   memSpec.tCK + memSpec.tRPST + memSpec.tRPRE);
             else
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_16 +
-                                                   memSpec->tCK + memSpec->tRPST + memSpec->tRPRE);
+                                               lastCommandStart + memSpec.BL_n_min_16 +
+                                                   memSpec.tCK + memSpec.tRPST + memSpec.tRPRE);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
@@ -201,12 +196,12 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->tWL +
-                                                   memSpec->BL_n_max_32 + memSpec->tWTR_L);
+                                               lastCommandStart + memSpec.tWL +
+                                                   memSpec.BL_n_max_32 + memSpec.tWTR_L);
             else
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->tWL +
-                                                   memSpec->BL_n_max_16 + memSpec->tWTR_L);
+                                               lastCommandStart + memSpec.tWL +
+                                                   memSpec.BL_n_max_16 + memSpec.tWTR_L);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
@@ -214,12 +209,12 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
         {
             if (lastBurstLengthByCommandAndRank[Command::WR][rank] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->tWL +
-                                                   memSpec->BL_n_min_32 + memSpec->tWTR_S);
+                                               lastCommandStart + memSpec.tWL +
+                                                   memSpec.BL_n_min_32 + memSpec.tWTR_S);
             else
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->tWL +
-                                                   memSpec->BL_n_min_16 + memSpec->tWTR_S);
+                                               lastCommandStart + memSpec.tWL +
+                                                   memSpec.BL_n_min_16 + memSpec.tWTR_S);
         }
 
         lastCommandStart =
@@ -232,13 +227,13 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommand[Command::WR] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_32 + memSpec->tCK -
-                                 memSpec->tRL);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK -
+                                 memSpec.tRL);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_16 + memSpec->tCK -
-                                 memSpec->tRL);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK -
+                                 memSpec.tRL);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
@@ -246,12 +241,12 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
         {
             if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->tWL +
-                                                   memSpec->BL_n_max_32 + memSpec->tWTR_L);
+                                               lastCommandStart + memSpec.tWL +
+                                                   memSpec.BL_n_max_32 + memSpec.tWTR_L);
             else
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->tWL +
-                                                   memSpec->BL_n_max_16 + memSpec->tWTR_L);
+                                               lastCommandStart + memSpec.tWL +
+                                                   memSpec.BL_n_max_16 + memSpec.tWTR_L);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
@@ -259,12 +254,12 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
         {
             if (lastBurstLengthByCommandAndRank[Command::WRA][rank] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->tWL +
-                                                   memSpec->BL_n_min_32 + memSpec->tWTR_S);
+                                               lastCommandStart + memSpec.tWL +
+                                                   memSpec.BL_n_min_32 + memSpec.tWTR_S);
             else
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->tWL +
-                                                   memSpec->BL_n_min_16 + memSpec->tWTR_S);
+                                               lastCommandStart + memSpec.tWL +
+                                                   memSpec.BL_n_min_16 + memSpec.tWTR_S);
         }
 
         lastCommandStart = lastScheduledByCommand[Command::WRA] !=
@@ -277,29 +272,29 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommand[Command::WRA] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_32 + memSpec->tCK -
-                                 memSpec->tRL);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK -
+                                 memSpec.tRL);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_16 + memSpec->tCK -
-                                 memSpec->tRL);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK -
+                                 memSpec.tRL);
         }
     }
     else if (command == Command::WR || command == Command::WRA || command == Command::MWR ||
              command == Command::MWRA)
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
-        assert(!(memSpec->bankMode == MemSpecLPDDR5::BankMode::M8B) ||
+        assert(!(memSpec.bankMode == MemSpecLPDDR5::BankMode::M8B) ||
                (burstLength == 32)); // 8B mode -> BL32
-        assert(!(memSpec->bankMode == MemSpecLPDDR5::BankMode::MBG) ||
-               (memSpec->dataRate == 8)); // BG mode -> 4:1 ratio
-        assert(burstLength <= memSpec->maxBurstLength);
+        assert(!(memSpec.bankMode == MemSpecLPDDR5::BankMode::MBG) ||
+               (memSpec.dataRate == 8)); // BG mode -> 4:1 ratio
+        assert(burstLength <= memSpec.maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD_S + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD_S + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
         if (lastCommandStart != scMaxTime)
@@ -307,13 +302,13 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndBankGroup[Command::RD][bankGroup] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tRL + memSpec->BL_n_max_32 +
-                                 memSpec->tWCK2DQO - memSpec->tWL);
+                             lastCommandStart + memSpec.tRL + memSpec.BL_n_max_32 +
+                                 memSpec.tWCK2DQO - memSpec.tWL);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tRL + memSpec->BL_n_max_16 +
-                                 memSpec->tWCK2DQO - memSpec->tWL);
+                             lastCommandStart + memSpec.tRL + memSpec.BL_n_max_16 +
+                                 memSpec.tWCK2DQO - memSpec.tWL);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
@@ -322,13 +317,13 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndRank[Command::RD][rank] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tRL + memSpec->BL_n_min_32 +
-                                 memSpec->tWCK2DQO - memSpec->tWL);
+                             lastCommandStart + memSpec.tRL + memSpec.BL_n_min_32 +
+                                 memSpec.tWCK2DQO - memSpec.tWL);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tRL + memSpec->BL_n_min_16 +
-                                 memSpec->tWCK2DQO - memSpec->tWL);
+                             lastCommandStart + memSpec.tRL + memSpec.BL_n_min_16 +
+                                 memSpec.tWCK2DQO - memSpec.tWL);
         }
 
         lastCommandStart =
@@ -341,13 +336,13 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommand[Command::RD] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tRL + memSpec->BL_n_min_32 +
-                                 memSpec->tWCK2DQO + memSpec->tRPST - memSpec->tWL);
+                             lastCommandStart + memSpec.tRL + memSpec.BL_n_min_32 +
+                                 memSpec.tWCK2DQO + memSpec.tRPST - memSpec.tWL);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tRL + memSpec->BL_n_min_16 +
-                                 memSpec->tWCK2DQO + memSpec->tRPST - memSpec->tWL);
+                             lastCommandStart + memSpec.tRL + memSpec.BL_n_min_16 +
+                                 memSpec.tWCK2DQO + memSpec.tRPST - memSpec.tWL);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
@@ -356,13 +351,13 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndBankGroup[Command::RDA][bankGroup] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tRL + memSpec->BL_n_max_32 +
-                                 memSpec->tWCK2DQO - memSpec->tWL);
+                             lastCommandStart + memSpec.tRL + memSpec.BL_n_max_32 +
+                                 memSpec.tWCK2DQO - memSpec.tWL);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tRL + memSpec->BL_n_max_16 +
-                                 memSpec->tWCK2DQO - memSpec->tWL);
+                             lastCommandStart + memSpec.tRL + memSpec.BL_n_max_16 +
+                                 memSpec.tWCK2DQO - memSpec.tWL);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
@@ -371,13 +366,13 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndRank[Command::RDA][rank] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tRL + memSpec->BL_n_min_32 +
-                                 memSpec->tWCK2DQO - memSpec->tWL);
+                             lastCommandStart + memSpec.tRL + memSpec.BL_n_min_32 +
+                                 memSpec.tWCK2DQO - memSpec.tWL);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tRL + memSpec->BL_n_min_16 +
-                                 memSpec->tWCK2DQO - memSpec->tWL);
+                             lastCommandStart + memSpec.tRL + memSpec.BL_n_min_16 +
+                                 memSpec.tWCK2DQO - memSpec.tWL);
         }
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] !=
@@ -390,13 +385,13 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommand[Command::RDA] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tRL + memSpec->BL_n_min_32 +
-                                 memSpec->tWCK2DQO + memSpec->tRPST - memSpec->tWL);
+                             lastCommandStart + memSpec.tRL + memSpec.BL_n_min_32 +
+                                 memSpec.tWCK2DQO + memSpec.tRPST - memSpec.tWL);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tRL + memSpec->BL_n_min_16 +
-                                 memSpec->tWCK2DQO + memSpec->tRPST - memSpec->tWL);
+                             lastCommandStart + memSpec.tRL + memSpec.BL_n_min_16 +
+                                 memSpec.tWCK2DQO + memSpec.tRPST - memSpec.tWL);
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
@@ -406,10 +401,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             {
                 if (lastBurstLengthByCommandAndBank[Command::WR][bank] == 32)
                     earliestTimeToStart = std::max(earliestTimeToStart,
-                                                   lastCommandStart + 2.5 * memSpec->BL_n_max_32);
+                                                   lastCommandStart + 2.5 * memSpec.BL_n_max_32);
                 else
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + 4 * memSpec->BL_n_max_16);
+                        std::max(earliestTimeToStart, lastCommandStart + 4 * memSpec.BL_n_max_16);
             }
         }
 
@@ -420,19 +415,19 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             {
                 if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup] == 32)
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_32);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_L_32);
                 else
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_16);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_L_16);
             }
             else if (command == Command::MWR || command == Command::MWRA)
             {
                 if (lastBurstLengthByCommandAndBankGroup[Command::WR][bankGroup] == 32)
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_max_32);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_max_32);
                 else
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_max_16);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_max_16);
             }
         }
 
@@ -442,17 +437,17 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndRank[Command::WR][rank] == 32)
             {
                 // TODO: model BG mode BL32 interleaved burst, remove this fix
-                if (memSpec->bankMode == MemSpecLPDDR5::BankMode::MBG)
+                if (memSpec.bankMode == MemSpecLPDDR5::BankMode::MBG)
                     earliestTimeToStart =
                         std::max(earliestTimeToStart,
-                                 lastCommandStart + memSpec->BL_n_S_32 + 2 * memSpec->tCK);
+                                 lastCommandStart + memSpec.BL_n_S_32 + 2 * memSpec.tCK);
                 else
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_S_32);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_32);
             }
             else
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_S_16);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_16);
         }
 
         lastCommandStart = lastScheduledByCommand[Command::WR];
@@ -465,11 +460,11 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
                 if (lastBurstLengthByCommand[Command::WR] == 32)
                     earliestTimeToStart =
                         std::max(earliestTimeToStart,
-                                 lastCommandStart + memSpec->BL_n_min_32 + memSpec->tCK);
+                                 lastCommandStart + memSpec.BL_n_min_32 + memSpec.tCK);
                 else
                     earliestTimeToStart =
                         std::max(earliestTimeToStart,
-                                 lastCommandStart + memSpec->BL_n_min_16 + memSpec->tCK);
+                                 lastCommandStart + memSpec.BL_n_min_16 + memSpec.tCK);
             }
         }
 
@@ -480,19 +475,19 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             {
                 if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup] == 32)
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_32);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_L_32);
                 else
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_L_16);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_L_16);
             }
             else if (command == Command::MWR || command == Command::MWRA)
             {
                 if (lastBurstLengthByCommandAndBankGroup[Command::WRA][bankGroup] == 32)
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_max_32);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_max_32);
                 else
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_max_16);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_max_16);
             }
         }
 
@@ -502,17 +497,17 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndRank[Command::WRA][rank] == 32)
             {
                 // TODO: model BG mode BL32 interleaved burst, remove this fix
-                if (memSpec->bankMode == MemSpecLPDDR5::BankMode::MBG)
+                if (memSpec.bankMode == MemSpecLPDDR5::BankMode::MBG)
                     earliestTimeToStart =
                         std::max(earliestTimeToStart,
-                                 lastCommandStart + memSpec->BL_n_S_32 + 2 * memSpec->tCK);
+                                 lastCommandStart + memSpec.BL_n_S_32 + 2 * memSpec.tCK);
                 else
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_S_32);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_32);
             }
             else
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->BL_n_S_16);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.BL_n_S_16);
         }
 
         lastCommandStart = lastScheduledByCommand[Command::WRA];
@@ -524,11 +519,11 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
                 if (lastBurstLengthByCommand[Command::WRA] == 32)
                     earliestTimeToStart =
                         std::max(earliestTimeToStart,
-                                 lastCommandStart + memSpec->BL_n_min_32 + memSpec->tCK);
+                                 lastCommandStart + memSpec.BL_n_min_32 + memSpec.tCK);
                 else
                     earliestTimeToStart =
                         std::max(earliestTimeToStart,
-                                 lastCommandStart + memSpec->BL_n_min_16 + memSpec->tCK);
+                                 lastCommandStart + memSpec.BL_n_min_16 + memSpec.tCK);
             }
         }
     }
@@ -536,23 +531,23 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::RDA][bank] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_32 +
-                                                   memSpec->tRBTP + memSpec->tRPpb - memSpec->tCK);
+                                               lastCommandStart + memSpec.BL_n_min_32 +
+                                                   memSpec.tRBTP + memSpec.tRPpb - memSpec.tCK);
             else
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_16 +
-                                                   memSpec->tRBTP + memSpec->tRPpb - memSpec->tCK);
+                                               lastCommandStart + memSpec.BL_n_min_16 +
+                                                   memSpec.tRBTP + memSpec.tRPpb - memSpec.tCK);
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
@@ -561,70 +556,70 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndBank[Command::RDA][bank] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_32 + memSpec->tCK +
-                                 memSpec->tWR + memSpec->tRPpb - memSpec->tCK);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK +
+                                 memSpec.tWR + memSpec.tRPpb - memSpec.tCK);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_16 + memSpec->tCK +
-                                 memSpec->tWR + memSpec->tRPpb - memSpec->tCK);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK +
+                                 memSpec.tWR + memSpec.tRPpb - memSpec.tCK);
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tpbR2act - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tpbR2act - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFP2B][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tpbR2act - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tpbR2act - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFP2B][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb - memSpec.tCK);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW - memSpec->tCK);
+                earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW - memSpec.tCK);
     }
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::RD][bank] == 32)
                 earliestTimeToStart = std::max(
-                    earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32 + memSpec->tRBTP);
+                    earliestTimeToStart, lastCommandStart + memSpec.BL_n_min_32 + memSpec.tRBTP);
             else
                 earliestTimeToStart = std::max(
-                    earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_16 + memSpec->tRBTP);
+                    earliestTimeToStart, lastCommandStart + memSpec.BL_n_min_16 + memSpec.tRBTP);
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
@@ -633,35 +628,35 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndBank[Command::WR][bank] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_32 + memSpec->tCK +
-                                 memSpec->tWR);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK +
+                                 memSpec.tWR);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_16 + memSpec->tCK +
-                                 memSpec->tWR);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK +
+                                 memSpec.tWR);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::RD][rank] == 32)
                 earliestTimeToStart = std::max(
-                    earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32 + memSpec->tRBTP);
+                    earliestTimeToStart, lastCommandStart + memSpec.BL_n_min_32 + memSpec.tRBTP);
             else
                 earliestTimeToStart = std::max(
-                    earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_16 + memSpec->tRBTP);
+                    earliestTimeToStart, lastCommandStart + memSpec.BL_n_min_16 + memSpec.tRBTP);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
@@ -669,10 +664,10 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
         {
             if (lastBurstLengthByCommandAndRank[Command::RDA][rank] == 32)
                 earliestTimeToStart = std::max(
-                    earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_32 + memSpec->tRBTP);
+                    earliestTimeToStart, lastCommandStart + memSpec.BL_n_min_32 + memSpec.tRBTP);
             else
                 earliestTimeToStart = std::max(
-                    earliestTimeToStart, lastCommandStart + memSpec->BL_n_min_16 + memSpec->tRBTP);
+                    earliestTimeToStart, lastCommandStart + memSpec.BL_n_min_16 + memSpec.tRBTP);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
@@ -681,13 +676,13 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndRank[Command::WR][rank] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_32 + memSpec->tCK +
-                                 memSpec->tWR);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK +
+                                 memSpec.tWR);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_16 + memSpec->tCK +
-                                 memSpec->tWR);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK +
+                                 memSpec.tWR);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
@@ -696,37 +691,37 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndRank[Command::WRA][rank] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_32 + memSpec->tCK +
-                                 memSpec->tWR);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK +
+                                 memSpec.tWR);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_16 + memSpec->tCK +
-                                 memSpec->tWR);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK +
+                                 memSpec.tWR);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndRank[Command::RDA][rank] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_32 +
-                                                   memSpec->tRBTP + memSpec->tRPpb);
+                                               lastCommandStart + memSpec.BL_n_min_32 +
+                                                   memSpec.tRBTP + memSpec.tRPpb);
             else
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_16 +
-                                                   memSpec->tRBTP + memSpec->tRPpb);
+                                               lastCommandStart + memSpec.BL_n_min_16 +
+                                                   memSpec.tRBTP + memSpec.tRPpb);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
@@ -735,50 +730,50 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndRank[Command::WRA][rank] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_32 + memSpec->tCK +
-                                 memSpec->tWR + memSpec->tRPpb);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK +
+                                 memSpec.tWR + memSpec.tRPpb);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_16 + memSpec->tCK +
-                                 memSpec->tWR + memSpec->tRPpb);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK +
+                                 memSpec.tWR + memSpec.tRPpb);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab);
     }
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::RDA][bank] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_32 +
-                                                   memSpec->tRBTP + memSpec->tRPpb);
+                                               lastCommandStart + memSpec.BL_n_min_32 +
+                                                   memSpec.tRBTP + memSpec.tRPpb);
             else
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_16 +
-                                                   memSpec->tRBTP + memSpec->tRPpb);
+                                               lastCommandStart + memSpec.BL_n_min_16 +
+                                                   memSpec.tRBTP + memSpec.tRPpb);
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
@@ -787,66 +782,66 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndBank[Command::WRA][bank] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_32 + memSpec->tCK +
-                                 memSpec->tWR + memSpec->tRPpb);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK +
+                                 memSpec.tWR + memSpec.tRPpb);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_16 + memSpec->tCK +
-                                 memSpec->tWR + memSpec->tRPpb);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK +
+                                 memSpec.tWR + memSpec.tRPpb);
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tpbR2pbR);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tpbR2pbR);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
     }
     else if (command == Command::REFP2B)
     {
-        Bank secondBank = Bank(static_cast<std::size_t>(bank) + memSpec->getPer2BankOffset());
+        Bank secondBank = Bank(static_cast<std::size_t>(bank) + memSpec.getPer2BankOffset());
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][secondBank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
         {
             if (lastBurstLengthByCommandAndBank[Command::RDA][bank] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_32 +
-                                                   memSpec->tRBTP + memSpec->tRPpb);
+                                               lastCommandStart + memSpec.BL_n_min_32 +
+                                                   memSpec.tRBTP + memSpec.tRPpb);
             else
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_16 +
-                                                   memSpec->tRBTP + memSpec->tRPpb);
+                                               lastCommandStart + memSpec.BL_n_min_16 +
+                                                   memSpec.tRBTP + memSpec.tRPpb);
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][secondBank];
@@ -854,12 +849,12 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
         {
             if (lastBurstLengthByCommandAndBank[Command::RDA][secondBank] == 32)
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_32 +
-                                                   memSpec->tRBTP + memSpec->tRPpb);
+                                               lastCommandStart + memSpec.BL_n_min_32 +
+                                                   memSpec.tRBTP + memSpec.tRPpb);
             else
                 earliestTimeToStart = std::max(earliestTimeToStart,
-                                               lastCommandStart + memSpec->BL_n_min_16 +
-                                                   memSpec->tRBTP + memSpec->tRPpb);
+                                               lastCommandStart + memSpec.BL_n_min_16 +
+                                                   memSpec.tRBTP + memSpec.tRPpb);
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
@@ -868,13 +863,13 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndBank[Command::WRA][bank] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_32 + memSpec->tCK +
-                                 memSpec->tWR + memSpec->tRPpb);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK +
+                                 memSpec.tWR + memSpec.tRPpb);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_16 + memSpec->tCK +
-                                 memSpec->tWR + memSpec->tRPpb);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK +
+                                 memSpec.tWR + memSpec.tRPpb);
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][secondBank];
@@ -883,46 +878,46 @@ sc_time CheckerLPDDR5::timeToSatisfyConstraints(Command command,
             if (lastBurstLengthByCommandAndBank[Command::WRA][secondBank] == 32)
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_32 + memSpec->tCK +
-                                 memSpec->tWR + memSpec->tRPpb);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_32 + memSpec.tCK +
+                                 memSpec.tWR + memSpec.tRPpb);
             else
                 earliestTimeToStart =
                     std::max(earliestTimeToStart,
-                             lastCommandStart + memSpec->tWL + memSpec->BL_n_min_16 + memSpec->tCK +
-                                 memSpec->tWR + memSpec->tRPpb);
+                             lastCommandStart + memSpec.tWL + memSpec.BL_n_min_16 + memSpec.tCK +
+                                 memSpec.tWR + memSpec.tRPpb);
         }
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][secondBank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFP2B][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFP2B][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tpbR2pbR);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tpbR2pbR);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
     }
     else
         SC_REPORT_FATAL("CheckerLPDDR5", "Unknown command!");
 
     // Check if command bus is free
     if (lastCommandOnBus != scMaxTime)
-        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK);
 
     return earliestTimeToStart;
 }
@@ -959,11 +954,11 @@ void CheckerLPDDR5::insert(Command command, const tlm_generic_payload& payload)
 
     if (command == Command::REFP2B)
     {
-        Bank secondBank = Bank(static_cast<std::size_t>(bank) + memSpec->getPer2BankOffset());
+        Bank secondBank = Bank(static_cast<std::size_t>(bank) + memSpec.getPer2BankOffset());
         lastScheduledByCommandAndBank[command][secondBank] = sc_time_stamp();
     }
 
-    lastCommandOnBus = sc_time_stamp() + memSpec->getCommandLength(command) - memSpec->tCK;
+    lastCommandOnBus = sc_time_stamp() + memSpec.getCommandLength(command) - memSpec.tCK;
 
     if (command == Command::ACT || command == Command::REFPB || command == Command::REFP2B ||
         command == Command::RFMPB || command == Command::RFMP2B)
diff --git a/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.h b/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.h
index 77c250c1..e84fe4fa 100644
--- a/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.h
+++ b/extensions/standards/LPDDR5/DRAMSys/controller/checker/CheckerLPDDR5.h
@@ -41,7 +41,6 @@
 #include <DRAMSys/controller/checker/CheckerIF.h>
 
 #include <DRAMSys/common/utils.h>
-#include <DRAMSys/configuration/Configuration.h>
 #include <DRAMSys/configuration/memspec/MemSpecLPDDR5.h>
 
 namespace DRAMSys
@@ -50,14 +49,14 @@ namespace DRAMSys
 class CheckerLPDDR5 final : public CheckerIF
 {
 public:
-    explicit CheckerLPDDR5(const Configuration& config);
+    explicit CheckerLPDDR5(const MemSpecLPDDR5& memSpec);
     sc_core::sc_time
     timeToSatisfyConstraints(Command command,
                              const tlm::tlm_generic_payload& payload) const override;
     void insert(Command command, const tlm::tlm_generic_payload& payload) override;
 
 private:
-    const MemSpecLPDDR5* memSpec;
+    const MemSpecLPDDR5& memSpec;
 
     std::vector<ControllerVector<Rank, sc_core::sc_time>> lastScheduledByCommandAndRank;
     std::vector<ControllerVector<BankGroup, sc_core::sc_time>> lastScheduledByCommandAndBankGroup;
diff --git a/src/configuration/DRAMSys/config/DRAMSysConfiguration.cpp b/src/configuration/DRAMSys/config/DRAMSysConfiguration.cpp
index 0a8ca1f9..56f7ad09 100644
--- a/src/configuration/DRAMSys/config/DRAMSysConfiguration.cpp
+++ b/src/configuration/DRAMSys/config/DRAMSysConfiguration.cpp
@@ -127,7 +127,7 @@ Configuration from_path(std::string_view path, std::string_view resourceDirector
     if (file.is_open())
     {
         json_t simulation = json_t::parse(file, parser_callback, true, true).at(Configuration::KEY);
-        return simulation.get<DRAMSys::Config::Configuration>();
+        return simulation.get<Config::Configuration>();
     }
     throw std::runtime_error("Failed to open file " + std::string(path));
 }
diff --git a/src/configuration/DRAMSys/config/SimConfig.h b/src/configuration/DRAMSys/config/SimConfig.h
index ea05ced5..bbd60ed4 100644
--- a/src/configuration/DRAMSys/config/SimConfig.h
+++ b/src/configuration/DRAMSys/config/SimConfig.h
@@ -47,15 +47,13 @@ enum class StoreModeType
 {
     NoStorage,
     Store,
-    ErrorModel,
     Invalid = -1
 };
 
 NLOHMANN_JSON_SERIALIZE_ENUM(StoreModeType,
                              {{StoreModeType::Invalid, nullptr},
                               {StoreModeType::NoStorage, "NoStorage"},
-                              {StoreModeType::Store, "Store"},
-                              {StoreModeType::ErrorModel, "ErrorModel"}})
+                              {StoreModeType::Store, "Store"}})
 
 struct SimConfig
 {
@@ -67,8 +65,6 @@ struct SimConfig
     std::optional<bool> DatabaseRecording;
     std::optional<bool> Debug;
     std::optional<bool> EnableWindowing;
-    std::optional<std::string> ErrorCSVFile;
-    std::optional<unsigned int> ErrorChipSeed;
     std::optional<bool> PowerAnalysis;
     std::optional<std::string> SimulationName;
     std::optional<bool> SimulationProgressBar;
@@ -84,8 +80,6 @@ NLOHMANN_JSONIFY_ALL_THINGS(SimConfig,
                             DatabaseRecording,
                             Debug,
                             EnableWindowing,
-                            ErrorCSVFile,
-                            ErrorChipSeed,
                             PowerAnalysis,
                             SimulationName,
                             SimulationProgressBar,
diff --git a/src/configuration/DRAMSys/config/memspec/MemSpec.h b/src/configuration/DRAMSys/config/memspec/MemSpec.h
index fe6d14bf..3d541fa1 100644
--- a/src/configuration/DRAMSys/config/memspec/MemSpec.h
+++ b/src/configuration/DRAMSys/config/memspec/MemSpec.h
@@ -46,6 +46,40 @@
 namespace DRAMSys::Config
 {
 
+enum class MemoryType
+{
+    DDR3,
+    DDR4,
+    DDR5,
+    LPDDR4,
+    LPDDR5,
+    WideIO,
+    WideIO2,
+    GDDR5,
+    GDDR5X,
+    GDDR6,
+    HBM2,
+    HBM3,
+    STTMRAM,
+    Invalid = -1
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MemoryType,
+                             {{MemoryType::Invalid, nullptr},
+                              {MemoryType::DDR3, "DDR3"},
+                              {MemoryType::DDR4, "DDR4"},
+                              {MemoryType::DDR5, "DDR5"},
+                              {MemoryType::LPDDR4, "LPDDR4"},
+                              {MemoryType::LPDDR5, "LPDDR5"},
+                              {MemoryType::WideIO, "WIDEIO_SDR"},
+                              {MemoryType::WideIO2, "WIDEIO2"},
+                              {MemoryType::GDDR5, "GDDR5"},
+                              {MemoryType::GDDR5X, "GDDR5X"},
+                              {MemoryType::GDDR6, "GDDR6"},
+                              {MemoryType::HBM2, "HBM2"},
+                              {MemoryType::HBM3, "HBM3"},
+                              {MemoryType::STTMRAM, "STTMRAM"}})
+
 struct MemSpec
 {
     static constexpr std::string_view KEY = "memspec";
@@ -53,7 +87,7 @@ struct MemSpec
 
     MemArchitectureSpecType memarchitecturespec;
     std::string memoryId;
-    std::string memoryType;
+    MemoryType memoryType;
     MemTimingSpecType memtimingspec;
     std::optional<MemPowerSpec> mempowerspec;
 };
diff --git a/src/libdramsys/DRAMSys/common/DebugManager.cpp b/src/libdramsys/DRAMSys/common/DebugManager.cpp
index a425da7c..f9a1ac0d 100644
--- a/src/libdramsys/DRAMSys/common/DebugManager.cpp
+++ b/src/libdramsys/DRAMSys/common/DebugManager.cpp
@@ -36,9 +36,10 @@
 
 #include "DebugManager.h"
 
-#ifndef NDEBUG
+#include <iostream>
+#include <systemc>
 
-#include <DRAMSys/configuration/Configuration.h>
+#ifndef NDEBUG
 
 namespace DRAMSys
 {
diff --git a/src/libdramsys/DRAMSys/common/TlmRecorder.cpp b/src/libdramsys/DRAMSys/common/TlmRecorder.cpp
index b3a642b7..2e09467f 100644
--- a/src/libdramsys/DRAMSys/common/TlmRecorder.cpp
+++ b/src/libdramsys/DRAMSys/common/TlmRecorder.cpp
@@ -53,14 +53,17 @@ namespace DRAMSys
 {
 
 TlmRecorder::TlmRecorder(const std::string& name,
-                         const Configuration& config,
+                         const SimConfig& simConfig,
+                         const McConfig& mcConfig,
+                         const MemSpec& memSpec,
                          const std::string& dbName,
-                         std::string mcconfig,
-                         std::string memspec,
-                         std::string traces) :
+                         const std::string& mcConfigString,
+                         const std::string& memSpecString,
+                         const std::string& traces) :
     name(name),
-    config(config),
-    memSpec(*config.memSpec),
+    simConfig(simConfig),
+    mcConfig(mcConfig),
+    memSpec(memSpec),
     currentDataBuffer(&recordingDataBuffer.at(0)),
     storageDataBuffer(&recordingDataBuffer.at(1)),
     simulationTimeCoveredByRecording(SC_ZERO_TIME)
@@ -79,7 +82,7 @@ TlmRecorder::TlmRecorder(const std::string& name,
     executeInitialSqlCommand();
     prepareSqlStatements();
 
-    insertGeneralInfo(mcconfig, memspec, traces);
+    insertGeneralInfo(mcConfigString, memSpecString, traces);
     insertCommandLengths();
 
     PRINTDEBUGMESSAGE(name, "Starting new database transaction");
@@ -435,52 +438,54 @@ void TlmRecorder::insertDebugMessageInDB(const std::string& message, const sc_ti
     executeSqlStatement(insertDebugMessageStatement);
 }
 
-void TlmRecorder::insertGeneralInfo(std::string mcconfig, std::string memspec, std::string traces)
+void TlmRecorder::insertGeneralInfo(const std::string& mcConfigString,
+                                    const std::string& memSpecString,
+                                    const std::string& traces)
 {
-    sqlite3_bind_int(
-        insertGeneralInfoStatement, 1, static_cast<int>(config.memSpec->ranksPerChannel));
-    sqlite3_bind_int(
-        insertGeneralInfoStatement, 2, static_cast<int>(config.memSpec->bankGroupsPerChannel));
-    sqlite3_bind_int(
-        insertGeneralInfoStatement, 3, static_cast<int>(config.memSpec->banksPerChannel));
-    sqlite3_bind_int64(
-        insertGeneralInfoStatement, 4, static_cast<int64_t>(config.memSpec->tCK.value()));
+    sqlite3_bind_int(insertGeneralInfoStatement, 1, static_cast<int>(memSpec.ranksPerChannel));
+    sqlite3_bind_int(insertGeneralInfoStatement, 2, static_cast<int>(memSpec.bankGroupsPerChannel));
+    sqlite3_bind_int(insertGeneralInfoStatement, 3, static_cast<int>(memSpec.banksPerChannel));
+    sqlite3_bind_int64(insertGeneralInfoStatement, 4, static_cast<int64_t>(memSpec.tCK.value()));
     sqlite3_bind_text(insertGeneralInfoStatement, 5, "PS", 2, nullptr);
 
     sqlite3_bind_text(insertGeneralInfoStatement,
                       6,
-                      mcconfig.c_str(),
-                      static_cast<int>(mcconfig.length()),
+                      mcConfigString.c_str(),
+                      static_cast<int>(mcConfigString.length()),
                       nullptr);
     sqlite3_bind_text(insertGeneralInfoStatement,
                       7,
-                      memspec.c_str(),
-                      static_cast<int>(memspec.length()),
+                      memSpecString.c_str(),
+                      static_cast<int>(memSpecString.length()),
                       nullptr);
     sqlite3_bind_text(
         insertGeneralInfoStatement, 8, traces.c_str(), static_cast<int>(traces.length()), nullptr);
-    if (config.enableWindowing)
+
+    if (simConfig.enableWindowing)
+    {
         sqlite3_bind_int64(insertGeneralInfoStatement,
                            9,
-                           static_cast<int64_t>((config.memSpec->tCK * config.windowSize).value()));
+                           static_cast<int64_t>((memSpec.tCK * simConfig.windowSize).value()));
+    }
     else
+    {
         sqlite3_bind_int64(insertGeneralInfoStatement, 9, 0);
-    sqlite3_bind_int(insertGeneralInfoStatement, 10, static_cast<int>(config.refreshMaxPostponed));
-    sqlite3_bind_int(insertGeneralInfoStatement, 11, static_cast<int>(config.refreshMaxPulledin));
-    sqlite3_bind_int(insertGeneralInfoStatement, 12, static_cast<int>(UINT_MAX));
-    sqlite3_bind_int(insertGeneralInfoStatement, 13, static_cast<int>(config.requestBufferSize));
+    }
     sqlite3_bind_int(
-        insertGeneralInfoStatement, 14, static_cast<int>(config.memSpec->getPer2BankOffset()));
+        insertGeneralInfoStatement, 10, static_cast<int>(mcConfig.refreshMaxPostponed));
+    sqlite3_bind_int(insertGeneralInfoStatement, 11, static_cast<int>(mcConfig.refreshMaxPulledin));
+    sqlite3_bind_int(insertGeneralInfoStatement, 12, static_cast<int>(UINT_MAX));
+    sqlite3_bind_int(insertGeneralInfoStatement, 13, static_cast<int>(mcConfig.requestBufferSize));
+    sqlite3_bind_int(insertGeneralInfoStatement, 14, static_cast<int>(memSpec.getPer2BankOffset()));
 
-    const MemSpec& memSpec = *config.memSpec;
     const auto memoryType = memSpec.memoryType;
 
     bool rowColumnCommandBus =
-        (memoryType == MemSpec::MemoryType::HBM2) || (memoryType == MemSpec::MemoryType::HBM3);
+        (memoryType == Config::MemoryType::HBM2) || (memoryType == Config::MemoryType::HBM3);
 
-    bool pseudoChannelMode = [&memSpec, memoryType]() -> bool
+    bool pseudoChannelMode = [this, memoryType]() -> bool
     {
-        if (memoryType != MemSpec::MemoryType::HBM2 && memoryType != MemSpec::MemoryType::HBM3)
+        if (memoryType != Config::MemoryType::HBM2 && memoryType != Config::MemoryType::HBM3)
             return false;
 
         return memSpec.pseudoChannelsPerChannel != 1;
@@ -493,16 +498,14 @@ void TlmRecorder::insertGeneralInfo(std::string mcconfig, std::string memspec, s
 
 void TlmRecorder::insertCommandLengths()
 {
-    const MemSpec& _memSpec = *config.memSpec;
-
-    auto insertCommandLength = [this, &_memSpec](Command command)
+    auto insertCommandLength = [this](Command command)
     {
         auto commandName = command.toString();
 
         sqlite3_bind_text(
             insertCommandLengthsStatement, 1, commandName.c_str(), commandName.length(), nullptr);
         sqlite3_bind_double(
-            insertCommandLengthsStatement, 2, _memSpec.getCommandLengthInCycles(command));
+            insertCommandLengthsStatement, 2, memSpec.getCommandLengthInCycles(command));
         executeSqlStatement(insertCommandLengthsStatement);
     };
 
diff --git a/src/libdramsys/DRAMSys/common/TlmRecorder.h b/src/libdramsys/DRAMSys/common/TlmRecorder.h
index 6ebc37b7..838bdf1f 100644
--- a/src/libdramsys/DRAMSys/common/TlmRecorder.h
+++ b/src/libdramsys/DRAMSys/common/TlmRecorder.h
@@ -43,7 +43,9 @@
 
 #include "DRAMSys/common/dramExtensions.h"
 #include "DRAMSys/common/utils.h"
-#include "DRAMSys/configuration/Configuration.h"
+#include "DRAMSys/configuration/memspec/MemSpec.h"
+#include "DRAMSys/controller/McConfig.h"
+#include "DRAMSys/simulation/SimConfig.h"
 
 #include <string>
 #include <systemc>
@@ -63,11 +65,13 @@ class TlmRecorder
 {
 public:
     TlmRecorder(const std::string& name,
-                const Configuration& config,
+                const SimConfig& simConfig,
+                const McConfig& mcConfig,
+                const MemSpec& memSpec,
                 const std::string& dbName,
-                std::string mcconfig,
-                std::string memspec,
-                std::string traces);
+                const std::string& mcconfig,
+                const std::string& memspec,
+                const std::string& traces);
     TlmRecorder(const TlmRecorder&) = delete;
     TlmRecorder(TlmRecorder&&) = default;
     TlmRecorder& operator=(const TlmRecorder&) = delete;
@@ -85,7 +89,8 @@ public:
 
 private:
     std::string name;
-    const Configuration& config;
+    const SimConfig& simConfig;
+    const McConfig& mcConfig;
     const MemSpec& memSpec;
 
     struct Transaction
@@ -168,7 +173,9 @@ private:
 
     void terminateRemainingTransactions();
     void commitRecordedDataToDB();
-    void insertGeneralInfo(std::string mcconfig, std::string memspec, std::string traces);
+    void insertGeneralInfo(const std::string& mcConfigString,
+                           const std::string& memSpecString,
+                           const std::string& traces);
     void insertCommandLengths();
     void insertTransactionInDB(const Transaction& recordingData);
     void insertRangeInDB(uint64_t id, const sc_core::sc_time& begin, const sc_core::sc_time& end);
diff --git a/src/libdramsys/DRAMSys/common/dramExtensions.cpp b/src/libdramsys/DRAMSys/common/dramExtensions.cpp
index ccf3403b..d19d3509 100644
--- a/src/libdramsys/DRAMSys/common/dramExtensions.cpp
+++ b/src/libdramsys/DRAMSys/common/dramExtensions.cpp
@@ -36,7 +36,6 @@
  */
 
 #include "dramExtensions.h"
-#include <DRAMSys/configuration/Configuration.h>
 
 using namespace sc_core;
 using namespace tlm;
diff --git a/src/libdramsys/DRAMSys/configuration/Configuration.cpp b/src/libdramsys/DRAMSys/configuration/Configuration.cpp
deleted file mode 100644
index 8fd9ef2d..00000000
--- a/src/libdramsys/DRAMSys/configuration/Configuration.cpp
+++ /dev/null
@@ -1,378 +0,0 @@
-/*
- * Copyright (c) 2015, 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.
- *
- * Authors:
- *    Janik Schlemminger
- *    Matthias Jung
- *    Éder F. Zulian
- *    Felipe S. Prado
- *    Lukas Steiner
- *    Luiza Correa
- *    Derek Christ
- */
-
-#include "Configuration.h"
-
-#include "DRAMSys/configuration/memspec/MemSpecDDR3.h"
-#include "DRAMSys/configuration/memspec/MemSpecDDR4.h"
-#include "DRAMSys/configuration/memspec/MemSpecGDDR5.h"
-#include "DRAMSys/configuration/memspec/MemSpecGDDR5X.h"
-#include "DRAMSys/configuration/memspec/MemSpecGDDR6.h"
-#include "DRAMSys/configuration/memspec/MemSpecHBM2.h"
-#include "DRAMSys/configuration/memspec/MemSpecLPDDR4.h"
-#include "DRAMSys/configuration/memspec/MemSpecSTTMRAM.h"
-#include "DRAMSys/configuration/memspec/MemSpecWideIO.h"
-#include "DRAMSys/configuration/memspec/MemSpecWideIO2.h"
-
-#ifdef DDR5_SIM
-#include "DRAMSys/configuration/memspec/MemSpecDDR5.h"
-#endif
-#ifdef LPDDR5_SIM
-#include "DRAMSys/configuration/memspec/MemSpecLPDDR5.h"
-#endif
-#ifdef HBM3_SIM
-#include "DRAMSys/configuration/memspec/MemSpecHBM3.h"
-#endif
-
-using namespace sc_core;
-
-namespace DRAMSys
-{
-
-enum sc_time_unit string2TimeUnit(const std::string& s)
-{
-    if (s == "s")
-        return SC_SEC;
-
-    if (s == "ms")
-        return SC_MS;
-
-    if (s == "us")
-        return SC_US;
-
-    if (s == "ns")
-        return SC_NS;
-
-    if (s == "ps")
-        return SC_PS;
-
-    if (s == "fs")
-        return SC_FS;
-
-    SC_REPORT_FATAL("Configuration", ("Could not convert to enum sc_time_unit: " + s).c_str());
-    throw;
-}
-
-void Configuration::loadSimConfig(const DRAMSys::Config::SimConfig& simConfig)
-{
-    addressOffset = simConfig.AddressOffset.value_or(addressOffset);
-    checkTLM2Protocol = simConfig.CheckTLM2Protocol.value_or(checkTLM2Protocol);
-    databaseRecording = simConfig.DatabaseRecording.value_or(databaseRecording);
-    debug = simConfig.Debug.value_or(debug);
-    enableWindowing = simConfig.EnableWindowing.value_or(enableWindowing);
-    simulationName = simConfig.SimulationName.value_or(simulationName);
-    simulationProgressBar = simConfig.SimulationProgressBar.value_or(simulationProgressBar);
-    useMalloc = simConfig.UseMalloc.value_or(useMalloc);
-
-    if (const auto& _storeMode = simConfig.StoreMode)
-        storeMode = [=]
-        {
-            switch (*_storeMode)
-            {
-            case DRAMSys::Config::StoreModeType::NoStorage:
-                return StoreMode::NoStorage;
-            case DRAMSys::Config::StoreModeType::Store:
-                return StoreMode::Store;
-            default:
-                SC_REPORT_FATAL("Configuration", "Invalid StoreMode");
-                return StoreMode::NoStorage; // Silence Warning
-            }
-        }();
-
-    windowSize = simConfig.WindowSize.value_or(windowSize);
-    if (windowSize == 0)
-        SC_REPORT_FATAL("Configuration", "Minimum window size is 1");
-
-    powerAnalysis = simConfig.PowerAnalysis.value_or(powerAnalysis);
-#ifndef DRAMPOWER
-    if (powerAnalysis)
-        SC_REPORT_FATAL("Configuration",
-                        "Power analysis is only supported with included DRAMPower library!");
-#endif
-}
-
-void Configuration::loadMCConfig(const DRAMSys::Config::McConfig& mcConfig)
-{
-    if (const auto& _pagePolicy = mcConfig.PagePolicy)
-        pagePolicy = [=]
-        {
-            switch (*_pagePolicy)
-            {
-            case DRAMSys::Config::PagePolicyType::Open:
-                return PagePolicy::Open;
-            case DRAMSys::Config::PagePolicyType::OpenAdaptive:
-                return PagePolicy::OpenAdaptive;
-            case DRAMSys::Config::PagePolicyType::Closed:
-                return PagePolicy::Closed;
-            case DRAMSys::Config::PagePolicyType::ClosedAdaptive:
-                return PagePolicy::ClosedAdaptive;
-            default:
-                SC_REPORT_FATAL("Configuration", "Invalid PagePolicy");
-                return PagePolicy::Open; // Silence Warning
-            }
-        }();
-
-    if (const auto& _scheduler = mcConfig.Scheduler)
-        scheduler = [=]
-        {
-            switch (*_scheduler)
-            {
-            case DRAMSys::Config::SchedulerType::Fifo:
-                return Scheduler::Fifo;
-            case DRAMSys::Config::SchedulerType::FrFcfs:
-                return Scheduler::FrFcfs;
-            case DRAMSys::Config::SchedulerType::FrFcfsGrp:
-                return Scheduler::FrFcfsGrp;
-            case DRAMSys::Config::SchedulerType::GrpFrFcfs:
-                return Scheduler::GrpFrFcfs;
-            case DRAMSys::Config::SchedulerType::GrpFrFcfsWm:
-                return Scheduler::GrpFrFcfsWm;
-            default:
-                SC_REPORT_FATAL("Configuration", "Invalid Scheduler");
-                return Scheduler::Fifo; // Silence Warning
-            }
-        }();
-
-    if (const auto& _schedulerBuffer = mcConfig.SchedulerBuffer)
-        schedulerBuffer = [=]
-        {
-            switch (*_schedulerBuffer)
-            {
-            case DRAMSys::Config::SchedulerBufferType::Bankwise:
-                return SchedulerBuffer::Bankwise;
-            case DRAMSys::Config::SchedulerBufferType::ReadWrite:
-                return SchedulerBuffer::ReadWrite;
-            case DRAMSys::Config::SchedulerBufferType::Shared:
-                return SchedulerBuffer::Shared;
-            default:
-                SC_REPORT_FATAL("Configuration", "Invalid SchedulerBuffer");
-                return SchedulerBuffer::Bankwise; // Silence Warning
-            }
-        }();
-
-    if (const auto& _cmdMux = mcConfig.CmdMux)
-        cmdMux = [=]
-        {
-            switch (*_cmdMux)
-            {
-            case DRAMSys::Config::CmdMuxType::Oldest:
-                return CmdMux::Oldest;
-            case DRAMSys::Config::CmdMuxType::Strict:
-                return CmdMux::Strict;
-            default:
-                SC_REPORT_FATAL("Configuration", "Invalid CmdMux");
-                return CmdMux::Oldest; // Silence Warning
-            }
-        }();
-
-    if (const auto& _respQueue = mcConfig.RespQueue)
-        respQueue = [=]
-        {
-            switch (*_respQueue)
-            {
-            case DRAMSys::Config::RespQueueType::Fifo:
-                return RespQueue::Fifo;
-            case DRAMSys::Config::RespQueueType::Reorder:
-                return RespQueue::Reorder;
-            default:
-                SC_REPORT_FATAL("Configuration", "Invalid RespQueue");
-                return RespQueue::Fifo; // Silence Warning
-            }
-        }();
-
-    if (const auto& _refreshPolicy = mcConfig.RefreshPolicy)
-        refreshPolicy = [=]
-        {
-            switch (*_refreshPolicy)
-            {
-            case DRAMSys::Config::RefreshPolicyType::NoRefresh:
-                return RefreshPolicy::NoRefresh;
-            case DRAMSys::Config::RefreshPolicyType::AllBank:
-                return RefreshPolicy::AllBank;
-            case DRAMSys::Config::RefreshPolicyType::PerBank:
-                return RefreshPolicy::PerBank;
-            case DRAMSys::Config::RefreshPolicyType::Per2Bank:
-                return RefreshPolicy::Per2Bank;
-            case DRAMSys::Config::RefreshPolicyType::SameBank:
-                return RefreshPolicy::SameBank;
-            default:
-                SC_REPORT_FATAL("Configuration", "Invalid RefreshPolicy");
-                return RefreshPolicy::NoRefresh; // Silence Warning
-            }
-        }();
-
-    if (const auto& _powerDownPolicy = mcConfig.PowerDownPolicy)
-        powerDownPolicy = [=]
-        {
-            switch (*_powerDownPolicy)
-            {
-            case DRAMSys::Config::PowerDownPolicyType::NoPowerDown:
-                return PowerDownPolicy::NoPowerDown;
-            case DRAMSys::Config::PowerDownPolicyType::Staggered:
-                return PowerDownPolicy::Staggered;
-            default:
-                SC_REPORT_FATAL("Configuration", "Invalid PowerDownPolicy");
-                return PowerDownPolicy::NoPowerDown; // Silence Warning
-            }
-        }();
-
-    if (const auto& _arbiter = mcConfig.Arbiter)
-        arbiter = [=]
-        {
-            switch (*_arbiter)
-            {
-            case DRAMSys::Config::ArbiterType::Simple:
-                return Arbiter::Simple;
-            case DRAMSys::Config::ArbiterType::Fifo:
-                return Arbiter::Fifo;
-            case DRAMSys::Config::ArbiterType::Reorder:
-                return Arbiter::Reorder;
-            default:
-                SC_REPORT_FATAL("Configuration", "Invalid Arbiter");
-                return Arbiter::Simple; // Silence Warning
-            }
-        }();
-
-    refreshMaxPostponed = mcConfig.RefreshMaxPostponed.value_or(refreshMaxPostponed);
-    refreshMaxPulledin = mcConfig.RefreshMaxPulledin.value_or(refreshMaxPulledin);
-    highWatermark = mcConfig.HighWatermark.value_or(highWatermark);
-    lowWatermark = mcConfig.LowWatermark.value_or(lowWatermark);
-    maxActiveTransactions = mcConfig.MaxActiveTransactions.value_or(maxActiveTransactions);
-    refreshManagement = mcConfig.RefreshManagement.value_or(refreshManagement);
-
-    requestBufferSize = mcConfig.RequestBufferSize.value_or(requestBufferSize);
-    if (requestBufferSize == 0)
-        SC_REPORT_FATAL("Configuration", "Minimum request buffer size is 1!");
-
-    requestBufferSizeRead = mcConfig.RequestBufferSizeRead.value_or(requestBufferSizeRead);
-    if (requestBufferSizeRead == 0)
-        SC_REPORT_FATAL("Configuration", "Minimum request buffer size is 1!");
-
-    requestBufferSizeWrite = mcConfig.RequestBufferSizeWrite.value_or(requestBufferSizeWrite);
-    if (requestBufferSizeWrite == 0)
-        SC_REPORT_FATAL("Configuration", "Minimum request buffer size is 1!");
-
-    if (const auto& _arbitrationDelayFw = mcConfig.ArbitrationDelayFw)
-    {
-        arbitrationDelayFw =
-            std::round(sc_time(*_arbitrationDelayFw, SC_NS) / memSpec->tCK) * memSpec->tCK;
-    }
-
-    if (const auto& _arbitrationDelayBw = mcConfig.ArbitrationDelayBw)
-    {
-        arbitrationDelayBw =
-            std::round(sc_time(*_arbitrationDelayBw, SC_NS) / memSpec->tCK) * memSpec->tCK;
-    }
-
-    if (const auto& _thinkDelayFw = mcConfig.ThinkDelayFw)
-    {
-        thinkDelayFw = std::round(sc_time(*_thinkDelayFw, SC_NS) / memSpec->tCK) * memSpec->tCK;
-    }
-
-    if (const auto& _thinkDelayBw = mcConfig.ThinkDelayBw)
-    {
-        thinkDelayBw = std::round(sc_time(*_thinkDelayBw, SC_NS) / memSpec->tCK) * memSpec->tCK;
-    }
-
-    if (const auto& _phyDelayFw = mcConfig.PhyDelayFw)
-    {
-        phyDelayFw = std::round(sc_time(*_phyDelayFw, SC_NS) / memSpec->tCK) * memSpec->tCK;
-    }
-
-    if (const auto& _phyDelayBw = mcConfig.PhyDelayBw)
-    {
-        phyDelayBw = std::round(sc_time(*_phyDelayBw, SC_NS) / memSpec->tCK) * memSpec->tCK;
-    }
-
-    {
-        auto _blockingReadDelay = mcConfig.BlockingReadDelay.value_or(60);
-        blockingReadDelay =
-            std::round(sc_time(_blockingReadDelay, SC_NS) / memSpec->tCK) * memSpec->tCK;
-    }
-
-    {
-        auto _blockingWriteDelay = mcConfig.BlockingWriteDelay.value_or(60);
-        blockingWriteDelay =
-            std::round(sc_time(_blockingWriteDelay, SC_NS) / memSpec->tCK) * memSpec->tCK;
-    }
-}
-
-void Configuration::loadMemSpec(const DRAMSys::Config::MemSpec& memSpecConfig)
-{
-    std::string memoryType = memSpecConfig.memoryType;
-
-    if (memoryType == "DDR3")
-        memSpec = std::make_unique<const MemSpecDDR3>(memSpecConfig);
-    else if (memoryType == "DDR4")
-        memSpec = std::make_unique<const MemSpecDDR4>(memSpecConfig);
-    else if (memoryType == "LPDDR4")
-        memSpec = std::make_unique<const MemSpecLPDDR4>(memSpecConfig);
-    else if (memoryType == "WIDEIO_SDR")
-        memSpec = std::make_unique<const MemSpecWideIO>(memSpecConfig);
-    else if (memoryType == "WIDEIO2")
-        memSpec = std::make_unique<const MemSpecWideIO2>(memSpecConfig);
-    else if (memoryType == "HBM2")
-        memSpec = std::make_unique<const MemSpecHBM2>(memSpecConfig);
-    else if (memoryType == "GDDR5")
-        memSpec = std::make_unique<const MemSpecGDDR5>(memSpecConfig);
-    else if (memoryType == "GDDR5X")
-        memSpec = std::make_unique<const MemSpecGDDR5X>(memSpecConfig);
-    else if (memoryType == "GDDR6")
-        memSpec = std::make_unique<const MemSpecGDDR6>(memSpecConfig);
-    else if (memoryType == "STT-MRAM")
-        memSpec = std::make_unique<const MemSpecSTTMRAM>(memSpecConfig);
-#ifdef DDR5_SIM
-    else if (memoryType == "DDR5")
-        memSpec = std::make_unique<const MemSpecDDR5>(memSpecConfig);
-#endif
-#ifdef LPDDR5_SIM
-    else if (memoryType == "LPDDR5")
-        memSpec = std::make_unique<const MemSpecLPDDR5>(memSpecConfig);
-#endif
-#ifdef HBM3_SIM
-    else if (memoryType == "HBM3")
-        memSpec = std::make_unique<const MemSpecHBM3>(memSpecConfig);
-#endif
-    else
-        SC_REPORT_FATAL("Configuration", "Unsupported DRAM type");
-}
-
-} // namespace DRAMSys
diff --git a/src/libdramsys/DRAMSys/configuration/Configuration.h b/src/libdramsys/DRAMSys/configuration/Configuration.h
deleted file mode 100644
index 930c78c5..00000000
--- a/src/libdramsys/DRAMSys/configuration/Configuration.h
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Copyright (c) 2015, 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.
- *
- * Authors:
- *    Janik Schlemminger
- *    Matthias Jung
- *    Eder F. Zulian
- *    Felipe S. Prado
- *    Lukas Steiner
- *    Luiza Correa
- *    Derek Christ
- *    Thomas Psota
- */
-
-#ifndef CONFIGURATION_H
-#define CONFIGURATION_H
-
-#include "DRAMSys/config/DRAMSysConfiguration.h"
-#include "DRAMSys/configuration/memspec/MemSpec.h"
-
-#include <string>
-#include <systemc>
-
-namespace DRAMSys
-{
-
-class Configuration
-{
-public:
-    // MCConfig:
-    enum class PagePolicy
-    {
-        Open,
-        Closed,
-        OpenAdaptive,
-        ClosedAdaptive
-    } pagePolicy = PagePolicy::Open;
-    enum class Scheduler
-    {
-        Fifo,
-        FrFcfs,
-        FrFcfsGrp,
-        GrpFrFcfs,
-        GrpFrFcfsWm
-    } scheduler = Scheduler::FrFcfs;
-    enum class SchedulerBuffer
-    {
-        Bankwise,
-        ReadWrite,
-        Shared
-    } schedulerBuffer = SchedulerBuffer::Bankwise;
-    unsigned int lowWatermark = 0;
-    unsigned int highWatermark = 0;
-    enum class CmdMux
-    {
-        Oldest,
-        Strict
-    } cmdMux = CmdMux::Oldest;
-    enum class RespQueue
-    {
-        Fifo,
-        Reorder
-    } respQueue = RespQueue::Fifo;
-    enum class Arbiter
-    {
-        Simple,
-        Fifo,
-        Reorder
-    } arbiter = Arbiter::Simple;
-    unsigned int requestBufferSize = 8;
-    unsigned int requestBufferSizeRead = 8;
-    unsigned int requestBufferSizeWrite = 8;
-    enum class RefreshPolicy
-    {
-        NoRefresh,
-        PerBank,
-        Per2Bank,
-        SameBank,
-        AllBank
-    } refreshPolicy = RefreshPolicy::AllBank;
-    unsigned int refreshMaxPostponed = 0;
-    unsigned int refreshMaxPulledin = 0;
-    enum class PowerDownPolicy
-    {
-        NoPowerDown,
-        Staggered
-    } powerDownPolicy = PowerDownPolicy::NoPowerDown;
-    unsigned int maxActiveTransactions = 64;
-    bool refreshManagement = false;
-    sc_core::sc_time arbitrationDelayFw = sc_core::SC_ZERO_TIME;
-    sc_core::sc_time arbitrationDelayBw = sc_core::SC_ZERO_TIME;
-    sc_core::sc_time thinkDelayFw = sc_core::SC_ZERO_TIME;
-    sc_core::sc_time thinkDelayBw = sc_core::SC_ZERO_TIME;
-    sc_core::sc_time phyDelayFw = sc_core::SC_ZERO_TIME;
-    sc_core::sc_time phyDelayBw = sc_core::SC_ZERO_TIME;
-    sc_core::sc_time blockingReadDelay = sc_core::SC_ZERO_TIME;
-    sc_core::sc_time blockingWriteDelay = sc_core::SC_ZERO_TIME;
-
-    // SimConfig
-    std::string simulationName = "default";
-    bool databaseRecording = false;
-    bool powerAnalysis = false;
-    bool enableWindowing = false;
-    unsigned int windowSize = 1000;
-    bool debug = false;
-    bool simulationProgressBar = false;
-    bool checkTLM2Protocol = false;
-    bool useMalloc = false;
-    unsigned long long int addressOffset = 0;
-
-    enum class StoreMode
-    {
-        NoStorage,
-        Store
-    } storeMode = StoreMode::NoStorage;
-
-    // MemSpec (from DRAM-Power)
-    std::unique_ptr<const MemSpec> memSpec;
-
-    void loadMCConfig(const DRAMSys::Config::McConfig& mcConfig);
-    void loadSimConfig(const DRAMSys::Config::SimConfig& simConfig);
-    void loadMemSpec(const DRAMSys::Config::MemSpec& memSpec);
-};
-
-} // namespace DRAMSys
-
-#endif // CONFIGURATION_H
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpec.cpp b/src/libdramsys/DRAMSys/configuration/memspec/MemSpec.cpp
index f9845d98..11c5df79 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpec.cpp
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpec.cpp
@@ -42,8 +42,7 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpec::MemSpec(const DRAMSys::Config::MemSpec& memSpec,
-                 MemoryType memoryType,
+MemSpec::MemSpec(const Config::MemSpec& memSpec,
                  unsigned numberOfChannels,
                  unsigned pseudoChannelsPerChannel,
                  unsigned ranksPerChannel,
@@ -77,7 +76,7 @@ MemSpec::MemSpec(const DRAMSys::Config::MemSpec& memSpec,
     maxBytesPerBurst((maxBurstLength * dataBusWidth) / 8),
     tCK(sc_time(memSpec.memtimingspec.entries.at("tCK"), SC_PS)),
     memoryId(memSpec.memoryId),
-    memoryType(memoryType),
+    memoryType(memSpec.memoryType),
     burstDuration(tCK * (static_cast<double>(defaultBurstLength) / dataRate))
 
 {
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpec.h b/src/libdramsys/DRAMSys/configuration/memspec/MemSpec.h
index 5e574a4d..e489ac3e 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpec.h
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpec.h
@@ -41,6 +41,7 @@
 
 #include "DRAMSys/common/utils.h"
 #include "DRAMSys/config/DRAMSysConfiguration.h"
+#include "DRAMSys/config/memspec/MemSpec.h"
 #include "DRAMSys/controller/Command.h"
 
 #include <string>
@@ -86,21 +87,7 @@ public:
     const sc_core::sc_time tCK;
 
     const std::string memoryId;
-    const enum class MemoryType {
-        DDR3,
-        DDR4,
-        DDR5,
-        LPDDR4,
-        LPDDR5,
-        WideIO,
-        WideIO2,
-        GDDR5,
-        GDDR5X,
-        GDDR6,
-        HBM2,
-        HBM3,
-        STTMRAM
-    } memoryType;
+    const Config::MemoryType memoryType;
 
     [[nodiscard]] virtual sc_core::sc_time getRefreshIntervalAB() const;
     [[nodiscard]] virtual sc_core::sc_time getRefreshIntervalPB() const;
@@ -130,8 +117,7 @@ public:
 #endif
 
 protected:
-    MemSpec(const DRAMSys::Config::MemSpec& memSpec,
-            MemoryType memoryType,
+    MemSpec(const Config::MemSpec& memSpec,
             unsigned numberOfChannels,
             unsigned pseudoChannelsPerChannel,
             unsigned ranksPerChannel,
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR3.cpp b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR3.cpp
index e7f9a764..b1e5015a 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR3.cpp
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR3.cpp
@@ -46,9 +46,8 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpecDDR3::MemSpecDDR3(const DRAMSys::Config::MemSpec& memSpec) :
+MemSpecDDR3::MemSpecDDR3(const Config::MemSpec& memSpec) :
     MemSpec(memSpec,
-            MemoryType::DDR3,
             memSpec.memarchitecturespec.entries.at("nbrOfChannels"),
             1,
             memSpec.memarchitecturespec.entries.at("nbrOfRanks"),
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR3.h b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR3.h
index ec297f78..b94abcfd 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR3.h
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR3.h
@@ -48,7 +48,7 @@ namespace DRAMSys
 class MemSpecDDR3 final : public MemSpec
 {
 public:
-    explicit MemSpecDDR3(const DRAMSys::Config::MemSpec& memSpec);
+    explicit MemSpecDDR3(const Config::MemSpec& memSpec);
 
     // Memspec Variables:
     const sc_core::sc_time tCKE;
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR4.cpp b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR4.cpp
index 23d227a1..534398b3 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR4.cpp
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR4.cpp
@@ -46,9 +46,8 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpecDDR4::MemSpecDDR4(const DRAMSys::Config::MemSpec& memSpec) :
+MemSpecDDR4::MemSpecDDR4(const Config::MemSpec& memSpec) :
     MemSpec(memSpec,
-            MemoryType::DDR4,
             memSpec.memarchitecturespec.entries.at("nbrOfChannels"),
             1,
             memSpec.memarchitecturespec.entries.at("nbrOfRanks"),
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR4.h b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR4.h
index 361a44c4..9e2949ad 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR4.h
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecDDR4.h
@@ -47,7 +47,7 @@ namespace DRAMSys
 class MemSpecDDR4 final : public MemSpec
 {
 public:
-    explicit MemSpecDDR4(const DRAMSys::Config::MemSpec& memSpec);
+    explicit MemSpecDDR4(const Config::MemSpec& memSpec);
 
     // Memspec Variables:
     const sc_core::sc_time tCKE;
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5.cpp b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5.cpp
index 5aa3fd50..769223a8 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5.cpp
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5.cpp
@@ -46,9 +46,8 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpecGDDR5::MemSpecGDDR5(const DRAMSys::Config::MemSpec& memSpec) :
+MemSpecGDDR5::MemSpecGDDR5(const Config::MemSpec& memSpec) :
     MemSpec(memSpec,
-            MemoryType::GDDR5,
             memSpec.memarchitecturespec.entries.at("nbrOfChannels"),
             1,
             memSpec.memarchitecturespec.entries.at("nbrOfRanks"),
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5.h b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5.h
index 149a3796..0f8a8497 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5.h
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5.h
@@ -47,7 +47,7 @@ namespace DRAMSys
 class MemSpecGDDR5 final : public MemSpec
 {
 public:
-    explicit MemSpecGDDR5(const DRAMSys::Config::MemSpec& memSpec);
+    explicit MemSpecGDDR5(const Config::MemSpec& memSpec);
 
     // Memspec Variables:
     const sc_core::sc_time tRP;
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5X.cpp b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5X.cpp
index 39653b38..6a044877 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5X.cpp
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5X.cpp
@@ -46,9 +46,8 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpecGDDR5X::MemSpecGDDR5X(const DRAMSys::Config::MemSpec& memSpec) :
+MemSpecGDDR5X::MemSpecGDDR5X(const Config::MemSpec& memSpec) :
     MemSpec(memSpec,
-            MemoryType::GDDR5X,
             memSpec.memarchitecturespec.entries.at("nbrOfChannels"),
             1,
             memSpec.memarchitecturespec.entries.at("nbrOfRanks"),
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5X.h b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5X.h
index e86de47b..1536ef93 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5X.h
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR5X.h
@@ -47,7 +47,7 @@ namespace DRAMSys
 class MemSpecGDDR5X final : public MemSpec
 {
 public:
-    explicit MemSpecGDDR5X(const DRAMSys::Config::MemSpec& memSpec);
+    explicit MemSpecGDDR5X(const Config::MemSpec& memSpec);
 
     // Memspec Variables:
     const sc_core::sc_time tRP;
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR6.cpp b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR6.cpp
index a337ac54..efecb9c6 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR6.cpp
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR6.cpp
@@ -46,9 +46,8 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpecGDDR6::MemSpecGDDR6(const DRAMSys::Config::MemSpec& memSpec) :
+MemSpecGDDR6::MemSpecGDDR6(const Config::MemSpec& memSpec) :
     MemSpec(memSpec,
-            MemoryType::GDDR6,
             memSpec.memarchitecturespec.entries.at("nbrOfChannels"),
             1,
             memSpec.memarchitecturespec.entries.at("nbrOfRanks"),
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR6.h b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR6.h
index 404d7462..4cba78d4 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR6.h
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecGDDR6.h
@@ -46,7 +46,7 @@ namespace DRAMSys
 struct MemSpecGDDR6 final : public MemSpec
 {
 public:
-    explicit MemSpecGDDR6(const DRAMSys::Config::MemSpec& memSpec);
+    explicit MemSpecGDDR6(const Config::MemSpec& memSpec);
 
     // Memspec Variables:
     const sc_core::sc_time tRP;
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecHBM2.cpp b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecHBM2.cpp
index a766f9b1..57de0491 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecHBM2.cpp
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecHBM2.cpp
@@ -46,9 +46,8 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpecHBM2::MemSpecHBM2(const DRAMSys::Config::MemSpec& memSpec) :
+MemSpecHBM2::MemSpecHBM2(const Config::MemSpec& memSpec) :
     MemSpec(memSpec,
-            MemoryType::HBM2,
             memSpec.memarchitecturespec.entries.at("nbrOfChannels"),
             memSpec.memarchitecturespec.entries.at("nbrOfPseudoChannels"),
             memSpec.memarchitecturespec.entries.at("nbrOfPseudoChannels"),
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecHBM2.h b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecHBM2.h
index ec435978..fa2b2a33 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecHBM2.h
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecHBM2.h
@@ -47,7 +47,7 @@ namespace DRAMSys
 class MemSpecHBM2 final : public MemSpec
 {
 public:
-    explicit MemSpecHBM2(const DRAMSys::Config::MemSpec& memSpec);
+    explicit MemSpecHBM2(const Config::MemSpec& memSpec);
 
     // Memspec Variables:
     const sc_core::sc_time tDQSCK;
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecLPDDR4.cpp b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecLPDDR4.cpp
index 57fa74c8..dcc813fa 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecLPDDR4.cpp
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecLPDDR4.cpp
@@ -46,9 +46,8 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpecLPDDR4::MemSpecLPDDR4(const DRAMSys::Config::MemSpec& memSpec) :
+MemSpecLPDDR4::MemSpecLPDDR4(const Config::MemSpec& memSpec) :
     MemSpec(memSpec,
-            MemoryType::LPDDR4,
             memSpec.memarchitecturespec.entries.at("nbrOfChannels"),
             1,
             memSpec.memarchitecturespec.entries.at("nbrOfRanks"),
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecLPDDR4.h b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecLPDDR4.h
index b88a235c..82913340 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecLPDDR4.h
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecLPDDR4.h
@@ -47,7 +47,7 @@ namespace DRAMSys
 class MemSpecLPDDR4 final : public MemSpec
 {
 public:
-    explicit MemSpecLPDDR4(const DRAMSys::Config::MemSpec& memSpec);
+    explicit MemSpecLPDDR4(const Config::MemSpec& memSpec);
 
     // Memspec Variables:
     const sc_core::sc_time tREFI;
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecSTTMRAM.cpp b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecSTTMRAM.cpp
index e3593450..51070be9 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecSTTMRAM.cpp
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecSTTMRAM.cpp
@@ -46,9 +46,8 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpecSTTMRAM::MemSpecSTTMRAM(const DRAMSys::Config::MemSpec& memSpec) :
+MemSpecSTTMRAM::MemSpecSTTMRAM(const Config::MemSpec& memSpec) :
     MemSpec(memSpec,
-            MemoryType::STTMRAM,
             memSpec.memarchitecturespec.entries.at("nbrOfChannels"),
             1,
             memSpec.memarchitecturespec.entries.at("nbrOfRanks"),
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecSTTMRAM.h b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecSTTMRAM.h
index e6c53f02..ba5064a5 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecSTTMRAM.h
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecSTTMRAM.h
@@ -47,7 +47,7 @@ namespace DRAMSys
 class MemSpecSTTMRAM final : public MemSpec
 {
 public:
-    explicit MemSpecSTTMRAM(const DRAMSys::Config::MemSpec& memSpec);
+    explicit MemSpecSTTMRAM(const Config::MemSpec& memSpec);
 
     // Memspec Variables:
     const sc_core::sc_time tCKE;
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO.cpp b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO.cpp
index 1dc56694..042fd130 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO.cpp
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO.cpp
@@ -46,9 +46,8 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpecWideIO::MemSpecWideIO(const DRAMSys::Config::MemSpec& memSpec) :
+MemSpecWideIO::MemSpecWideIO(const Config::MemSpec& memSpec) :
     MemSpec(memSpec,
-            MemoryType::WideIO,
             memSpec.memarchitecturespec.entries.at("nbrOfChannels"),
             1,
             memSpec.memarchitecturespec.entries.at("nbrOfRanks"),
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO.h b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO.h
index 12eafeb1..ed80398f 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO.h
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO.h
@@ -47,7 +47,7 @@ namespace DRAMSys
 class MemSpecWideIO final : public MemSpec
 {
 public:
-    explicit MemSpecWideIO(const DRAMSys::Config::MemSpec& memSpec);
+    explicit MemSpecWideIO(const Config::MemSpec& memSpec);
 
     // Memspec Variables:
     const sc_core::sc_time tCKE;
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO2.cpp b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO2.cpp
index 15b0e8b4..3fc327ce 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO2.cpp
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO2.cpp
@@ -46,9 +46,8 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-MemSpecWideIO2::MemSpecWideIO2(const DRAMSys::Config::MemSpec& memSpec) :
+MemSpecWideIO2::MemSpecWideIO2(const Config::MemSpec& memSpec) :
     MemSpec(memSpec,
-            MemoryType::WideIO2,
             memSpec.memarchitecturespec.entries.at("nbrOfChannels"),
             1,
             memSpec.memarchitecturespec.entries.at("nbrOfRanks"),
diff --git a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO2.h b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO2.h
index 19e32455..cf171492 100644
--- a/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO2.h
+++ b/src/libdramsys/DRAMSys/configuration/memspec/MemSpecWideIO2.h
@@ -47,7 +47,7 @@ namespace DRAMSys
 class MemSpecWideIO2 final : public MemSpec
 {
 public:
-    explicit MemSpecWideIO2(const DRAMSys::Config::MemSpec& memSpec);
+    explicit MemSpecWideIO2(const Config::MemSpec& memSpec);
 
     // Memspec Variables:
     const sc_core::sc_time tDQSCK;
diff --git a/src/libdramsys/DRAMSys/controller/BankMachine.cpp b/src/libdramsys/DRAMSys/controller/BankMachine.cpp
index 288b816e..0639010a 100644
--- a/src/libdramsys/DRAMSys/controller/BankMachine.cpp
+++ b/src/libdramsys/DRAMSys/controller/BankMachine.cpp
@@ -34,8 +34,6 @@
 
 #include "BankMachine.h"
 
-#include "DRAMSys/configuration/Configuration.h"
-
 #include <algorithm>
 
 using namespace sc_core;
@@ -44,8 +42,11 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-BankMachine::BankMachine(const Configuration& config, const SchedulerIF& scheduler, Bank bank) :
-    memSpec(*config.memSpec),
+BankMachine::BankMachine(const McConfig& config,
+                         const MemSpec& memSpec,
+                         const SchedulerIF& scheduler,
+                         Bank bank) :
+    memSpec(memSpec),
     scheduler(scheduler),
     bank(bank),
     bankgroup(BankGroup(static_cast<std::size_t>(bank) / memSpec.banksPerGroup)),
@@ -181,10 +182,11 @@ bool BankMachine::isPrecharged() const
     return state == State::Precharged;
 }
 
-BankMachineOpen::BankMachineOpen(const Configuration& config,
+BankMachineOpen::BankMachineOpen(const McConfig& config,
+                                 const MemSpec& memSpec,
                                  const SchedulerIF& scheduler,
                                  Bank bank) :
-    BankMachine(config, scheduler, bank)
+    BankMachine(config, memSpec, scheduler, bank)
 {
 }
 
@@ -230,10 +232,11 @@ void BankMachineOpen::evaluate()
     }
 }
 
-BankMachineClosed::BankMachineClosed(const Configuration& config,
+BankMachineClosed::BankMachineClosed(const McConfig& config,
+                                     const MemSpec& memSpec,
                                      const SchedulerIF& scheduler,
                                      Bank bank) :
-    BankMachine(config, scheduler, bank)
+    BankMachine(config, memSpec, scheduler, bank)
 {
 }
 
@@ -274,10 +277,11 @@ void BankMachineClosed::evaluate()
     }
 }
 
-BankMachineOpenAdaptive::BankMachineOpenAdaptive(const Configuration& config,
+BankMachineOpenAdaptive::BankMachineOpenAdaptive(const McConfig& config,
+                                                 const MemSpec& memSpec,
                                                  const SchedulerIF& scheduler,
                                                  Bank bank) :
-    BankMachine(config, scheduler, bank)
+    BankMachine(config, memSpec, scheduler, bank)
 {
 }
 
@@ -338,10 +342,11 @@ void BankMachineOpenAdaptive::evaluate()
     }
 }
 
-BankMachineClosedAdaptive::BankMachineClosedAdaptive(const Configuration& config,
+BankMachineClosedAdaptive::BankMachineClosedAdaptive(const McConfig& config,
+                                                     const MemSpec& memSpec,
                                                      const SchedulerIF& scheduler,
                                                      Bank bank) :
-    BankMachine(config, scheduler, bank)
+    BankMachine(config, memSpec, scheduler, bank)
 {
 }
 
diff --git a/src/libdramsys/DRAMSys/controller/BankMachine.h b/src/libdramsys/DRAMSys/controller/BankMachine.h
index 00d805f2..a034c2ca 100644
--- a/src/libdramsys/DRAMSys/controller/BankMachine.h
+++ b/src/libdramsys/DRAMSys/controller/BankMachine.h
@@ -36,10 +36,10 @@
 #define BANKMACHINE_H
 
 #include "DRAMSys/common/dramExtensions.h"
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpec.h"
 #include "DRAMSys/controller/Command.h"
 #include "DRAMSys/controller/ManagerIF.h"
+#include "DRAMSys/controller/McConfig.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 #include "DRAMSys/controller/scheduler/SchedulerIF.h"
 
@@ -71,7 +71,7 @@ protected:
         Precharged,
         Activated
     } state = State::Precharged;
-    BankMachine(const Configuration& config, const SchedulerIF& scheduler, Bank bank);
+    BankMachine(const McConfig& config, const MemSpec& memSpec, const SchedulerIF& scheduler, Bank bank);
     const MemSpec& memSpec;
     tlm::tlm_generic_payload* currentPayload = nullptr;
     const SchedulerIF& scheduler;
@@ -90,28 +90,28 @@ protected:
 class BankMachineOpen final : public BankMachine
 {
 public:
-    BankMachineOpen(const Configuration& config, const SchedulerIF& scheduler, Bank bank);
+    BankMachineOpen(const McConfig& config, const MemSpec& memSpec, const SchedulerIF& scheduler, Bank bank);
     void evaluate() override;
 };
 
 class BankMachineClosed final : public BankMachine
 {
 public:
-    BankMachineClosed(const Configuration& config, const SchedulerIF& scheduler, Bank bank);
+    BankMachineClosed(const McConfig& config, const MemSpec& memSpec, const SchedulerIF& scheduler, Bank bank);
     void evaluate() override;
 };
 
 class BankMachineOpenAdaptive final : public BankMachine
 {
 public:
-    BankMachineOpenAdaptive(const Configuration& config, const SchedulerIF& scheduler, Bank bank);
+    BankMachineOpenAdaptive(const McConfig& config, const MemSpec& memSpec, const SchedulerIF& scheduler, Bank bank);
     void evaluate() override;
 };
 
 class BankMachineClosedAdaptive final : public BankMachine
 {
 public:
-    BankMachineClosedAdaptive(const Configuration& config, const SchedulerIF& scheduler, Bank bank);
+    BankMachineClosedAdaptive(const McConfig& config, const MemSpec& memSpec, const SchedulerIF& scheduler, Bank bank);
     void evaluate() override;
 };
 
diff --git a/src/libdramsys/DRAMSys/controller/Controller.cpp b/src/libdramsys/DRAMSys/controller/Controller.cpp
index fedc589c..99aa20cf 100644
--- a/src/libdramsys/DRAMSys/controller/Controller.cpp
+++ b/src/libdramsys/DRAMSys/controller/Controller.cpp
@@ -29,13 +29,15 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * Author: Lukas Steiner
+ * Authors:
+ *    Lukas Steiner
+ *    Derek Christ
  */
 
 #include "Controller.h"
 
 #include "DRAMSys/common/dramExtensions.h"
-#include "DRAMSys/configuration/Configuration.h"
+#include "DRAMSys/config/McConfig.h"
 #include "DRAMSys/controller/checker/CheckerDDR3.h"
 #include "DRAMSys/controller/checker/CheckerDDR4.h"
 #include "DRAMSys/controller/checker/CheckerGDDR5.h"
@@ -80,117 +82,156 @@ namespace DRAMSys
 {
 
 Controller::Controller(const sc_module_name& name,
-                       const Configuration& config,
+                       const McConfig& config,
+                       const MemSpec& memSpec,
                        const AddressDecoder& addressDecoder) :
-    ControllerIF(name, config),
-    thinkDelayFw(config.thinkDelayFw),
-    thinkDelayBw(config.thinkDelayBw),
-    phyDelayFw(config.phyDelayFw),
-    phyDelayBw(config.phyDelayBw),
-    blockingReadDelay(config.blockingReadDelay),
-    blockingWriteDelay(config.blockingWriteDelay),
+    sc_module(name),
+    config(config),
+    memSpec(memSpec),
     addressDecoder(addressDecoder),
-    minBytesPerBurst(config.memSpec->defaultBytesPerBurst),
-    maxBytesPerBurst(config.memSpec->maxBytesPerBurst)
+    minBytesPerBurst(memSpec.defaultBytesPerBurst),
+    maxBytesPerBurst(memSpec.maxBytesPerBurst)
 {
     SC_METHOD(controllerMethod);
     sensitive << beginReqEvent << endRespEvent << controllerEvent << dataResponseEvent;
 
+    tSocket.register_nb_transport_fw(this, &Controller::nb_transport_fw);
+    tSocket.register_transport_dbg(this, &Controller::transport_dbg);
+    tSocket.register_b_transport(this, &Controller::b_transport);
+    iSocket.register_nb_transport_bw(this, &Controller::nb_transport_bw);
+
+    idleTimeCollector.start();
+
     ranksNumberOfPayloads = ControllerVector<Rank, unsigned>(memSpec.ranksPerChannel);
 
     // reserve buffer for command tuples
     readyCommands.reserve(memSpec.banksPerChannel);
 
     // instantiate timing checker
-    if (memSpec.memoryType == MemSpec::MemoryType::DDR3)
-        checker = std::make_unique<CheckerDDR3>(config);
-    else if (memSpec.memoryType == MemSpec::MemoryType::DDR4)
-        checker = std::make_unique<CheckerDDR4>(config);
-    else if (memSpec.memoryType == MemSpec::MemoryType::WideIO)
-        checker = std::make_unique<CheckerWideIO>(config);
-    else if (memSpec.memoryType == MemSpec::MemoryType::LPDDR4)
-        checker = std::make_unique<CheckerLPDDR4>(config);
-    else if (memSpec.memoryType == MemSpec::MemoryType::WideIO2)
-        checker = std::make_unique<CheckerWideIO2>(config);
-    else if (memSpec.memoryType == MemSpec::MemoryType::HBM2)
-        checker = std::make_unique<CheckerHBM2>(config);
-    else if (memSpec.memoryType == MemSpec::MemoryType::GDDR5)
-        checker = std::make_unique<CheckerGDDR5>(config);
-    else if (memSpec.memoryType == MemSpec::MemoryType::GDDR5X)
-        checker = std::make_unique<CheckerGDDR5X>(config);
-    else if (memSpec.memoryType == MemSpec::MemoryType::GDDR6)
-        checker = std::make_unique<CheckerGDDR6>(config);
-    else if (memSpec.memoryType == MemSpec::MemoryType::STTMRAM)
-        checker = std::make_unique<CheckerSTTMRAM>(config);
+    try
+    {
+        if (memSpec.memoryType == Config::MemoryType::DDR3)
+        {
+            checker = std::make_unique<CheckerDDR3>(dynamic_cast<const MemSpecDDR3&>(memSpec));
+        }
+        else if (memSpec.memoryType == Config::MemoryType::DDR4)
+        {
+            checker = std::make_unique<CheckerDDR4>(dynamic_cast<const MemSpecDDR4&>(memSpec));
+        }
+        else if (memSpec.memoryType == Config::MemoryType::WideIO)
+        {
+            checker = std::make_unique<CheckerWideIO>(dynamic_cast<const MemSpecWideIO&>(memSpec));
+        }
+        else if (memSpec.memoryType == Config::MemoryType::LPDDR4)
+        {
+            checker = std::make_unique<CheckerLPDDR4>(dynamic_cast<const MemSpecLPDDR4&>(memSpec));
+        }
+        else if (memSpec.memoryType == Config::MemoryType::WideIO2)
+        {
+            checker =
+                std::make_unique<CheckerWideIO2>(dynamic_cast<const MemSpecWideIO2&>(memSpec));
+        }
+        else if (memSpec.memoryType == Config::MemoryType::HBM2)
+        {
+            checker = std::make_unique<CheckerHBM2>(dynamic_cast<const MemSpecHBM2&>(memSpec));
+        }
+        else if (memSpec.memoryType == Config::MemoryType::GDDR5)
+        {
+            checker = std::make_unique<CheckerGDDR5>(dynamic_cast<const MemSpecGDDR5&>(memSpec));
+        }
+        else if (memSpec.memoryType == Config::MemoryType::GDDR5X)
+        {
+            checker = std::make_unique<CheckerGDDR5X>(dynamic_cast<const MemSpecGDDR5X&>(memSpec));
+        }
+        else if (memSpec.memoryType == Config::MemoryType::GDDR6)
+        {
+            checker = std::make_unique<CheckerGDDR6>(dynamic_cast<const MemSpecGDDR6&>(memSpec));
+        }
+        else if (memSpec.memoryType == Config::MemoryType::STTMRAM)
+        {
+            checker =
+                std::make_unique<CheckerSTTMRAM>(dynamic_cast<const MemSpecSTTMRAM&>(memSpec));
+        }
 #ifdef DDR5_SIM
-    else if (memSpec.memoryType == MemSpec::MemoryType::DDR5)
-        checker = std::make_unique<CheckerDDR5>(config);
+        else if (memSpec.memoryType == Config::MemoryType::DDR5)
+        {
+            checker = std::make_unique<CheckerDDR5>(dynamic_cast<const MemSpecDDR5&>(memSpec));
+        }
 #endif
 #ifdef LPDDR5_SIM
-    else if (memSpec.memoryType == MemSpec::MemoryType::LPDDR5)
-        checker = std::make_unique<CheckerLPDDR5>(config);
+        else if (memSpec.memoryType == Config::MemoryType::LPDDR5)
+        {
+            checker = std::make_unique<CheckerLPDDR5>(dynamic_cast<const MemSpecLPDDR5&>(memSpec));
+        }
 #endif
 #ifdef HBM3_SIM
-    else if (memSpec.memoryType == MemSpec::MemoryType::HBM3)
-        checker = std::make_unique<CheckerHBM3>(config);
+        else if (memSpec.memoryType == Config::MemoryType::HBM3)
+        {
+            checker = std::make_unique<CheckerHBM3>(dynamic_cast<const MemSpecHBM3&>(memSpec));
+        }
 #endif
+    }
+    catch (const std::bad_cast& e)
+    {
+        SC_REPORT_FATAL(sc_module::name(), "Wrong MemSpec chosen");
+    }
 
     // instantiate scheduler and command mux
-    if (config.scheduler == Configuration::Scheduler::Fifo)
-        scheduler = std::make_unique<SchedulerFifo>(config);
-    else if (config.scheduler == Configuration::Scheduler::FrFcfs)
-        scheduler = std::make_unique<SchedulerFrFcfs>(config);
-    else if (config.scheduler == Configuration::Scheduler::FrFcfsGrp)
-        scheduler = std::make_unique<SchedulerFrFcfsGrp>(config);
-    else if (config.scheduler == Configuration::Scheduler::GrpFrFcfs)
-        scheduler = std::make_unique<SchedulerGrpFrFcfs>(config);
-    else if (config.scheduler == Configuration::Scheduler::GrpFrFcfsWm)
-        scheduler = std::make_unique<SchedulerGrpFrFcfsWm>(config);
+    if (config.scheduler == Config::SchedulerType::Fifo)
+        scheduler = std::make_unique<SchedulerFifo>(config, memSpec);
+    else if (config.scheduler == Config::SchedulerType::FrFcfs)
+        scheduler = std::make_unique<SchedulerFrFcfs>(config, memSpec);
+    else if (config.scheduler == Config::SchedulerType::FrFcfsGrp)
+        scheduler = std::make_unique<SchedulerFrFcfsGrp>(config, memSpec);
+    else if (config.scheduler == Config::SchedulerType::GrpFrFcfs)
+        scheduler = std::make_unique<SchedulerGrpFrFcfs>(config, memSpec);
+    else if (config.scheduler == Config::SchedulerType::GrpFrFcfsWm)
+        scheduler = std::make_unique<SchedulerGrpFrFcfsWm>(config, memSpec);
 
-    if (config.cmdMux == Configuration::CmdMux::Oldest)
+    if (config.cmdMux == Config::CmdMuxType::Oldest)
     {
         if (memSpec.hasRasAndCasBus())
-            cmdMux = std::make_unique<CmdMuxOldestRasCas>(config);
+            cmdMux = std::make_unique<CmdMuxOldestRasCas>(memSpec);
         else
-            cmdMux = std::make_unique<CmdMuxOldest>(config);
+            cmdMux = std::make_unique<CmdMuxOldest>(memSpec);
     }
-    else if (config.cmdMux == Configuration::CmdMux::Strict)
+    else if (config.cmdMux == Config::CmdMuxType::Strict)
     {
         if (memSpec.hasRasAndCasBus())
-            cmdMux = std::make_unique<CmdMuxStrictRasCas>(config);
+            cmdMux = std::make_unique<CmdMuxStrictRasCas>(memSpec);
         else
-            cmdMux = std::make_unique<CmdMuxStrict>(config);
+            cmdMux = std::make_unique<CmdMuxStrict>(memSpec);
     }
 
-    if (config.respQueue == Configuration::RespQueue::Fifo)
+    if (config.respQueue == Config::RespQueueType::Fifo)
         respQueue = std::make_unique<RespQueueFifo>();
-    else if (config.respQueue == Configuration::RespQueue::Reorder)
+    else if (config.respQueue == Config::RespQueueType::Reorder)
         respQueue = std::make_unique<RespQueueReorder>();
 
     // instantiate bank machines (one per bank)
-    if (config.pagePolicy == Configuration::PagePolicy::Open)
+    if (config.pagePolicy == Config::PagePolicyType::Open)
     {
         for (unsigned bankID = 0; bankID < memSpec.banksPerChannel; bankID++)
             bankMachines.push_back(
-                std::make_unique<BankMachineOpen>(config, *scheduler, Bank(bankID)));
+                std::make_unique<BankMachineOpen>(config, memSpec, *scheduler, Bank(bankID)));
     }
-    else if (config.pagePolicy == Configuration::PagePolicy::OpenAdaptive)
+    else if (config.pagePolicy == Config::PagePolicyType::OpenAdaptive)
     {
         for (unsigned bankID = 0; bankID < memSpec.banksPerChannel; bankID++)
-            bankMachines.push_back(
-                std::make_unique<BankMachineOpenAdaptive>(config, *scheduler, Bank(bankID)));
+            bankMachines.push_back(std::make_unique<BankMachineOpenAdaptive>(
+                config, memSpec, *scheduler, Bank(bankID)));
     }
-    else if (config.pagePolicy == Configuration::PagePolicy::Closed)
+    else if (config.pagePolicy == Config::PagePolicyType::Closed)
     {
         for (unsigned bankID = 0; bankID < memSpec.banksPerChannel; bankID++)
             bankMachines.push_back(
-                std::make_unique<BankMachineClosed>(config, *scheduler, Bank(bankID)));
+                std::make_unique<BankMachineClosed>(config, memSpec, *scheduler, Bank(bankID)));
     }
-    else if (config.pagePolicy == Configuration::PagePolicy::ClosedAdaptive)
+    else if (config.pagePolicy == Config::PagePolicyType::ClosedAdaptive)
     {
         for (unsigned bankID = 0; bankID < memSpec.banksPerChannel; bankID++)
-            bankMachines.push_back(
-                std::make_unique<BankMachineClosedAdaptive>(config, *scheduler, Bank(bankID)));
+            bankMachines.push_back(std::make_unique<BankMachineClosedAdaptive>(
+                config, memSpec, *scheduler, Bank(bankID)));
     }
 
     bankMachinesOnRank = ControllerVector<Rank, ControllerVector<Bank, BankMachine*>>(
@@ -203,12 +244,12 @@ Controller::Controller(const sc_module_name& name,
     }
 
     // instantiate power-down managers (one per rank)
-    if (config.powerDownPolicy == Configuration::PowerDownPolicy::NoPowerDown)
+    if (config.powerDownPolicy == Config::PowerDownPolicyType::NoPowerDown)
     {
         for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
             powerDownManagers.push_back(std::make_unique<PowerDownManagerDummy>());
     }
-    else if (config.powerDownPolicy == Configuration::PowerDownPolicy::Staggered)
+    else if (config.powerDownPolicy == Config::PowerDownPolicyType::Staggered)
     {
         for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
         {
@@ -218,52 +259,56 @@ Controller::Controller(const sc_module_name& name,
     }
 
     // instantiate refresh managers (one per rank)
-    if (config.refreshPolicy == Configuration::RefreshPolicy::NoRefresh)
+    if (config.refreshPolicy == Config::RefreshPolicyType::NoRefresh)
     {
         for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
             refreshManagers.push_back(std::make_unique<RefreshManagerDummy>());
     }
-    else if (config.refreshPolicy == Configuration::RefreshPolicy::AllBank)
+    else if (config.refreshPolicy == Config::RefreshPolicyType::AllBank)
     {
         for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
         {
             refreshManagers.push_back(
                 std::make_unique<RefreshManagerAllBank>(config,
+                                                        memSpec,
                                                         bankMachinesOnRank[Rank(rankID)],
                                                         *powerDownManagers[Rank(rankID)],
                                                         Rank(rankID)));
         }
     }
-    else if (config.refreshPolicy == Configuration::RefreshPolicy::SameBank)
+    else if (config.refreshPolicy == Config::RefreshPolicyType::SameBank)
     {
         for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
         {
             refreshManagers.push_back(
                 std::make_unique<RefreshManagerSameBank>(config,
+                                                         memSpec,
                                                          bankMachinesOnRank[Rank(rankID)],
                                                          *powerDownManagers[Rank(rankID)],
                                                          Rank(rankID)));
         }
     }
-    else if (config.refreshPolicy == Configuration::RefreshPolicy::PerBank)
+    else if (config.refreshPolicy == Config::RefreshPolicyType::PerBank)
     {
         for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
         {
             // TODO: remove bankMachines in constructor
             refreshManagers.push_back(
                 std::make_unique<RefreshManagerPerBank>(config,
+                                                        memSpec,
                                                         bankMachinesOnRank[Rank(rankID)],
                                                         *powerDownManagers[Rank(rankID)],
                                                         Rank(rankID)));
         }
     }
-    else if (config.refreshPolicy == Configuration::RefreshPolicy::Per2Bank)
+    else if (config.refreshPolicy == Config::RefreshPolicyType::Per2Bank)
     {
         for (unsigned rankID = 0; rankID < memSpec.ranksPerChannel; rankID++)
         {
             // TODO: remove bankMachines in constructor
             refreshManagers.push_back(
                 std::make_unique<RefreshManagerPer2Bank>(config,
+                                                         memSpec,
                                                          bankMachinesOnRank[Rank(rankID)],
                                                          *powerDownManagers[Rank(rankID)],
                                                          Rank(rankID)));
@@ -273,11 +318,6 @@ Controller::Controller(const sc_module_name& name,
         SC_REPORT_FATAL("Controller", "Selected refresh mode not supported!");
 }
 
-bool Controller::idle() const
-{
-    return totalNumberOfPayloads == 0;
-}
-
 void Controller::registerIdleCallback(std::function<void()> idleCallback)
 {
     this->idleCallback = std::move(idleCallback);
@@ -376,11 +416,11 @@ void Controller::controllerMethod()
             if (command.isCasCommand())
             {
                 scheduler->removeRequest(*trans);
-                manageRequests(thinkDelayFw);
+                manageRequests(config.thinkDelayFw);
                 respQueue->insertPayload(trans,
-                                         sc_time_stamp() + thinkDelayFw + phyDelayFw +
+                                         sc_time_stamp() + config.thinkDelayFw + config.phyDelayFw +
                                              memSpec.getIntervalOnDataStrobe(command, *trans).end +
-                                             phyDelayBw + thinkDelayBw);
+                                             config.phyDelayBw + config.thinkDelayBw);
 
                 sc_time triggerTime = respQueue->getTriggerTime();
                 if (triggerTime != scMaxTime)
@@ -391,7 +431,7 @@ void Controller::controllerMethod()
             if (ranksNumberOfPayloads[rank] == 0)
                 powerDownManagers[rank]->triggerEntry();
 
-            sc_time fwDelay = thinkDelayFw + phyDelayFw;
+            sc_time fwDelay = config.thinkDelayFw + config.phyDelayFw;
             tlm_phase phase = command.toPhase();
             iSocket->nb_transport_fw(*trans, phase, fwDelay);
         }
@@ -486,7 +526,7 @@ tlm_sync_enum Controller::nb_transport_bw([[maybe_unused]] tlm_generic_payload&
 void Controller::b_transport(tlm_generic_payload& trans, sc_time& delay)
 {
     iSocket->b_transport(trans, delay);
-    delay += trans.is_write() ? blockingWriteDelay : blockingReadDelay;
+    delay += trans.is_write() ? config.blockingWriteDelay : config.blockingReadDelay;
 }
 
 unsigned int Controller::transport_dbg(tlm_generic_payload& trans)
@@ -736,4 +776,42 @@ void Controller::createChildTranses(tlm::tlm_generic_payload& parentTrans)
     ParentExtension::setExtension(parentTrans, std::move(childTranses));
 }
 
+void Controller::end_of_simulation()
+{
+    idleTimeCollector.end();
+
+    sc_core::sc_time activeTime = static_cast<double>(numberOfBeatsServed) / memSpec.dataRate *
+                                  memSpec.tCK / memSpec.pseudoChannelsPerChannel;
+
+    double bandwidth = activeTime / sc_core::sc_time_stamp();
+    double bandwidthWoIdle =
+        activeTime / (sc_core::sc_time_stamp() - idleTimeCollector.getIdleTime());
+
+    double maxBandwidth = (
+        // fCK in GHz e.g. 1 [GHz] (tCK in ps):
+        (1000 / memSpec.tCK.to_double())
+        // DataRate e.g. 2
+        * memSpec.dataRate
+        // BusWidth e.g. 8 or 64
+        * memSpec.bitWidth
+        // Number of devices that form a rank, e.g., 8 on a DDR3 DIMM
+        * memSpec.devicesPerRank
+        // HBM specific, one or two pseudo channels per channel
+        * memSpec.pseudoChannelsPerChannel);
+
+    std::cout << name() << std::string("  Total Time:     ") << sc_core::sc_time_stamp().to_string()
+              << std::endl;
+    std::cout << name() << std::string("  AVG BW:         ") << std::fixed << std::setprecision(2)
+              << std::setw(6) << (bandwidth * maxBandwidth) << " Gb/s | " << std::setw(6)
+              << (bandwidth * maxBandwidth / 8) << " GB/s | " << std::setw(6) << (bandwidth * 100)
+              << " %" << std::endl;
+    std::cout << name() << std::string("  AVG BW\\IDLE:    ") << std::fixed << std::setprecision(2)
+              << std::setw(6) << (bandwidthWoIdle * maxBandwidth) << " Gb/s | " << std::setw(6)
+              << (bandwidthWoIdle * maxBandwidth / 8) << " GB/s | " << std::setw(6)
+              << (bandwidthWoIdle * 100) << " %" << std::endl;
+    std::cout << name() << std::string("  MAX BW:         ") << std::fixed << std::setprecision(2)
+              << std::setw(6) << maxBandwidth << " Gb/s | " << std::setw(6) << maxBandwidth / 8
+              << " GB/s | " << std::setw(6) << 100.0 << " %" << std::endl;
+}
+
 } // namespace DRAMSys
diff --git a/src/libdramsys/DRAMSys/controller/Controller.h b/src/libdramsys/DRAMSys/controller/Controller.h
index 39dae470..12bdf697 100644
--- a/src/libdramsys/DRAMSys/controller/Controller.h
+++ b/src/libdramsys/DRAMSys/controller/Controller.h
@@ -29,68 +29,79 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * Author: Lukas Steiner
+ * Authors:
+ *    Lukas Steiner
+ *    Derek Christ
  */
 
 #ifndef CONTROLLER_H
 #define CONTROLLER_H
 
-#include "DRAMSys/controller/BankMachine.h"
-#include "DRAMSys/controller/Command.h"
-#include "DRAMSys/controller/ControllerIF.h"
-#include "DRAMSys/controller/checker/CheckerIF.h"
-#include "DRAMSys/controller/cmdmux/CmdMuxIF.h"
-#include "DRAMSys/controller/powerdown/PowerDownManagerIF.h"
-#include "DRAMSys/controller/refresh/RefreshManagerIF.h"
-#include "DRAMSys/controller/respqueue/RespQueueIF.h"
-#include "DRAMSys/simulation/AddressDecoder.h"
+#include "BankMachine.h"
+#include "Command.h"
+#include "McConfig.h"
+#include "checker/CheckerIF.h"
+#include "cmdmux/CmdMuxIF.h"
+#include "powerdown/PowerDownManagerIF.h"
+#include "refresh/RefreshManagerIF.h"
+#include "respqueue/RespQueueIF.h"
 
+#include <DRAMSys/common/DebugManager.h>
+#include <DRAMSys/simulation/AddressDecoder.h>
+
+#include <functional>
 #include <stack>
 #include <systemc>
 #include <tlm>
+#include <tlm_utils/simple_initiator_socket.h>
+#include <tlm_utils/simple_target_socket.h>
 #include <utility>
 #include <vector>
 
 namespace DRAMSys
 {
 
-class Controller : public ControllerIF
+class Controller : public sc_core::sc_module
 {
 public:
+    tlm_utils::simple_target_socket<Controller> tSocket{"tSocket"};    // Arbiter side
+    tlm_utils::simple_initiator_socket<Controller> iSocket{"iSocket"}; // DRAM side
+
     Controller(const sc_core::sc_module_name& name,
-               const Configuration& config,
+               const McConfig& config,
+               const MemSpec& memSpec,
                const AddressDecoder& addressDecoder);
     SC_HAS_PROCESS(Controller);
 
-    [[nodiscard]] bool idle() const override;
+    [[nodiscard]] bool idle() const { return totalNumberOfPayloads == 0; }
     void registerIdleCallback(std::function<void()> idleCallback);
 
 protected:
-    tlm::tlm_sync_enum nb_transport_fw(tlm::tlm_generic_payload& trans,
-                                       tlm::tlm_phase& phase,
-                                       sc_core::sc_time& delay) override;
-    tlm::tlm_sync_enum nb_transport_bw(tlm::tlm_generic_payload& trans,
-                                       tlm::tlm_phase& phase,
-                                       sc_core::sc_time& delay) override;
-    void b_transport(tlm::tlm_generic_payload& trans, sc_core::sc_time& delay) override;
-    unsigned int transport_dbg(tlm::tlm_generic_payload& trans) override;
+    void end_of_simulation() override;
+
+    virtual tlm::tlm_sync_enum nb_transport_fw(tlm::tlm_generic_payload& trans,
+                                               tlm::tlm_phase& phase,
+                                               sc_core::sc_time& delay);
+    virtual tlm::tlm_sync_enum nb_transport_bw(tlm::tlm_generic_payload& trans,
+                                               tlm::tlm_phase& phase,
+                                               sc_core::sc_time& delay);
+    void b_transport(tlm::tlm_generic_payload& trans, sc_core::sc_time& delay);
+    unsigned int transport_dbg(tlm::tlm_generic_payload& trans);
 
     virtual void
     sendToFrontend(tlm::tlm_generic_payload& trans, tlm::tlm_phase& phase, sc_core::sc_time& delay);
 
     virtual void controllerMethod();
 
+    const McConfig& config;
+    const MemSpec& memSpec;
+    const AddressDecoder& addressDecoder;
+
     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;
-    const sc_core::sc_time phyDelayBw;
-    const sc_core::sc_time blockingReadDelay;
-    const sc_core::sc_time blockingWriteDelay;
+    sc_core::sc_time scMaxTime = sc_core::sc_max_time();
 
-private:
+    uint64_t numberOfBeatsServed = 0;
     unsigned totalNumberOfPayloads = 0;
     std::function<void()> idleCallback;
     ControllerVector<Rank, unsigned> ranksNumberOfPayloads;
@@ -104,7 +115,6 @@ private:
     ControllerVector<Rank, std::unique_ptr<RefreshManagerIF>> refreshManagers;
     ControllerVector<Rank, std::unique_ptr<PowerDownManagerIF>> powerDownManagers;
 
-    const AddressDecoder& addressDecoder;
     uint64_t nextChannelPayloadIDToAppend = 1;
 
     struct PayloadAndArrival
@@ -139,6 +149,37 @@ private:
     private:
         std::stack<tlm::tlm_generic_payload*> freePayloads;
     } memoryManager;
+
+    class IdleTimeCollector
+    {
+    public:
+        void start()
+        {
+            if (!isIdle)
+            {
+                PRINTDEBUGMESSAGE("IdleTimeCollector", "IDLE start");
+                idleStart = sc_core::sc_time_stamp();
+                isIdle = true;
+            }
+        }
+
+        void end()
+        {
+            if (isIdle)
+            {
+                PRINTDEBUGMESSAGE("IdleTimeCollector", "IDLE end");
+                idleTime += sc_core::sc_time_stamp() - idleStart;
+                isIdle = false;
+            }
+        }
+
+        sc_core::sc_time getIdleTime() { return idleTime; }
+
+    private:
+        bool isIdle = false;
+        sc_core::sc_time idleTime = sc_core::SC_ZERO_TIME;
+        sc_core::sc_time idleStart;
+    } idleTimeCollector;
 };
 
 } // namespace DRAMSys
diff --git a/src/libdramsys/DRAMSys/controller/ControllerIF.h b/src/libdramsys/DRAMSys/controller/ControllerIF.h
deleted file mode 100644
index 4b0de78d..00000000
--- a/src/libdramsys/DRAMSys/controller/ControllerIF.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * Copyright (c) 2019, 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.
- *
- * Authors:
- *    Kirill Bykov
- *    Lukas Steiner
- */
-
-#ifndef CONTROLLERIF_H
-#define CONTROLLERIF_H
-
-#include "DRAMSys/common/DebugManager.h"
-#include "DRAMSys/configuration/Configuration.h"
-
-#include <iomanip>
-#include <systemc>
-#include <tlm>
-#include <tlm_utils/simple_initiator_socket.h>
-#include <tlm_utils/simple_target_socket.h>
-
-namespace DRAMSys
-{
-
-// Utility class to pass around DRAMSys, without having to propagate the template definitions
-// throughout all classes
-class ControllerIF : public sc_core::sc_module
-{
-public:
-    // Already create and bind sockets to the virtual functions
-    tlm_utils::simple_target_socket<ControllerIF> tSocket;    // Arbiter side
-    tlm_utils::simple_initiator_socket<ControllerIF> iSocket; // DRAM side
-
-    void end_of_simulation() override
-    {
-        idleTimeCollector.end();
-
-        sc_core::sc_time activeTime = static_cast<double>(numberOfBeatsServed) / memSpec.dataRate *
-                                      memSpec.tCK / memSpec.pseudoChannelsPerChannel;
-
-        double bandwidth = activeTime / sc_core::sc_time_stamp();
-        double bandwidthWoIdle =
-            activeTime / (sc_core::sc_time_stamp() - idleTimeCollector.getIdleTime());
-
-        double maxBandwidth = (
-            // fCK in GHz e.g. 1 [GHz] (tCK in ps):
-            (1000 / memSpec.tCK.to_double())
-            // DataRate e.g. 2
-            * memSpec.dataRate
-            // BusWidth e.g. 8 or 64
-            * memSpec.bitWidth
-            // Number of devices that form a rank, e.g., 8 on a DDR3 DIMM
-            * memSpec.devicesPerRank
-            // HBM specific, one or two pseudo channels per channel
-            * memSpec.pseudoChannelsPerChannel);
-
-        std::cout << name() << std::string("  Total Time:     ")
-                  << sc_core::sc_time_stamp().to_string() << std::endl;
-        std::cout << name() << std::string("  AVG BW:         ") << std::fixed
-                  << std::setprecision(2) << std::setw(6) << (bandwidth * maxBandwidth)
-                  << " Gb/s | " << std::setw(6) << (bandwidth * maxBandwidth / 8) << " GB/s | "
-                  << std::setw(6) << (bandwidth * 100) << " %" << std::endl;
-        std::cout << name() << std::string("  AVG BW\\IDLE:    ") << std::fixed
-                  << std::setprecision(2) << std::setw(6) << (bandwidthWoIdle * maxBandwidth)
-                  << " Gb/s | " << std::setw(6) << (bandwidthWoIdle * maxBandwidth / 8)
-                  << " GB/s | " << std::setw(6) << (bandwidthWoIdle * 100) << " %" << std::endl;
-        std::cout << name() << std::string("  MAX BW:         ") << std::fixed
-                  << std::setprecision(2) << std::setw(6) << maxBandwidth << " Gb/s | "
-                  << std::setw(6) << maxBandwidth / 8 << " GB/s | " << std::setw(6) << 100.0 << " %"
-                  << std::endl;
-    }
-
-    [[nodiscard]] virtual bool idle() const = 0;
-
-protected:
-    const MemSpec& memSpec;
-
-    // Bind sockets with virtual functions
-    ControllerIF(const sc_core::sc_module_name& name, const Configuration& config) :
-        sc_core::sc_module(name),
-        tSocket("tSocket"),
-        iSocket("iSocket"),
-        memSpec(*config.memSpec)
-    {
-        tSocket.register_nb_transport_fw(this, &ControllerIF::nb_transport_fw);
-        tSocket.register_transport_dbg(this, &ControllerIF::transport_dbg);
-        tSocket.register_b_transport(this, &ControllerIF::b_transport);
-        iSocket.register_nb_transport_bw(this, &ControllerIF::nb_transport_bw);
-
-        idleTimeCollector.start();
-    }
-    SC_HAS_PROCESS(ControllerIF);
-
-    // Virtual transport functions
-    virtual tlm::tlm_sync_enum nb_transport_fw(tlm::tlm_generic_payload& trans,
-                                               tlm::tlm_phase& phase,
-                                               sc_core::sc_time& delay) = 0;
-    virtual tlm::tlm_sync_enum nb_transport_bw(tlm::tlm_generic_payload& trans,
-                                               tlm::tlm_phase& phase,
-                                               sc_core::sc_time& delay) = 0;
-    virtual void b_transport(tlm::tlm_generic_payload& trans, sc_core::sc_time& delay) = 0;
-    virtual unsigned int transport_dbg(tlm::tlm_generic_payload& trans) = 0;
-
-    // Bandwidth related
-    class IdleTimeCollector
-    {
-    public:
-        void start()
-        {
-            if (!isIdle)
-            {
-                PRINTDEBUGMESSAGE("IdleTimeCollector", "IDLE start");
-                idleStart = sc_core::sc_time_stamp();
-                isIdle = true;
-            }
-        }
-
-        void end()
-        {
-            if (isIdle)
-            {
-                PRINTDEBUGMESSAGE("IdleTimeCollector", "IDLE end");
-                idleTime += sc_core::sc_time_stamp() - idleStart;
-                isIdle = false;
-            }
-        }
-
-        sc_core::sc_time getIdleTime() { return idleTime; }
-
-    private:
-        bool isIdle = false;
-        sc_core::sc_time idleTime = sc_core::SC_ZERO_TIME;
-        sc_core::sc_time idleStart;
-    } idleTimeCollector;
-
-    uint64_t numberOfBeatsServed = 0;
-};
-
-} // namespace DRAMSys
-
-#endif // CONTROLLERIF_H
diff --git a/src/libdramsys/DRAMSys/controller/ControllerRecordable.cpp b/src/libdramsys/DRAMSys/controller/ControllerRecordable.cpp
index c5af3390..be257434 100644
--- a/src/libdramsys/DRAMSys/controller/ControllerRecordable.cpp
+++ b/src/libdramsys/DRAMSys/controller/ControllerRecordable.cpp
@@ -43,14 +43,16 @@ namespace DRAMSys
 {
 
 ControllerRecordable::ControllerRecordable(const sc_module_name& name,
-                                           const Configuration& config,
+                                           const McConfig& config,
+                                           const SimConfig& simConfig,
+                                           const MemSpec& memSpec,
                                            const AddressDecoder& addressDecoder,
                                            TlmRecorder& tlmRecorder) :
-    Controller(name, config, addressDecoder),
+    Controller(name, config, memSpec, addressDecoder),
     tlmRecorder(tlmRecorder),
-    windowSizeTime(config.windowSize * memSpec.tCK),
-    activeTimeMultiplier(config.memSpec->tCK / config.memSpec->dataRate),
-    enableWindowing(config.enableWindowing)
+    windowSizeTime(simConfig.windowSize * memSpec.tCK),
+    activeTimeMultiplier(memSpec.tCK / memSpec.dataRate),
+    enableWindowing(simConfig.enableWindowing)
 {
     if (enableWindowing)
     {
diff --git a/src/libdramsys/DRAMSys/controller/ControllerRecordable.h b/src/libdramsys/DRAMSys/controller/ControllerRecordable.h
index ac21c5b4..26ae086d 100644
--- a/src/libdramsys/DRAMSys/controller/ControllerRecordable.h
+++ b/src/libdramsys/DRAMSys/controller/ControllerRecordable.h
@@ -37,6 +37,7 @@
 
 #include "DRAMSys/common/TlmRecorder.h"
 #include "DRAMSys/controller/Controller.h"
+#include "DRAMSys/simulation/SimConfig.h"
 
 #include <systemc>
 #include <tlm>
@@ -48,7 +49,9 @@ class ControllerRecordable final : public Controller
 {
 public:
     ControllerRecordable(const sc_core::sc_module_name& name,
-                         const Configuration& config,
+                         const McConfig& config,
+                         const SimConfig& simConfig,
+                         const MemSpec& memSpec,
                          const AddressDecoder& addressDecoder,
                          TlmRecorder& tlmRecorder);
 
diff --git a/src/libdramsys/DRAMSys/controller/McConfig.cpp b/src/libdramsys/DRAMSys/controller/McConfig.cpp
new file mode 100644
index 00000000..a2b9bb5e
--- /dev/null
+++ b/src/libdramsys/DRAMSys/controller/McConfig.cpp
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2024, 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.
+ *
+ * Authors:
+ *    Derek Christ
+ */
+
+#include "McConfig.h"
+
+namespace DRAMSys
+{
+
+McConfig::McConfig(const Config::McConfig& config, const MemSpec& memSpec) :
+    pagePolicy(config.PagePolicy.value_or(DEFAULT_PAGE_POLICY)),
+    scheduler(config.Scheduler.value_or(DEFAULT_SCHEDULER)),
+    schedulerBuffer(config.SchedulerBuffer.value_or(DEFAULT_SCHEDULER_BUFFER)),
+    lowWatermark(config.LowWatermark.value_or(DEFAULT_LOW_WATERMARK)),
+    highWatermark(config.HighWatermark.value_or(DEFAULT_HIGH_WATERMARK)),
+    cmdMux(config.CmdMux.value_or(DEFAULT_CMD_MUX)),
+    respQueue(config.RespQueue.value_or(DEFAULT_RESP_QUEUE)),
+    arbiter(config.Arbiter.value_or(DEFAULT_ARBITER)),
+    requestBufferSize(config.RequestBufferSize.value_or(DEFAULT_REQUEST_BUFFER_SIZE)),
+    requestBufferSizeRead(config.RequestBufferSizeRead.value_or(DEFAULT_REQUEST_BUFFER_SIZE_READ)),
+    requestBufferSizeWrite(
+        config.RequestBufferSizeWrite.value_or(DEFAULT_REQUEST_BUFFER_SIZE_WRITE)),
+    refreshPolicy(config.RefreshPolicy.value_or(DEFAULT_REFRESH_POLICY)),
+    refreshMaxPostponed(config.RefreshMaxPostponed.value_or(DEFAULT_REFRESH_MAX_POSTPONED)),
+    refreshMaxPulledin(config.RefreshMaxPulledin.value_or(DEFAULT_REFRESH_MAX_PULLEDIN)),
+    powerDownPolicy(config.PowerDownPolicy.value_or(DEFAULT_POWER_DOWN_POLICY)),
+    maxActiveTransactions(config.MaxActiveTransactions.value_or(DEFAULT_MAX_ACTIVE_TRANSACTIONS)),
+    refreshManagement(config.RefreshManagement.value_or(DEFAULT_REFRESH_MANAGEMENT)),
+    arbitrationDelayFw(sc_core::sc_time(
+        config.ArbitrationDelayFw.value_or(DEFAULT_ARBITRATION_DELAY_FW_NS), sc_core::SC_NS)),
+    arbitrationDelayBw(sc_core::sc_time(
+        config.ArbitrationDelayBw.value_or(DEFAULT_ARBITRATION_DELAY_BW_NS), sc_core::SC_NS)),
+    thinkDelayFw(
+        sc_core::sc_time(config.ThinkDelayFw.value_or(DEFAULT_THINK_DELAY_FW_NS), sc_core::SC_NS)),
+    thinkDelayBw(
+        sc_core::sc_time(config.ThinkDelayBw.value_or(DEFAULT_THINK_DELAY_BW_NS), sc_core::SC_NS)),
+    phyDelayFw(
+        sc_core::sc_time(config.PhyDelayFw.value_or(DEFAULT_PHY_DELAY_FW_NS), sc_core::SC_NS)),
+    phyDelayBw(
+        sc_core::sc_time(config.PhyDelayBw.value_or(DEFAULT_PHY_DELAY_BW_NS), sc_core::SC_NS)),
+    blockingReadDelay(sc_core::sc_time(
+        config.BlockingReadDelay.value_or(DEFAULT_BLOCKING_READ_DELAY_NS), sc_core::SC_NS)),
+    blockingWriteDelay(sc_core::sc_time(
+        config.BlockingWriteDelay.value_or(DEFAULT_BLOCKING_WRITE_DELAY_NS), sc_core::SC_NS))
+
+{
+    if (pagePolicy == Config::PagePolicyType::Invalid)
+        SC_REPORT_FATAL("McConfig", "Invalid PagePolicy");
+
+    if (scheduler == Config::SchedulerType::Invalid)
+        SC_REPORT_FATAL("McConfig", "Invalid Scheduler");
+
+    if (schedulerBuffer == Config::SchedulerBufferType::Invalid)
+        SC_REPORT_FATAL("McConfig", "Invalid SchedulerBuffer");
+
+    if (cmdMux == Config::CmdMuxType::Invalid)
+        SC_REPORT_FATAL("McConfig", "Invalid CmdMux");
+
+    if (respQueue == Config::RespQueueType::Invalid)
+        SC_REPORT_FATAL("McConfig", "Invalid RespQueue");
+
+    if (refreshPolicy == Config::RefreshPolicyType::Invalid)
+        SC_REPORT_FATAL("McConfig", "Invalid RefreshPolicy");
+
+    if (powerDownPolicy == Config::PowerDownPolicyType::Invalid)
+        SC_REPORT_FATAL("Configuration", "Invalid PowerDownPolicy");
+
+    if (arbiter == Config::ArbiterType::Invalid)
+        SC_REPORT_FATAL("Arbiter", "Invalid Arbiter");
+
+    if (requestBufferSize < 1)
+        SC_REPORT_FATAL("Configuration", "Minimum request buffer size is 1!");
+
+    if (requestBufferSizeRead < 1)
+        SC_REPORT_FATAL("Configuration", "Minimum request buffer size is 1!");
+
+    if (requestBufferSizeWrite < 1)
+        SC_REPORT_FATAL("Configuration", "Minimum request buffer size is 1!");
+
+    arbitrationDelayFw = std::round(arbitrationDelayFw / memSpec.tCK) * memSpec.tCK;
+    arbitrationDelayBw = std::round(arbitrationDelayBw / memSpec.tCK) * memSpec.tCK;
+
+    thinkDelayFw = std::round(thinkDelayFw / memSpec.tCK) * memSpec.tCK;
+    thinkDelayBw = std::round(thinkDelayBw / memSpec.tCK) * memSpec.tCK;
+
+    phyDelayFw = std::round(phyDelayFw / memSpec.tCK) * memSpec.tCK;
+    phyDelayBw = std::round(phyDelayBw / memSpec.tCK) * memSpec.tCK;
+
+    blockingReadDelay = std::round(blockingReadDelay / memSpec.tCK) * memSpec.tCK;
+    blockingWriteDelay = std::round(blockingWriteDelay / memSpec.tCK) * memSpec.tCK;
+}
+
+} // namespace DRAMSys
diff --git a/src/libdramsys/DRAMSys/controller/McConfig.h b/src/libdramsys/DRAMSys/controller/McConfig.h
new file mode 100644
index 00000000..aad546cb
--- /dev/null
+++ b/src/libdramsys/DRAMSys/controller/McConfig.h
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2024, 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.
+ *
+ * Authors:
+ *    Derek Christ
+ */
+
+#ifndef MC_CONFIG_H
+#define MC_CONFIG_H
+
+#include <DRAMSys/config/McConfig.h>
+#include <DRAMSys/configuration/memspec/MemSpec.h>
+
+#include <systemc>
+
+namespace DRAMSys
+{
+
+struct McConfig
+{
+    McConfig(const Config::McConfig& config, const MemSpec& memSpec);
+
+    Config::PagePolicyType pagePolicy;
+    Config::SchedulerType scheduler;
+    Config::SchedulerBufferType schedulerBuffer;
+
+    unsigned int lowWatermark;
+    unsigned int highWatermark;
+
+    Config::CmdMuxType cmdMux;
+    Config::RespQueueType respQueue;
+    Config::ArbiterType arbiter;
+
+    unsigned int requestBufferSize;
+    unsigned int requestBufferSizeRead;
+    unsigned int requestBufferSizeWrite;
+
+    Config::RefreshPolicyType refreshPolicy;
+    unsigned int refreshMaxPostponed;
+    unsigned int refreshMaxPulledin;
+
+    Config::PowerDownPolicyType powerDownPolicy;
+    unsigned int maxActiveTransactions;
+    bool refreshManagement;
+
+    sc_core::sc_time arbitrationDelayFw;
+    sc_core::sc_time arbitrationDelayBw;
+    sc_core::sc_time thinkDelayFw;
+    sc_core::sc_time thinkDelayBw;
+    sc_core::sc_time phyDelayFw;
+    sc_core::sc_time phyDelayBw;
+    sc_core::sc_time blockingReadDelay;
+    sc_core::sc_time blockingWriteDelay;
+
+    static constexpr Config::PagePolicyType DEFAULT_PAGE_POLICY = Config::PagePolicyType::Open;
+    static constexpr Config::SchedulerType DEFAULT_SCHEDULER = Config::SchedulerType::FrFcfs;
+    static constexpr Config::SchedulerBufferType DEFAULT_SCHEDULER_BUFFER =
+        Config::SchedulerBufferType::Bankwise;
+    static constexpr unsigned int DEFAULT_LOW_WATERMARK = 0;
+    static constexpr unsigned int DEFAULT_HIGH_WATERMARK = 0;
+    static constexpr Config::CmdMuxType DEFAULT_CMD_MUX = Config::CmdMuxType::Oldest;
+    static constexpr Config::RespQueueType DEFAULT_RESP_QUEUE = Config::RespQueueType::Fifo;
+    static constexpr Config::ArbiterType DEFAULT_ARBITER = Config::ArbiterType::Simple;
+    static constexpr unsigned int DEFAULT_REQUEST_BUFFER_SIZE = 8;
+    static constexpr unsigned int DEFAULT_REQUEST_BUFFER_SIZE_READ = 8;
+    static constexpr unsigned int DEFAULT_REQUEST_BUFFER_SIZE_WRITE = 8;
+    static constexpr Config::RefreshPolicyType DEFAULT_REFRESH_POLICY =
+        Config::RefreshPolicyType::AllBank;
+    static constexpr unsigned int DEFAULT_REFRESH_MAX_POSTPONED = 0;
+    static constexpr unsigned int DEFAULT_REFRESH_MAX_PULLEDIN = 0;
+    static constexpr Config::PowerDownPolicyType DEFAULT_POWER_DOWN_POLICY =
+        Config::PowerDownPolicyType::NoPowerDown;
+    static constexpr unsigned int DEFAULT_MAX_ACTIVE_TRANSACTIONS = 64;
+    static constexpr bool DEFAULT_REFRESH_MANAGEMENT = false;
+    static constexpr unsigned DEFAULT_ARBITRATION_DELAY_FW_NS = 0;
+    static constexpr unsigned DEFAULT_ARBITRATION_DELAY_BW_NS = 0;
+    static constexpr unsigned DEFAULT_THINK_DELAY_FW_NS = 0;
+    static constexpr unsigned DEFAULT_THINK_DELAY_BW_NS = 0;
+    static constexpr unsigned DEFAULT_PHY_DELAY_FW_NS = 0;
+    static constexpr unsigned DEFAULT_PHY_DELAY_BW_NS = 0;
+    static constexpr unsigned DEFAULT_BLOCKING_READ_DELAY_NS = 60;
+    static constexpr unsigned DEFAULT_BLOCKING_WRITE_DELAY_NS = 60;
+};
+
+} // namespace DRAMSys
+
+#endif
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.cpp
index 06fa4636..522857ee 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.cpp
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.cpp
@@ -44,31 +44,28 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-CheckerDDR3::CheckerDDR3(const Configuration& config) :
-    memSpec(dynamic_cast<const MemSpecDDR3*>(config.memSpec.get()))
+CheckerDDR3::CheckerDDR3(const MemSpecDDR3& memSpec) :
+    memSpec(memSpec)
 {
-    if (memSpec == nullptr)
-        SC_REPORT_FATAL("CheckerDDR3", "Wrong MemSpec chosen");
-
     lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
+        ControllerVector<Bank, sc_time>(memSpec.banksPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
+        ControllerVector<Rank, sc_time>(memSpec.ranksPerChannel, scMaxTime));
     lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
     lastCommandOnBus = scMaxTime;
-    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
+    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec.ranksPerChannel);
 
-    tBURST = memSpec->defaultBurstLength / memSpec->dataRate * memSpec->tCK;
-    tRDWR = memSpec->tRL + tBURST + 2 * memSpec->tCK - memSpec->tWL;
-    tRDWR_R = memSpec->tRL + tBURST + memSpec->tRTRS - memSpec->tWL;
-    tWRRD = memSpec->tWL + tBURST + memSpec->tWTR - memSpec->tAL;
-    tWRRD_R = memSpec->tWL + tBURST + memSpec->tRTRS - memSpec->tRL;
-    tWRPRE = memSpec->tWL + tBURST + memSpec->tWR;
-    tRDPDEN = memSpec->tRL + tBURST + memSpec->tCK;
-    tWRPDEN = memSpec->tWL + tBURST + memSpec->tWR;
-    tWRAPDEN = memSpec->tWL + tBURST + memSpec->tWR + memSpec->tCK;
+    tBURST = memSpec.defaultBurstLength / memSpec.dataRate * memSpec.tCK;
+    tRDWR = memSpec.tRL + tBURST + 2 * memSpec.tCK - memSpec.tWL;
+    tRDWR_R = memSpec.tRL + tBURST + memSpec.tRTRS - memSpec.tWL;
+    tWRRD = memSpec.tWL + tBURST + memSpec.tWTR - memSpec.tAL;
+    tWRRD_R = memSpec.tWL + tBURST + memSpec.tRTRS - memSpec.tRL;
+    tWRPRE = memSpec.tWL + tBURST + memSpec.tWR;
+    tRDPDEN = memSpec.tRL + tBURST + memSpec.tCK;
+    tWRPDEN = memSpec.tWL + tBURST + memSpec.tWR;
+    tWRAPDEN = memSpec.tWL + tBURST + memSpec.tWR + memSpec.tCK;
 }
 
 sc_time CheckerDDR3::timeToSatisfyConstraints(Command command,
@@ -87,11 +84,11 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD - memSpec->tAL);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD - memSpec.tAL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD);
 
         lastCommandStart =
             lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank]
@@ -99,11 +96,11 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] !=
                                    lastScheduledByCommandAndRank[Command::RDA][rank]
@@ -111,14 +108,14 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
             if (lastCommandStart != scMaxTime)
                 earliestTimeToStart = std::max(
-                    earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP - memSpec->tAL);
+                    earliestTimeToStart, lastCommandStart + tWRPRE - memSpec.tRTP - memSpec.tAL);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
@@ -139,11 +136,11 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSDLL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSDLL);
     }
     else if (command == Command::WR || command == Command::WRA || command == Command::MWR ||
              command == Command::MWRA)
@@ -153,7 +150,7 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD - memSpec->tAL);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD - memSpec.tAL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -179,7 +176,7 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD);
 
         lastCommandStart =
             lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank]
@@ -187,11 +184,11 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD);
 
         lastCommandStart = lastScheduledByCommand[Command::WRA] !=
                                    lastScheduledByCommandAndRank[Command::WRA][rank]
@@ -199,75 +196,75 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSDLL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSDLL);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + memSpec->tAL + memSpec->tRTP + memSpec->tRP);
+                         lastCommandStart + memSpec.tAL + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
     }
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
         if (lastCommandStart != scMaxTime)
@@ -275,23 +272,23 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
@@ -303,51 +300,51 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + memSpec->tAL + memSpec->tRTP + memSpec->tRP);
+                         lastCommandStart + memSpec.tAL + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tACTPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tACTPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -368,17 +365,17 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::PDEP)
     {
@@ -397,80 +394,80 @@ sc_time CheckerDDR3::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tREFPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
                 earliestTimeToStart,
-                lastCommandStart + std::max(tRDPDEN, memSpec->tAL + memSpec->tRTP + memSpec->tRP));
+                lastCommandStart + std::max(tRDPDEN, memSpec.tAL + memSpec.tRTP + memSpec.tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec->tRP));
+                earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec.tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKESR);
     }
     else
         SC_REPORT_FATAL("CheckerDDR3", "Unknown command!");
 
     if (lastCommandOnBus != scMaxTime)
-        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK);
 
     return earliestTimeToStart;
 }
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.h b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.h
index a7cca4d4..9d447250 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.h
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR3.h
@@ -35,7 +35,6 @@
 #ifndef CHECKERDDR3_H
 #define CHECKERDDR3_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpecDDR3.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 
@@ -48,14 +47,14 @@ namespace DRAMSys
 class CheckerDDR3 final : public CheckerIF
 {
 public:
-    explicit CheckerDDR3(const Configuration& config);
+    explicit CheckerDDR3(const MemSpecDDR3 &memSpec);
     [[nodiscard]] sc_core::sc_time
     timeToSatisfyConstraints(Command command,
                              const tlm::tlm_generic_payload& payload) const override;
     void insert(Command command, const tlm::tlm_generic_payload& payload) override;
 
 private:
-    const MemSpecDDR3* memSpec;
+    const MemSpecDDR3& memSpec;
 
     std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
     std::vector<ControllerVector<Rank, sc_core::sc_time>> lastScheduledByCommandAndRank;
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.cpp
index cd8e740e..0e50cd0d 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.cpp
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.cpp
@@ -35,6 +35,7 @@
 #include "CheckerDDR4.h"
 
 #include "DRAMSys/common/DebugManager.h"
+#include "DRAMSys/configuration/memspec/MemSpecDDR4.h"
 
 #include <algorithm>
 
@@ -44,35 +45,32 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-CheckerDDR4::CheckerDDR4(const Configuration& config) :
-    memSpec(dynamic_cast<const MemSpecDDR4*>(config.memSpec.get()))
+CheckerDDR4::CheckerDDR4(const MemSpecDDR4 &memSpec) :
+    memSpec(memSpec)
 {
-    if (memSpec == nullptr)
-        SC_REPORT_FATAL("CheckerDDR4", "Wrong MemSpec chosen");
-
     lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
+        ControllerVector<Bank, sc_time>(memSpec.banksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<BankGroup, sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
+        ControllerVector<BankGroup, sc_time>(memSpec.bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
+        ControllerVector<Rank, sc_time>(memSpec.ranksPerChannel, scMaxTime));
     lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
     lastCommandOnBus = scMaxTime;
-    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
+    last4Activates = ControllerVector<Rank, 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;
-    tWRRD_S = memSpec->tWL + tBURST + memSpec->tWTR_S - memSpec->tAL;
-    tWRRD_L = memSpec->tWL + tBURST + memSpec->tWTR_L - memSpec->tAL;
-    tWRRD_R = memSpec->tWL + tBURST + memSpec->tRTRS - memSpec->tRL + memSpec->tRPRE;
-    tWRPRE = memSpec->tWL + tBURST + memSpec->tWR;
-    tRDPDEN = memSpec->tRL + tBURST + memSpec->tCK;
-    tWRPDEN = memSpec->tWL + tBURST + memSpec->tWR;
-    tWRAPDEN = memSpec->tWL + tBURST + memSpec->tCK + memSpec->tWR;
+    tBURST = memSpec.defaultBurstLength / memSpec.dataRate * memSpec.tCK;
+    tRDWR = memSpec.tRL + tBURST + memSpec.tCK - memSpec.tWL + memSpec.tWPRE;
+    tRDWR_R = memSpec.tRL + tBURST + memSpec.tRTRS - memSpec.tWL + memSpec.tWPRE;
+    tWRRD_S = memSpec.tWL + tBURST + memSpec.tWTR_S - memSpec.tAL;
+    tWRRD_L = memSpec.tWL + tBURST + memSpec.tWTR_L - memSpec.tAL;
+    tWRRD_R = memSpec.tWL + tBURST + memSpec.tRTRS - memSpec.tRL + memSpec.tRPRE;
+    tWRPRE = memSpec.tWL + tBURST + memSpec.tWR;
+    tRDPDEN = memSpec.tRL + tBURST + memSpec.tCK;
+    tWRPDEN = memSpec.tWL + tBURST + memSpec.tWR;
+    tWRAPDEN = memSpec.tWL + tBURST + memSpec.tCK + memSpec.tWR;
 }
 
 sc_time CheckerDDR4::timeToSatisfyConstraints(Command command,
@@ -92,15 +90,15 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD - memSpec->tAL);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD - memSpec.tAL);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_L);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S);
 
         lastCommandStart =
             lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank]
@@ -108,15 +106,15 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_L);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] !=
                                    lastScheduledByCommandAndRank[Command::RDA][rank]
@@ -124,14 +122,14 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
             if (lastCommandStart != scMaxTime)
                 earliestTimeToStart = std::max(
-                    earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP - memSpec->tAL);
+                    earliestTimeToStart, lastCommandStart + tWRPRE - memSpec.tRTP - memSpec.tAL);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
@@ -160,11 +158,11 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSDLL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSDLL);
     }
     else if (command == Command::WR || command == Command::WRA || command == Command::MWR ||
              command == Command::MWRA)
@@ -174,7 +172,7 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD - memSpec->tAL);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD - memSpec.tAL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -200,11 +198,11 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_L);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S);
 
         lastCommandStart =
             lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank]
@@ -212,15 +210,15 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_L);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD_S);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD_S);
 
         lastCommandStart = lastScheduledByCommand[Command::WRA] !=
                                    lastScheduledByCommandAndRank[Command::WRA][rank]
@@ -228,79 +226,79 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSDLL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSDLL);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD_L);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD_L);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD_S);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD_S);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + memSpec->tAL + memSpec->tRTP + memSpec->tRP);
+                         lastCommandStart + memSpec.tAL + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
     }
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
         if (lastCommandStart != scMaxTime)
@@ -308,23 +306,23 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
@@ -336,51 +334,51 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + memSpec->tAL + memSpec->tRTP + memSpec->tRP);
+                         lastCommandStart + memSpec.tAL + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tACTPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tACTPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -401,17 +399,17 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::PDEP)
     {
@@ -430,80 +428,80 @@ sc_time CheckerDDR4::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tREFPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
                 earliestTimeToStart,
-                lastCommandStart + std::max(tRDPDEN, memSpec->tAL + memSpec->tRTP + memSpec->tRP));
+                lastCommandStart + std::max(tRDPDEN, memSpec.tAL + memSpec.tRTP + memSpec.tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec->tRP));
+                earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec.tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKESR);
     }
     else
         SC_REPORT_FATAL("CheckerDDR4", "Unknown command!");
 
     if (lastCommandOnBus != scMaxTime)
-        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK);
 
     return earliestTimeToStart;
 }
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.h b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.h
index 6ea3708d..945619a0 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.h
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerDDR4.h
@@ -35,7 +35,6 @@
 #ifndef CHECKERDDR4_H
 #define CHECKERDDR4_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpecDDR4.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 
@@ -50,14 +49,14 @@ namespace DRAMSys
 class CheckerDDR4 final : public CheckerIF
 {
 public:
-    explicit CheckerDDR4(const Configuration& config);
+    explicit CheckerDDR4(const MemSpecDDR4& memSpec);
     [[nodiscard]] sc_core::sc_time
     timeToSatisfyConstraints(Command command,
                              const tlm::tlm_generic_payload& payload) const override;
     void insert(Command command, const tlm::tlm_generic_payload& payload) override;
 
 private:
-    const MemSpecDDR4* memSpec;
+    const MemSpecDDR4& memSpec;
 
     std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
     std::vector<ControllerVector<BankGroup, sc_core::sc_time>> lastScheduledByCommandAndBankGroup;
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5.cpp
index d4a097e3..349de993 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5.cpp
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5.cpp
@@ -35,6 +35,7 @@
 #include "CheckerGDDR5.h"
 
 #include "DRAMSys/common/DebugManager.h"
+#include "DRAMSys/configuration/memspec/MemSpecGDDR5.h"
 
 #include <algorithm>
 
@@ -44,36 +45,33 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-CheckerGDDR5::CheckerGDDR5(const Configuration& config) :
-    memSpec(dynamic_cast<const MemSpecGDDR5*>(config.memSpec.get()))
+CheckerGDDR5::CheckerGDDR5(const MemSpecGDDR5& memSpec) :
+    memSpec(memSpec)
 {
-    if (memSpec == nullptr)
-        SC_REPORT_FATAL("CheckerGDDR5", "Wrong MemSpec chosen");
-
     lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
+        ControllerVector<Bank, sc_time>(memSpec.banksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<BankGroup, sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
+        ControllerVector<BankGroup, sc_time>(memSpec.bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
+        ControllerVector<Rank, sc_time>(memSpec.ranksPerChannel, scMaxTime));
     lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
     lastCommandOnBus = scMaxTime;
-    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
-    last32Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
+    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec.ranksPerChannel);
+    last32Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec.ranksPerChannel);
 
-    bankwiseRefreshCounter = ControllerVector<Rank, unsigned>(memSpec->ranksPerChannel);
+    bankwiseRefreshCounter = ControllerVector<Rank, unsigned>(memSpec.ranksPerChannel);
 
-    tBURST = memSpec->defaultBurstLength / memSpec->dataRate * memSpec->tCK;
-    tRDSRE = memSpec->tCL + memSpec->tWCK2CKPIN + memSpec->tWCK2CK + memSpec->tWCK2DQO + tBURST;
-    tWRSRE = memSpec->tWL + memSpec->tWCK2CKPIN + memSpec->tWCK2CK + memSpec->tWCK2DQI + tBURST;
-    tRDWR_R = memSpec->tCL + tBURST + memSpec->tRTRS - memSpec->tWL;
-    tWRRD_R = memSpec->tWL + tBURST + memSpec->tRTRS - memSpec->tCL;
-    tWRRD_S = memSpec->tWL + tBURST + memSpec->tWTRS;
-    tWRRD_L = memSpec->tWL + tBURST + memSpec->tWTRL;
-    tWRPRE = memSpec->tWL + tBURST + memSpec->tWR;
+    tBURST = memSpec.defaultBurstLength / memSpec.dataRate * memSpec.tCK;
+    tRDSRE = memSpec.tCL + memSpec.tWCK2CKPIN + memSpec.tWCK2CK + memSpec.tWCK2DQO + tBURST;
+    tWRSRE = memSpec.tWL + memSpec.tWCK2CKPIN + memSpec.tWCK2CK + memSpec.tWCK2DQI + tBURST;
+    tRDWR_R = memSpec.tCL + tBURST + memSpec.tRTRS - memSpec.tWL;
+    tWRRD_R = memSpec.tWL + tBURST + memSpec.tRTRS - memSpec.tCL;
+    tWRRD_S = memSpec.tWL + tBURST + memSpec.tWTRS;
+    tWRRD_L = memSpec.tWL + tBURST + memSpec.tWTRL;
+    tWRPRE = memSpec.tWL + tBURST + memSpec.tWR;
 }
 
 sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
@@ -92,15 +90,15 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDRD);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart =
             lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank]
@@ -108,15 +106,15 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] !=
                                    lastScheduledByCommandAndRank[Command::RDA][rank]
@@ -124,14 +122,14 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
             if (lastCommandStart != scMaxTime)
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP);
+                    std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec.tRTP);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
@@ -166,11 +164,11 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tLK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tLK);
     }
     else if (command == Command::WR || command == Command::WRA)
     {
@@ -178,11 +176,11 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDWR);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW);
 
         lastCommandStart =
             lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank]
@@ -193,7 +191,7 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] !=
                                    lastScheduledByCommandAndRank[Command::RDA][rank]
@@ -204,11 +202,11 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart =
             lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank]
@@ -216,15 +214,15 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommand[Command::WRA] !=
                                    lastScheduledByCommandAndRank[Command::WRA][rank]
@@ -232,89 +230,89 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tLK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tLK);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
 
         if (last32Activates[rank].size() >= 32)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last32Activates[rank].front() + memSpec->t32AW);
+                std::max(earliestTimeToStart, last32Activates[rank].front() + memSpec.t32AW);
     }
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
         if (lastCommandStart != scMaxTime)
@@ -322,25 +320,25 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXPN);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
@@ -352,126 +350,126 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
         {
             if (bankwiseRefreshCounter[rank] == 0)
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
             else
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
 
         if (last32Activates[rank].size() >= 32)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last32Activates[rank].front() + memSpec->t32AW);
+                std::max(earliestTimeToStart, last32Activates[rank].front() + memSpec.t32AW);
     }
     else if (command == Command::PDEA)
     {
@@ -493,13 +491,13 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXPN);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::PDEP)
     {
@@ -517,23 +515,23 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -543,49 +541,49 @@ sc_time CheckerGDDR5::timeToSatisfyConstraints(Command command,
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + std::max(memSpec->tRTP + memSpec->tRP, tRDSRE));
+                         lastCommandStart + std::max(memSpec.tRTP + memSpec.tRP, tRDSRE));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXPN);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXPN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else
         SC_REPORT_FATAL("CheckerGDDR5", "Unknown command!");
 
     // Check if command bus is free
     if (lastCommandOnBus != scMaxTime)
-        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK);
 
     return earliestTimeToStart;
 }
@@ -618,7 +616,7 @@ void CheckerGDDR5::insert(Command command, const tlm_generic_payload& payload)
     }
 
     if (command == Command::REFPB)
-        bankwiseRefreshCounter[rank] = (bankwiseRefreshCounter[rank] + 1) % memSpec->banksPerRank;
+        bankwiseRefreshCounter[rank] = (bankwiseRefreshCounter[rank] + 1) % memSpec.banksPerRank;
 }
 
 } // namespace DRAMSys
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5.h b/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5.h
index c7d78974..9d5ccc01 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5.h
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5.h
@@ -35,7 +35,6 @@
 #ifndef CHECKERGDDR5_H
 #define CHECKERGDDR5_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpecGDDR5.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 
@@ -48,14 +47,14 @@ namespace DRAMSys
 class CheckerGDDR5 final : public CheckerIF
 {
 public:
-    explicit CheckerGDDR5(const Configuration& config);
+    explicit CheckerGDDR5(const MemSpecGDDR5& memSpec);
     [[nodiscard]] sc_core::sc_time
     timeToSatisfyConstraints(Command command,
                              const tlm::tlm_generic_payload& payload) const override;
     void insert(Command command, const tlm::tlm_generic_payload& payload) override;
 
 private:
-    const MemSpecGDDR5* memSpec;
+    const MemSpecGDDR5& memSpec;
 
     std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
     std::vector<ControllerVector<BankGroup, sc_core::sc_time>> lastScheduledByCommandAndBankGroup;
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5X.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5X.cpp
index df75de09..34faa567 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5X.cpp
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5X.cpp
@@ -44,36 +44,33 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-CheckerGDDR5X::CheckerGDDR5X(const Configuration& config) :
-    memSpec(dynamic_cast<const MemSpecGDDR5X*>(config.memSpec.get()))
+CheckerGDDR5X::CheckerGDDR5X(const MemSpecGDDR5X& memSpec) :
+    memSpec(memSpec)
 {
-    if (memSpec == nullptr)
-        SC_REPORT_FATAL("CheckerGDDR5X", "Wrong MemSpec chosen");
-
     lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
+        ControllerVector<Bank, sc_time>(memSpec.banksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<BankGroup, sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
+        ControllerVector<BankGroup, sc_time>(memSpec.bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
+        ControllerVector<Rank, sc_time>(memSpec.ranksPerChannel, scMaxTime));
     lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
     lastCommandOnBus = scMaxTime;
-    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
-    last32Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
+    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec.ranksPerChannel);
+    last32Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec.ranksPerChannel);
 
-    bankwiseRefreshCounter = ControllerVector<Rank, unsigned>(memSpec->ranksPerChannel);
+    bankwiseRefreshCounter = ControllerVector<Rank, unsigned>(memSpec.ranksPerChannel);
 
-    tBURST = memSpec->defaultBurstLength / memSpec->dataRate * memSpec->tCK;
-    tRDSRE = memSpec->tRL + memSpec->tWCK2CKPIN + memSpec->tWCK2CK + memSpec->tWCK2DQO + tBURST;
-    tWRSRE = memSpec->tWL + memSpec->tWCK2CKPIN + memSpec->tWCK2CK + memSpec->tWCK2DQI + tBURST;
-    tRDWR_R = memSpec->tRL + tBURST + memSpec->tRTRS - memSpec->tWL;
-    tWRRD_R = memSpec->tWL + tBURST + memSpec->tRTRS - memSpec->tRL;
-    tWRRD_S = memSpec->tWL + tBURST + memSpec->tWTRS;
-    tWRRD_L = memSpec->tWL + tBURST + memSpec->tWTRL;
-    tWRPRE = memSpec->tWL + tBURST + memSpec->tWR;
+    tBURST = memSpec.defaultBurstLength / memSpec.dataRate * memSpec.tCK;
+    tRDSRE = memSpec.tRL + memSpec.tWCK2CKPIN + memSpec.tWCK2CK + memSpec.tWCK2DQO + tBURST;
+    tWRSRE = memSpec.tWL + memSpec.tWCK2CKPIN + memSpec.tWCK2CK + memSpec.tWCK2DQI + tBURST;
+    tRDWR_R = memSpec.tRL + tBURST + memSpec.tRTRS - memSpec.tWL;
+    tWRRD_R = memSpec.tWL + tBURST + memSpec.tRTRS - memSpec.tRL;
+    tWRRD_S = memSpec.tWL + tBURST + memSpec.tWTRS;
+    tWRRD_L = memSpec.tWL + tBURST + memSpec.tWTRL;
+    tWRPRE = memSpec.tWL + tBURST + memSpec.tWR;
 }
 
 sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
@@ -89,20 +86,20 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
     if (command == Command::RD || command == Command::RDA)
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
-        assert(!(memSpec->dataRate == 4) || (burstLength == 8));  // DDR mode (QDR wrt CK)
-        assert(!(memSpec->dataRate == 8) || (burstLength == 16)); // QDR mode (ODR wrt CK)
+        assert(!(memSpec.dataRate == 4) || (burstLength == 8));  // DDR mode (QDR wrt CK)
+        assert(!(memSpec.dataRate == 8) || (burstLength == 16)); // QDR mode (ODR wrt CK)
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDRD);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart =
             lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank]
@@ -110,15 +107,15 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] !=
                                    lastScheduledByCommandAndRank[Command::RDA][rank]
@@ -126,14 +123,14 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
             if (lastCommandStart != scMaxTime)
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP);
+                    std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec.tRTP);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
@@ -168,25 +165,25 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tLK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tLK);
     }
     else if (command == Command::WR || command == Command::WRA)
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
-        assert(!(memSpec->dataRate == 4) || (burstLength == 8));  // DDR mode (QDR wrt CK)
-        assert(!(memSpec->dataRate == 8) || (burstLength == 16)); // QDR mode (ODR wrt CK)
+        assert(!(memSpec.dataRate == 4) || (burstLength == 8));  // DDR mode (QDR wrt CK)
+        assert(!(memSpec.dataRate == 8) || (burstLength == 16)); // QDR mode (ODR wrt CK)
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDWR);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW);
 
         lastCommandStart =
             lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank]
@@ -197,7 +194,7 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] !=
                                    lastScheduledByCommandAndRank[Command::RDA][rank]
@@ -208,11 +205,11 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart =
             lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank]
@@ -220,15 +217,15 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommand[Command::WRA] !=
                                    lastScheduledByCommandAndRank[Command::WRA][rank]
@@ -236,89 +233,89 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tLK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tLK);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
 
         if (last32Activates[rank].size() >= 32)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last32Activates[rank].front() + memSpec->t32AW);
+                std::max(earliestTimeToStart, last32Activates[rank].front() + memSpec.t32AW);
     }
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
         if (lastCommandStart != scMaxTime)
@@ -326,25 +323,25 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
@@ -356,126 +353,126 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
         {
             if (bankwiseRefreshCounter[rank] == 0)
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
             else
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
 
         if (last32Activates[rank].size() >= 32)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last32Activates[rank].front() + memSpec->t32AW);
+                std::max(earliestTimeToStart, last32Activates[rank].front() + memSpec.t32AW);
     }
     else if (command == Command::PDEA)
     {
@@ -497,13 +494,13 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::PDEP)
     {
@@ -521,23 +518,23 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -547,49 +544,49 @@ sc_time CheckerGDDR5X::timeToSatisfyConstraints(Command command,
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + std::max(memSpec->tRTP + memSpec->tRP, tRDSRE));
+                         lastCommandStart + std::max(memSpec.tRTP + memSpec.tRP, tRDSRE));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCPB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCPB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else
         SC_REPORT_FATAL("CheckerGDDR5X", "Unknown command!");
 
     // Check if command bus is free
     if (lastCommandOnBus != scMaxTime)
-        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK);
 
     return earliestTimeToStart;
 }
@@ -622,7 +619,7 @@ void CheckerGDDR5X::insert(Command command, const tlm_generic_payload& payload)
     }
 
     if (command == Command::REFPB)
-        bankwiseRefreshCounter[rank] = (bankwiseRefreshCounter[rank] + 1) % memSpec->banksPerRank;
+        bankwiseRefreshCounter[rank] = (bankwiseRefreshCounter[rank] + 1) % memSpec.banksPerRank;
 }
 
 } // namespace DRAMSys
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5X.h b/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5X.h
index f287fede..689d4f55 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5X.h
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR5X.h
@@ -35,7 +35,6 @@
 #ifndef CHECKERGDDR5X_H
 #define CHECKERGDDR5X_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpecGDDR5X.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 
@@ -48,14 +47,14 @@ namespace DRAMSys
 class CheckerGDDR5X final : public CheckerIF
 {
 public:
-    explicit CheckerGDDR5X(const Configuration& config);
+    explicit CheckerGDDR5X(const MemSpecGDDR5X& memSpec);
     [[nodiscard]] sc_core::sc_time
     timeToSatisfyConstraints(Command command,
                              const tlm::tlm_generic_payload& payload) const override;
     void insert(Command command, const tlm::tlm_generic_payload& payload) override;
 
 private:
-    const MemSpecGDDR5X* memSpec;
+    const MemSpecGDDR5X& memSpec;
 
     std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
     std::vector<ControllerVector<BankGroup, sc_core::sc_time>> lastScheduledByCommandAndBankGroup;
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR6.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR6.cpp
index 3305e8fe..d6edeac1 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR6.cpp
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR6.cpp
@@ -44,35 +44,32 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-CheckerGDDR6::CheckerGDDR6(const Configuration& config) :
-    memSpec(dynamic_cast<const MemSpecGDDR6*>(config.memSpec.get()))
+CheckerGDDR6::CheckerGDDR6(const MemSpecGDDR6& memSpec) :
+    memSpec(memSpec)
 {
-    if (memSpec == nullptr)
-        SC_REPORT_FATAL("CheckerGDDR6", "Wrong MemSpec chosen");
-
     lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
+        ControllerVector<Bank, sc_time>(memSpec.banksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<BankGroup, sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
+        ControllerVector<BankGroup, sc_time>(memSpec.bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
+        ControllerVector<Rank, sc_time>(memSpec.ranksPerChannel, scMaxTime));
     lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
     lastCommandOnBus = scMaxTime;
-    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
+    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec.ranksPerChannel);
 
-    bankwiseRefreshCounter = ControllerVector<Rank, unsigned>(memSpec->ranksPerChannel);
+    bankwiseRefreshCounter = ControllerVector<Rank, unsigned>(memSpec.ranksPerChannel);
 
-    tBURST = memSpec->defaultBurstLength / memSpec->dataRate * memSpec->tCK;
-    tRDSRE = memSpec->tRL + memSpec->tWCK2CKPIN + memSpec->tWCK2CK + memSpec->tWCK2DQO + tBURST;
-    tWRSRE = memSpec->tWL + memSpec->tWCK2CKPIN + memSpec->tWCK2CK + memSpec->tWCK2DQI + tBURST;
-    tRDWR_R = memSpec->tRL + tBURST + memSpec->tRTRS - memSpec->tWL;
-    tWRRD_R = memSpec->tWL + tBURST + memSpec->tRTRS - memSpec->tRL;
-    tWRRD_S = memSpec->tWL + tBURST + memSpec->tWTRS;
-    tWRRD_L = memSpec->tWL + tBURST + memSpec->tWTRL;
-    tWRPRE = memSpec->tWL + tBURST + memSpec->tWR;
+    tBURST = memSpec.defaultBurstLength / memSpec.dataRate * memSpec.tCK;
+    tRDSRE = memSpec.tRL + memSpec.tWCK2CKPIN + memSpec.tWCK2CK + memSpec.tWCK2DQO + tBURST;
+    tWRSRE = memSpec.tWL + memSpec.tWCK2CKPIN + memSpec.tWCK2CK + memSpec.tWCK2DQI + tBURST;
+    tRDWR_R = memSpec.tRL + tBURST + memSpec.tRTRS - memSpec.tWL;
+    tWRRD_R = memSpec.tWL + tBURST + memSpec.tRTRS - memSpec.tRL;
+    tWRRD_S = memSpec.tWL + tBURST + memSpec.tWTRS;
+    tWRRD_L = memSpec.tWL + tBURST + memSpec.tWTRL;
+    tWRPRE = memSpec.tWL + tBURST + memSpec.tWR;
 }
 
 sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
@@ -91,15 +88,15 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDRD);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart =
             lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank]
@@ -107,15 +104,15 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] !=
                                    lastScheduledByCommandAndRank[Command::RDA][rank]
@@ -123,14 +120,14 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
             if (lastCommandStart != scMaxTime)
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP);
+                    std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec.tRTP);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
@@ -165,11 +162,11 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tLK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tLK);
     }
     else if (command == Command::WR || command == Command::WRA)
     {
@@ -177,11 +174,11 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDWR);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW);
 
         lastCommandStart =
             lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank]
@@ -192,7 +189,7 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] !=
                                    lastScheduledByCommandAndRank[Command::RDA][rank]
@@ -203,11 +200,11 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart =
             lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank]
@@ -215,15 +212,15 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommand[Command::WRA] !=
                                    lastScheduledByCommandAndRank[Command::WRA][rank]
@@ -231,85 +228,85 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tLK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tLK);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
     }
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
         if (lastCommandStart != scMaxTime)
@@ -317,25 +314,25 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
@@ -347,129 +344,129 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
         {
             if (bankwiseRefreshCounter[rank] == 0)
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
             else
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
     }
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tACTPDE);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tACTPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -490,22 +487,22 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tPREPDE);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tPREPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFPDE);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tREFPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::PDEP)
     {
@@ -524,42 +521,42 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tPREPDE);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tPREPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tPREPDE);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tPREPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFPDE);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tREFPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tREFPDE);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tREFPDE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -569,49 +566,49 @@ sc_time CheckerGDDR6::timeToSatisfyConstraints(Command command,
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + std::max(memSpec->tRTP + memSpec->tRP, tRDSRE));
+                         lastCommandStart + std::max(memSpec.tRTP + memSpec.tRP, tRDSRE));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKESR);
     }
     else
         SC_REPORT_FATAL("CheckerGDDR6", "Unknown command!");
 
     // Check if command bus is free
     if (lastCommandOnBus != scMaxTime)
-        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK);
 
     return earliestTimeToStart;
 }
@@ -640,7 +637,7 @@ void CheckerGDDR6::insert(Command command, const tlm_generic_payload& payload)
     }
 
     if (command == Command::REFPB)
-        bankwiseRefreshCounter[rank] = (bankwiseRefreshCounter[rank] + 1) % memSpec->banksPerRank;
+        bankwiseRefreshCounter[rank] = (bankwiseRefreshCounter[rank] + 1) % memSpec.banksPerRank;
 }
 
 } // namespace DRAMSys
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR6.h b/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR6.h
index ab47894e..7a01e313 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR6.h
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerGDDR6.h
@@ -35,7 +35,6 @@
 #ifndef CHECKERGDDR6_H
 #define CHECKERGDDR6_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpecGDDR6.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 
@@ -48,14 +47,14 @@ namespace DRAMSys
 class CheckerGDDR6 final : public CheckerIF
 {
 public:
-    explicit CheckerGDDR6(const Configuration& config);
+    explicit CheckerGDDR6(const MemSpecGDDR6 &memSpec);
     [[nodiscard]] sc_core::sc_time
     timeToSatisfyConstraints(Command command,
                              const tlm::tlm_generic_payload& payload) const override;
     void insert(Command command, const tlm::tlm_generic_payload& payload) override;
 
 private:
-    const MemSpecGDDR6* memSpec;
+    const MemSpecGDDR6& memSpec;
 
     std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
     std::vector<ControllerVector<BankGroup, sc_core::sc_time>> lastScheduledByCommandAndBankGroup;
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.cpp
index b794b7ce..4cb8dfe6 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.cpp
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.cpp
@@ -35,6 +35,7 @@
 #include "CheckerHBM2.h"
 
 #include "DRAMSys/common/DebugManager.h"
+#include "DRAMSys/configuration/memspec/MemSpecHBM2.h"
 
 #include <algorithm>
 
@@ -44,36 +45,33 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-CheckerHBM2::CheckerHBM2(const Configuration& config) :
-    memSpec(dynamic_cast<const MemSpecHBM2*>(config.memSpec.get()))
+CheckerHBM2::CheckerHBM2(const MemSpecHBM2& memSpec) :
+    memSpec(memSpec)
 {
-    if (memSpec == nullptr)
-        SC_REPORT_FATAL("CheckerHBM2", "Wrong MemSpec chosen");
-
     lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
+        ControllerVector<Bank, sc_time>(memSpec.banksPerChannel, scMaxTime));
     lastScheduledByCommandAndBankGroup = std::vector<ControllerVector<BankGroup, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<BankGroup, sc_time>(memSpec->bankGroupsPerChannel, scMaxTime));
+        ControllerVector<BankGroup, sc_time>(memSpec.bankGroupsPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
+        ControllerVector<Rank, sc_time>(memSpec.ranksPerChannel, scMaxTime));
     lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
     lastCommandOnRasBus = scMaxTime;
     lastCommandOnCasBus = scMaxTime;
-    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
+    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec.ranksPerChannel);
 
-    bankwiseRefreshCounter = ControllerVector<Rank, unsigned>(memSpec->ranksPerChannel);
+    bankwiseRefreshCounter = ControllerVector<Rank, unsigned>(memSpec.ranksPerChannel);
 
-    tBURST = memSpec->defaultBurstLength / memSpec->dataRate * memSpec->tCK;
-    tRDPDE = memSpec->tRL + memSpec->tPL + tBURST + memSpec->tCK;
+    tBURST = memSpec.defaultBurstLength / memSpec.dataRate * memSpec.tCK;
+    tRDPDE = memSpec.tRL + memSpec.tPL + tBURST + memSpec.tCK;
     tRDSRE = tRDPDE;
-    tWRPRE = memSpec->tWL + tBURST + memSpec->tWR;
-    tWRPDE = memSpec->tWL + memSpec->tPL + tBURST + memSpec->tCK + memSpec->tWR;
-    tWRAPDE = memSpec->tWL + memSpec->tPL + tBURST + memSpec->tCK + memSpec->tWR;
-    tWRRDS = memSpec->tWL + tBURST + memSpec->tWTRS;
-    tWRRDL = memSpec->tWL + tBURST + memSpec->tWTRL;
+    tWRPRE = memSpec.tWL + tBURST + memSpec.tWR;
+    tWRPDE = memSpec.tWL + memSpec.tPL + tBURST + memSpec.tCK + memSpec.tWR;
+    tWRAPDE = memSpec.tWL + memSpec.tPL + tBURST + memSpec.tCK + memSpec.tWR;
+    tWRRDS = memSpec.tWL + tBURST + memSpec.tWTRS;
+    tWRRDL = memSpec.tWL + tBURST + memSpec.tWTRL;
 }
 
 sc_time CheckerHBM2::timeToSatisfyConstraints(Command command,
@@ -89,37 +87,37 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command,
     if (command == Command::RD || command == Command::RDA)
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
-        assert(!(memSpec->ranksPerChannel == 1) ||
+        assert(!(memSpec.ranksPerChannel == 1) ||
                (burstLength == 2 || burstLength == 4));                 // Legacy mode
-        assert(!(memSpec->ranksPerChannel == 2) || (burstLength == 4)); // Pseudo-channel mode
+        assert(!(memSpec.ranksPerChannel == 2) || (burstLength == 4)); // Pseudo-channel mode
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDRD + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDRD + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RD][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::RDA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
             if (lastCommandStart != scMaxTime)
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP);
+                    std::max(earliestTimeToStart, lastCommandStart + tWRPRE - memSpec.tRTP);
         }
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
@@ -140,128 +138,128 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::WR || command == Command::WRA || command == Command::MWR ||
              command == Command::MWRA)
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
-        assert(!(memSpec->ranksPerChannel == 1) ||
+        assert(!(memSpec.ranksPerChannel == 1) ||
                (burstLength == 2 || burstLength == 4));                 // Legacy mode
-        assert(!(memSpec->ranksPerChannel == 2) || (burstLength == 4)); // Pseudo-channel mode
+        assert(!(memSpec.ranksPerChannel == 2) || (burstLength == 4)); // Pseudo-channel mode
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCDWR + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCDWR + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTW);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTW);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WR][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::WRA][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDS);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + memSpec->tRTP + memSpec->tRP - memSpec->tCK);
+                         lastCommandStart + memSpec.tRTP + memSpec.tRP - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart,
-                                           lastCommandStart + tWRPRE + memSpec->tRP - memSpec->tCK);
+                                           lastCommandStart + tWRPRE + memSpec.tRP - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXP];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCSB - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD - memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS - memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS - memSpec.tCK);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW - memSpec->tCK);
+                earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW - memSpec.tCK);
     }
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
         if (lastCommandStart != scMaxTime)
@@ -269,22 +267,22 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
@@ -296,122 +294,122 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCSB);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXP];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCSB);
 
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBankGroup[Command::ACT][bankGroup];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDL + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDL + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRDS + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRDS + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRTP + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXP];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCSB);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
         {
             if (bankwiseRefreshCounter[rank] == 0)
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCSB);
             else
                 earliestTimeToStart =
-                    std::max(earliestTimeToStart, lastCommandStart + memSpec->tRREFD);
+                    std::max(earliestTimeToStart, lastCommandStart + memSpec.tRREFD);
         }
 
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
     }
     else if (command == Command::PDEA)
     {
@@ -433,13 +431,13 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommand[Command::PDXA];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommand[Command::PDEA];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::PDEP)
     {
@@ -457,65 +455,65 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommand[Command::PDXP];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
 
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommand[Command::PDEP];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommand[Command::ACT];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC + memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC + memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + std::max(memSpec->tRTP + memSpec->tRP, tRDSRE));
+                         lastCommandStart + std::max(memSpec.tRTP + memSpec.tRP, tRDSRE));
 
         lastCommandStart = lastScheduledByCommand[Command::WRA];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommand[Command::PREPB];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommand[Command::PREAB];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommand[Command::PDXP];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommand[Command::REFAB];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommand[Command::REFPB];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCSB);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCSB);
 
         lastCommandStart = lastScheduledByCommand[Command::SREFEX];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommand[Command::SREFEN];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKESR);
     }
     else
         SC_REPORT_FATAL("CheckerHBM2", "Unknown command!");
@@ -523,12 +521,12 @@ sc_time CheckerHBM2::timeToSatisfyConstraints(Command command,
     if (command.isRasCommand())
     {
         if (lastCommandOnRasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnRasBus + memSpec.tCK);
     }
     else
     {
         if (lastCommandOnCasBus != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec->tCK);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnCasBus + memSpec.tCK);
     }
 
     return earliestTimeToStart;
@@ -558,7 +556,7 @@ void CheckerHBM2::insert(Command command, const tlm_generic_payload& payload)
     if (command.isCasCommand())
         lastCommandOnCasBus = sc_time_stamp();
     else if (command == Command::ACT)
-        lastCommandOnRasBus = sc_time_stamp() + memSpec->tCK;
+        lastCommandOnRasBus = sc_time_stamp() + memSpec.tCK;
     else
         lastCommandOnRasBus = sc_time_stamp();
 
@@ -570,7 +568,7 @@ void CheckerHBM2::insert(Command command, const tlm_generic_payload& payload)
     }
 
     if (command == Command::REFPB)
-        bankwiseRefreshCounter[rank] = (bankwiseRefreshCounter[rank] + 1) % memSpec->banksPerRank;
+        bankwiseRefreshCounter[rank] = (bankwiseRefreshCounter[rank] + 1) % memSpec.banksPerRank;
 }
 
 } // namespace DRAMSys
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.h b/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.h
index c90dc952..be0bc0db 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.h
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerHBM2.h
@@ -35,7 +35,6 @@
 #ifndef CHECKERHBM2_H
 #define CHECKERHBM2_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpecHBM2.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 
@@ -48,14 +47,14 @@ namespace DRAMSys
 class CheckerHBM2 final : public CheckerIF
 {
 public:
-    explicit CheckerHBM2(const Configuration& config);
+    explicit CheckerHBM2(const MemSpecHBM2& memSpec);
     [[nodiscard]] sc_core::sc_time
     timeToSatisfyConstraints(Command command,
                              const tlm::tlm_generic_payload& payload) const override;
     void insert(Command command, const tlm::tlm_generic_payload& payload) override;
 
 private:
-    const MemSpecHBM2* memSpec;
+    const MemSpecHBM2& memSpec;
 
     std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
     std::vector<ControllerVector<BankGroup, sc_core::sc_time>> lastScheduledByCommandAndBankGroup;
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.cpp
index 564f8aab..3753c75a 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.cpp
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.cpp
@@ -44,49 +44,46 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-CheckerLPDDR4::CheckerLPDDR4(const Configuration& config) :
-    memSpec(dynamic_cast<const MemSpecLPDDR4*>(config.memSpec.get()))
+CheckerLPDDR4::CheckerLPDDR4(const MemSpecLPDDR4& memSpec) :
+    memSpec(memSpec)
 {
-    if (memSpec == nullptr)
-        SC_REPORT_FATAL("CheckerLPDDR4", "Wrong MemSpec chosen");
-
     lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
+        ControllerVector<Bank, sc_time>(memSpec.banksPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
+        ControllerVector<Rank, sc_time>(memSpec.ranksPerChannel, scMaxTime));
     lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
     lastCommandOnBus = scMaxTime;
-    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
+    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec.ranksPerChannel);
 
     lastBurstLengthByCommandAndBank = ControllerVector<Command, ControllerVector<Bank, uint8_t>>(
-        Command::WRA + 1, ControllerVector<Bank, uint8_t>(memSpec->banksPerChannel));
+        Command::WRA + 1, ControllerVector<Bank, uint8_t>(memSpec.banksPerChannel));
 
-    tBURST = memSpec->defaultBurstLength / memSpec->dataRate * memSpec->tCK;
+    tBURST = memSpec.defaultBurstLength / memSpec.dataRate * memSpec.tCK;
     tRDWR =
-        memSpec->tRL + memSpec->tDQSCK + tBURST - memSpec->tWL + memSpec->tWPRE + memSpec->tRPST;
-    tRDWR_R = memSpec->tRL + tBURST + memSpec->tRTRS - memSpec->tWL;
-    tWRRD = memSpec->tWL + memSpec->tCK + tBURST + memSpec->tWTR;
-    tWRRD_R = memSpec->tWL + tBURST + memSpec->tRTRS - memSpec->tRL;
-    tRDPRE = memSpec->tRTP + tBURST - 6 * memSpec->tCK;
-    tRDAACT = memSpec->tRTP + tBURST - 8 * memSpec->tCK + memSpec->tRPpb;
-    tWRPRE = memSpec->tWL + tBURST + memSpec->tCK + memSpec->tWR + 2 * memSpec->tCK;
-    tWRAACT = memSpec->tWL + tBURST + memSpec->tCK + memSpec->tWR + memSpec->tRPpb;
-    tACTPDEN = 3 * memSpec->tCK + memSpec->tCMDCKE;
-    tPRPDEN = memSpec->tCK + memSpec->tCMDCKE;
-    tRDPDEN = 3 * memSpec->tCK + memSpec->tRL + memSpec->tDQSCK + tBURST + memSpec->tRPST;
+        memSpec.tRL + memSpec.tDQSCK + tBURST - memSpec.tWL + memSpec.tWPRE + memSpec.tRPST;
+    tRDWR_R = memSpec.tRL + tBURST + memSpec.tRTRS - memSpec.tWL;
+    tWRRD = memSpec.tWL + memSpec.tCK + tBURST + memSpec.tWTR;
+    tWRRD_R = memSpec.tWL + tBURST + memSpec.tRTRS - memSpec.tRL;
+    tRDPRE = memSpec.tRTP + tBURST - 6 * memSpec.tCK;
+    tRDAACT = memSpec.tRTP + tBURST - 8 * memSpec.tCK + memSpec.tRPpb;
+    tWRPRE = memSpec.tWL + tBURST + memSpec.tCK + memSpec.tWR + 2 * memSpec.tCK;
+    tWRAACT = memSpec.tWL + tBURST + memSpec.tCK + memSpec.tWR + memSpec.tRPpb;
+    tACTPDEN = 3 * memSpec.tCK + memSpec.tCMDCKE;
+    tPRPDEN = memSpec.tCK + memSpec.tCMDCKE;
+    tRDPDEN = 3 * memSpec.tCK + memSpec.tRL + memSpec.tDQSCK + tBURST + memSpec.tRPST;
     tWRPDEN =
-        3 * memSpec->tCK + memSpec->tWL +
-        (std::ceil(memSpec->tDQSS / memSpec->tCK) + std::ceil(memSpec->tDQS2DQ / memSpec->tCK)) *
-            memSpec->tCK +
-        tBURST + memSpec->tWR;
+        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;
+        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,
@@ -102,11 +99,11 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command,
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
         assert((burstLength == 16) || (burstLength == 32)); // TODO: BL16/32 OTF
-        assert(burstLength <= memSpec->maxBurstLength);
+        assert(burstLength <= memSpec.maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -118,7 +115,7 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
@@ -130,7 +127,7 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         if (command == Command::RDA)
         {
@@ -164,18 +161,18 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::WR || command == Command::WRA || command == Command::MWR ||
              command == Command::MWRA)
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
         assert((burstLength == 16) || (burstLength == 32));
-        assert(burstLength <= memSpec->maxBurstLength);
+        assert(burstLength <= memSpec.maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -209,7 +206,7 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
@@ -221,7 +218,7 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         if (command == Command::MWR || command == Command::MWRA)
         {
@@ -230,36 +227,36 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command,
             {
                 if (lastBurstLengthByCommandAndBank[Command::WR][bank] == 32)
                     earliestTimeToStart = std::max(
-                        earliestTimeToStart, lastCommandStart + memSpec->tCCDMW + 8 * memSpec->tCK);
+                        earliestTimeToStart, lastCommandStart + memSpec.tCCDMW + 8 * memSpec.tCK);
                 else
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDMW);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDMW);
             }
 
             lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
             {
                 if (lastBurstLengthByCommandAndBank[Command::WRA][bank] == 32)
                     earliestTimeToStart = std::max(
-                        earliestTimeToStart, lastCommandStart + memSpec->tCCDMW + 8 * memSpec->tCK);
+                        earliestTimeToStart, lastCommandStart + memSpec.tCCDMW + 8 * memSpec.tCK);
                 else
                     earliestTimeToStart =
-                        std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCDMW);
+                        std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCDMW);
             }
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
@@ -272,52 +269,52 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb - 2 * memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb - 2 * memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab - 2 * memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab - 2 * memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart,
-                                           lastCommandStart + memSpec->tRFCab - 2 * memSpec->tCK);
+                                           lastCommandStart + memSpec.tRFCab - 2 * memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(earliestTimeToStart,
-                                           lastCommandStart + memSpec->tRFCpb - 2 * memSpec->tCK);
+                                           lastCommandStart + memSpec.tRFCpb - 2 * memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD - 2 * memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD - 2 * memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR - 2 * memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR - 2 * memSpec.tCK);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         last4Activates[rank].front() + memSpec->tFAW - 3 * memSpec->tCK);
+                         last4Activates[rank].front() + memSpec.tFAW - 3 * memSpec.tCK);
     }
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + 2 * memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + 2 * memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
@@ -329,18 +326,18 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS + 2 * memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS + 2 * memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -360,110 +357,110 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPPD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + 2 * memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + 2 * memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec->tRPpb);
+                std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRPpb);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR);
     }
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + 2 * memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + 2 * memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD + 2 * memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD + 2 * memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec->tRPpb);
+                std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRPpb);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW - memSpec->tCK);
+                earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW - memSpec.tCK);
     }
     else if (command == Command::PDEA)
     {
@@ -497,13 +494,13 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else if (command == Command::PDEP)
     {
@@ -537,72 +534,72 @@ sc_time CheckerLPDDR4::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb + 2 * memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb + 2 * memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, lastCommandStart + std::max(tRDPDEN, tRDPRE + memSpec->tRPpb));
+                earliestTimeToStart, lastCommandStart + std::max(tRDPDEN, tRDPRE + memSpec.tRPpb));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec->tRPpb));
+                         lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec.tRPpb));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tSR);
     }
     else
         SC_REPORT_FATAL("CheckerLPDDR4", "Unknown command!");
 
     // Check if command bus is free
     if (lastCommandOnBus != scMaxTime)
-        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK);
 
     return earliestTimeToStart;
 }
@@ -626,7 +623,7 @@ void CheckerLPDDR4::insert(Command command, const tlm_generic_payload& payload)
     lastScheduledByCommandAndRank[command][rank] = sc_time_stamp();
     lastScheduledByCommand[command] = sc_time_stamp();
 
-    lastCommandOnBus = sc_time_stamp() + memSpec->getCommandLength(command) - memSpec->tCK;
+    lastCommandOnBus = sc_time_stamp() + memSpec.getCommandLength(command) - memSpec.tCK;
 
     if (command == Command::ACT || command == Command::REFPB)
     {
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.h b/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.h
index 9ae8ef4d..cda1d9ee 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.h
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerLPDDR4.h
@@ -35,7 +35,6 @@
 #ifndef CHECKERLPDDR4_H
 #define CHECKERLPDDR4_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpecLPDDR4.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 
@@ -48,14 +47,14 @@ namespace DRAMSys
 class CheckerLPDDR4 final : public CheckerIF
 {
 public:
-    explicit CheckerLPDDR4(const Configuration& config);
+    explicit CheckerLPDDR4(const MemSpecLPDDR4& memSpec);
     [[nodiscard]] sc_core::sc_time
     timeToSatisfyConstraints(Command command,
                              const tlm::tlm_generic_payload& payload) const override;
     void insert(Command command, const tlm::tlm_generic_payload& payload) override;
 
 private:
-    const MemSpecLPDDR4* memSpec;
+    const MemSpecLPDDR4& memSpec;
 
     std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
     std::vector<ControllerVector<Rank, sc_core::sc_time>> lastScheduledByCommandAndRank;
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerSTTMRAM.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerSTTMRAM.cpp
index 63db733b..f0594dcb 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerSTTMRAM.cpp
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerSTTMRAM.cpp
@@ -44,31 +44,28 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-CheckerSTTMRAM::CheckerSTTMRAM(const Configuration& config) :
-    memSpec(dynamic_cast<const MemSpecSTTMRAM*>(config.memSpec.get()))
+CheckerSTTMRAM::CheckerSTTMRAM(const MemSpecSTTMRAM& memSpec) :
+    memSpec(memSpec)
 {
-    if (memSpec == nullptr)
-        SC_REPORT_FATAL("CheckerSTTMRAM", "Wrong MemSpec chosen");
-
     lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
+        ControllerVector<Bank, sc_time>(memSpec.banksPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
+        ControllerVector<Rank, sc_time>(memSpec.ranksPerChannel, scMaxTime));
     lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
     lastCommandOnBus = scMaxTime;
-    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
+    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec.ranksPerChannel);
 
-    tBURST = memSpec->defaultBurstLength / memSpec->dataRate * memSpec->tCK;
-    tRDWR = memSpec->tRL + tBURST + 2 * memSpec->tCK - memSpec->tWL;
-    tRDWR_R = memSpec->tRL + tBURST + memSpec->tRTRS - memSpec->tWL;
-    tWRRD = memSpec->tWL + tBURST + memSpec->tWTR - memSpec->tAL;
-    tWRRD_R = memSpec->tWL + tBURST + memSpec->tRTRS - memSpec->tRL;
-    tWRPRE = memSpec->tWL + tBURST + memSpec->tWR;
-    tRDPDEN = memSpec->tRL + tBURST + memSpec->tCK;
-    tWRPDEN = memSpec->tWL + tBURST + memSpec->tWR;
-    tWRAPDEN = memSpec->tWL + tBURST + memSpec->tWR + memSpec->tCK;
+    tBURST = memSpec.defaultBurstLength / memSpec.dataRate * memSpec.tCK;
+    tRDWR = memSpec.tRL + tBURST + 2 * memSpec.tCK - memSpec.tWL;
+    tRDWR_R = memSpec.tRL + tBURST + memSpec.tRTRS - memSpec.tWL;
+    tWRRD = memSpec.tWL + tBURST + memSpec.tWTR - memSpec.tAL;
+    tWRRD_R = memSpec.tWL + tBURST + memSpec.tRTRS - memSpec.tRL;
+    tWRPRE = memSpec.tWL + tBURST + memSpec.tWR;
+    tRDPDEN = memSpec.tRL + tBURST + memSpec.tCK;
+    tWRPDEN = memSpec.tWL + tBURST + memSpec.tWR;
+    tWRAPDEN = memSpec.tWL + tBURST + memSpec.tWR + memSpec.tCK;
 }
 
 sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command,
@@ -87,11 +84,11 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD - memSpec->tAL);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD - memSpec.tAL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD);
 
         lastCommandStart =
             lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank]
@@ -99,11 +96,11 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] !=
                                    lastScheduledByCommandAndRank[Command::RDA][rank]
@@ -111,14 +108,14 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         if (command == Command::RDA)
         {
             lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
             if (lastCommandStart != scMaxTime)
                 earliestTimeToStart = std::max(
-                    earliestTimeToStart, lastCommandStart + tWRPRE - memSpec->tRTP - memSpec->tAL);
+                    earliestTimeToStart, lastCommandStart + tWRPRE - memSpec.tRTP - memSpec.tAL);
         }
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
@@ -139,11 +136,11 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSDLL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSDLL);
     }
     else if (command == Command::WR || command == Command::WRA || command == Command::MWR ||
              command == Command::MWRA)
@@ -153,7 +150,7 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD - memSpec->tAL);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD - memSpec.tAL);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -179,7 +176,7 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD);
 
         lastCommandStart =
             lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank]
@@ -187,11 +184,11 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD);
 
         lastCommandStart = lastScheduledByCommand[Command::WRA] !=
                                    lastScheduledByCommandAndRank[Command::WRA][rank]
@@ -199,71 +196,71 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSDLL);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSDLL);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + memSpec->tAL + memSpec->tRTP + memSpec->tRP);
+                         lastCommandStart + memSpec.tAL + memSpec.tRTP + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
     }
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WR][bank];
         if (lastCommandStart != scMaxTime)
@@ -271,23 +268,23 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tAL + memSpec->tRTP);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tAL + memSpec.tRTP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
@@ -299,14 +296,14 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::PDEA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tACTPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tACTPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -327,17 +324,17 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::PDEP)
     {
@@ -356,71 +353,71 @@ sc_time CheckerSTTMRAM::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + memSpec->tPRPDEN);
+                std::max(earliestTimeToStart, lastCommandStart + memSpec.tPRPDEN);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tPD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tPD);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
                 earliestTimeToStart,
-                lastCommandStart + std::max(tRDPDEN, memSpec->tAL + memSpec->tRTP + memSpec->tRP));
+                lastCommandStart + std::max(tRDPDEN, memSpec.tAL + memSpec.tRTP + memSpec.tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec->tRP));
+                earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec.tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXS);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKESR);
     }
     else
         SC_REPORT_FATAL("CheckerSTTMRAM", "Unknown command!");
 
     if (lastCommandOnBus != scMaxTime)
-        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK);
 
     return earliestTimeToStart;
 }
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerSTTMRAM.h b/src/libdramsys/DRAMSys/controller/checker/CheckerSTTMRAM.h
index 6523289f..269ece03 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerSTTMRAM.h
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerSTTMRAM.h
@@ -35,7 +35,6 @@
 #ifndef CHECKERSTTMRAM_H
 #define CHECKERSTTMRAM_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpecSTTMRAM.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 
@@ -48,14 +47,14 @@ namespace DRAMSys
 class CheckerSTTMRAM final : public CheckerIF
 {
 public:
-    explicit CheckerSTTMRAM(const Configuration& config);
+    explicit CheckerSTTMRAM(const MemSpecSTTMRAM& memSpec);
     [[nodiscard]] sc_core::sc_time
     timeToSatisfyConstraints(Command command,
                              const tlm::tlm_generic_payload& payload) const override;
     void insert(Command command, const tlm::tlm_generic_payload& payload) override;
 
 private:
-    const MemSpecSTTMRAM* memSpec;
+    const MemSpecSTTMRAM& memSpec;
 
     std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
     std::vector<ControllerVector<Rank, sc_core::sc_time>> lastScheduledByCommandAndRank;
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO.cpp
index bd9471fe..085d2962 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO.cpp
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO.cpp
@@ -44,31 +44,28 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-CheckerWideIO::CheckerWideIO(const Configuration& config) :
-    memSpec(dynamic_cast<const MemSpecWideIO*>(config.memSpec.get()))
+CheckerWideIO::CheckerWideIO(const MemSpecWideIO& memSpec) :
+    memSpec(memSpec)
 {
-    if (memSpec == nullptr)
-        SC_REPORT_FATAL("CheckerWideIO", "Wrong MemSpec chosen");
-
     lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
+        ControllerVector<Bank, sc_time>(memSpec.banksPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
+        ControllerVector<Rank, sc_time>(memSpec.ranksPerChannel, scMaxTime));
     lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
     lastCommandOnBus = scMaxTime;
-    last2Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
+    last2Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec.ranksPerChannel);
 
-    tBURST = memSpec->defaultBurstLength * memSpec->tCK;
-    tRDWR = memSpec->tRL + tBURST + memSpec->tCK;
-    tRDWR_R = memSpec->tRL + tBURST + memSpec->tRTRS - memSpec->tWL;
-    tWRPRE = memSpec->tWL + tBURST - memSpec->tCK + memSpec->tWR;
-    tWRRD = memSpec->tWL + tBURST - memSpec->tCK + memSpec->tWTR;
-    tWRRD_R = memSpec->tWL + tBURST + memSpec->tRTRS - memSpec->tRL;
-    tRDPDEN = memSpec->tRL + tBURST; // + memSpec->tCK; ??
-    tWRPDEN = memSpec->tWL + tBURST + memSpec->tWR - memSpec->tCK;
-    tWRAPDEN = memSpec->tWL + tBURST + memSpec->tWR; // + memSpec->tCK; ??
+    tBURST = memSpec.defaultBurstLength * memSpec.tCK;
+    tRDWR = memSpec.tRL + tBURST + memSpec.tCK;
+    tRDWR_R = memSpec.tRL + tBURST + memSpec.tRTRS - memSpec.tWL;
+    tWRPRE = memSpec.tWL + tBURST - memSpec.tCK + memSpec.tWR;
+    tWRRD = memSpec.tWL + tBURST - memSpec.tCK + memSpec.tWTR;
+    tWRRD_R = memSpec.tWL + tBURST + memSpec.tRTRS - memSpec.tRL;
+    tRDPDEN = memSpec.tRL + tBURST; // + memSpec.tCK; ??
+    tWRPDEN = memSpec.tWL + tBURST + memSpec.tWR - memSpec.tCK;
+    tWRAPDEN = memSpec.tWL + tBURST + memSpec.tWR; // + memSpec.tCK; ??
 }
 
 sc_time CheckerWideIO::timeToSatisfyConstraints(Command command,
@@ -84,11 +81,11 @@ sc_time CheckerWideIO::timeToSatisfyConstraints(Command command,
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
         assert((burstLength == 2) || (burstLength == 4));
-        assert(burstLength <= memSpec->maxBurstLength);
+        assert(burstLength <= memSpec.maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -100,7 +97,7 @@ sc_time CheckerWideIO::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
@@ -112,7 +109,7 @@ sc_time CheckerWideIO::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         if (command == Command::RDA)
         {
@@ -146,18 +143,18 @@ sc_time CheckerWideIO::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::WR || command == Command::WRA || command == Command::MWR ||
              command == Command::MWRA)
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
         assert((burstLength == 2) || (burstLength == 4));
-        assert(burstLength <= memSpec->maxBurstLength);
+        assert(burstLength <= memSpec.maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -191,7 +188,7 @@ sc_time CheckerWideIO::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
@@ -203,65 +200,65 @@ sc_time CheckerWideIO::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR);
 
         if (last2Activates[rank].size() >= 2)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last2Activates[rank].front() + memSpec->tTAW);
+                std::max(earliestTimeToStart, last2Activates[rank].front() + memSpec.tTAW);
     }
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
@@ -273,13 +270,13 @@ sc_time CheckerWideIO::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -299,43 +296,43 @@ sc_time CheckerWideIO::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRP);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR);
     }
     else if (command == Command::PDEA)
     {
@@ -357,13 +354,13 @@ sc_time CheckerWideIO::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else if (command == Command::PDEP)
     {
@@ -381,66 +378,66 @@ sc_time CheckerWideIO::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, lastCommandStart + std::max(tRDPDEN, tBURST + memSpec->tRP));
+                earliestTimeToStart, lastCommandStart + std::max(tRDPDEN, tBURST + memSpec.tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec->tRP));
+                earliestTimeToStart, lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec.tRP));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFC);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFC);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKESR);
     }
     else
         SC_REPORT_FATAL("CheckerWideIO", "Unknown command!");
 
     // Check if command bus is free
     if (lastCommandOnBus != scMaxTime)
-        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK);
 
     return earliestTimeToStart;
 }
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO.h b/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO.h
index 47326980..1ec31f8c 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO.h
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO.h
@@ -35,7 +35,6 @@
 #ifndef CHECKERWIDEIO_H
 #define CHECKERWIDEIO_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpecWideIO.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 
@@ -48,14 +47,14 @@ namespace DRAMSys
 class CheckerWideIO final : public CheckerIF
 {
 public:
-    explicit CheckerWideIO(const Configuration& config);
+    explicit CheckerWideIO(const MemSpecWideIO& memSpec);
     [[nodiscard]] sc_core::sc_time
     timeToSatisfyConstraints(Command command,
                              const tlm::tlm_generic_payload& payload) const override;
     void insert(Command command, const tlm::tlm_generic_payload& payload) override;
 
 private:
-    const MemSpecWideIO* memSpec;
+    const MemSpecWideIO& memSpec;
 
     std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
     std::vector<ControllerVector<Rank, sc_core::sc_time>> lastScheduledByCommandAndRank;
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO2.cpp b/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO2.cpp
index 60beea84..dc57bda8 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO2.cpp
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO2.cpp
@@ -44,32 +44,29 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-CheckerWideIO2::CheckerWideIO2(const Configuration& config) :
-    memSpec(dynamic_cast<const MemSpecWideIO2*>(config.memSpec.get()))
+CheckerWideIO2::CheckerWideIO2(const MemSpecWideIO2& memSpec) :
+    memSpec(memSpec)
 {
-    if (memSpec == nullptr)
-        SC_REPORT_FATAL("CheckerWideIO2", "Wrong MemSpec chosen");
-
     lastScheduledByCommandAndBank = std::vector<ControllerVector<Bank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Bank, sc_time>(memSpec->banksPerChannel, scMaxTime));
+        ControllerVector<Bank, sc_time>(memSpec.banksPerChannel, scMaxTime));
     lastScheduledByCommandAndRank = std::vector<ControllerVector<Rank, sc_time>>(
         Command::numberOfCommands(),
-        ControllerVector<Rank, sc_time>(memSpec->ranksPerChannel, scMaxTime));
+        ControllerVector<Rank, sc_time>(memSpec.ranksPerChannel, scMaxTime));
     lastScheduledByCommand = std::vector<sc_time>(Command::numberOfCommands(), scMaxTime);
     lastCommandOnBus = scMaxTime;
-    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec->ranksPerChannel);
+    last4Activates = ControllerVector<Rank, std::queue<sc_time>>(memSpec.ranksPerChannel);
 
-    tBURST = memSpec->defaultBurstLength / memSpec->dataRate * memSpec->tCK;
-    tRDPRE = tBURST + std::max(2 * memSpec->tCK, memSpec->tRTP) - 2 * memSpec->tCK;
-    tRDPDEN = memSpec->tRL + memSpec->tDQSCK + tBURST + memSpec->tCK;
-    tRDWR = memSpec->tRL + memSpec->tDQSCK + tBURST + memSpec->tCK - memSpec->tWL;
-    tRDWR_R = memSpec->tRL + memSpec->tDQSCK + tBURST + memSpec->tRTRS - memSpec->tWL;
-    tWRPRE = memSpec->tWL + memSpec->tCK + tBURST + memSpec->tWR;
-    tWRPDEN = memSpec->tWL + memSpec->tCK + tBURST + memSpec->tWR;
-    tWRAPDEN = memSpec->tWL + memSpec->tCK + tBURST + memSpec->tWR + memSpec->tCK;
-    tWRRD = memSpec->tWL + memSpec->tCK + tBURST + memSpec->tWTR;
-    tWRRD_R = memSpec->tWL + memSpec->tCK + tBURST + memSpec->tRTRS - memSpec->tRL;
+    tBURST = memSpec.defaultBurstLength / memSpec.dataRate * memSpec.tCK;
+    tRDPRE = tBURST + std::max(2 * memSpec.tCK, memSpec.tRTP) - 2 * memSpec.tCK;
+    tRDPDEN = memSpec.tRL + memSpec.tDQSCK + tBURST + memSpec.tCK;
+    tRDWR = memSpec.tRL + memSpec.tDQSCK + tBURST + memSpec.tCK - memSpec.tWL;
+    tRDWR_R = memSpec.tRL + memSpec.tDQSCK + tBURST + memSpec.tRTRS - memSpec.tWL;
+    tWRPRE = memSpec.tWL + memSpec.tCK + tBURST + memSpec.tWR;
+    tWRPDEN = memSpec.tWL + memSpec.tCK + tBURST + memSpec.tWR;
+    tWRAPDEN = memSpec.tWL + memSpec.tCK + tBURST + memSpec.tWR + memSpec.tCK;
+    tWRRD = memSpec.tWL + memSpec.tCK + tBURST + memSpec.tWTR;
+    tWRRD_R = memSpec.tWL + memSpec.tCK + tBURST + memSpec.tRTRS - memSpec.tRL;
 }
 
 sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command,
@@ -85,15 +82,15 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command,
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
         assert((burstLength == 4) || (burstLength == 8)); // TODO: BL4/8 OTF
-        assert(burstLength <= memSpec->maxBurstLength);
+        assert(burstLength <= memSpec.maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD);
 
         lastCommandStart =
             lastScheduledByCommand[Command::RD] != lastScheduledByCommandAndRank[Command::RD][rank]
@@ -101,11 +98,11 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD);
 
         lastCommandStart = lastScheduledByCommand[Command::RDA] !=
                                    lastScheduledByCommandAndRank[Command::RDA][rank]
@@ -113,7 +110,7 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         if (command == Command::RDA)
         {
@@ -147,18 +144,18 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::WR || command == Command::WRA || command == Command::MWR ||
              command == Command::MWRA)
     {
         unsigned burstLength = ControllerExtension::getBurstLength(payload);
         assert((burstLength == 4) || (burstLength == 8));
-        assert(burstLength <= memSpec->maxBurstLength);
+        assert(burstLength <= memSpec.maxBurstLength);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -184,7 +181,7 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WR][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD);
 
         lastCommandStart =
             lastScheduledByCommand[Command::WR] != lastScheduledByCommandAndRank[Command::WR][rank]
@@ -192,11 +189,11 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command,
                 : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCCD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCCD);
 
         lastCommandStart = lastScheduledByCommand[Command::WRA] !=
                                    lastScheduledByCommandAndRank[Command::WRA][rank]
@@ -204,73 +201,73 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command,
                                : scMaxTime;
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec->tRTRS);
+                std::max(earliestTimeToStart, lastCommandStart + tBURST + memSpec.tRTRS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::ACT)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec->tRPpb);
+                std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRPpb);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::REFPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
     }
     else if (command == Command::PREPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RD][bank];
         if (lastCommandStart != scMaxTime)
@@ -283,17 +280,17 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + 2 * memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + 2 * memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
     }
     else if (command == Command::PREAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRAS);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRAS);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RD][rank];
         if (lastCommandStart != scMaxTime)
@@ -314,107 +311,107 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command,
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + 2 * memSpec->tCK);
+                std::max(earliestTimeToStart, lastCommandStart + 2 * memSpec.tCK);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
     }
     else if (command == Command::REFAB)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec->tRPpb);
+                std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRPpb);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR);
     }
     else if (command == Command::REFPB)
     {
         lastCommandStart = lastScheduledByCommandAndBank[Command::ACT][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRRD);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRRD);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::RDA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec->tRPpb);
+                std::max(earliestTimeToStart, lastCommandStart + tRDPRE + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::WRA][bank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec->tRPpb);
+                std::max(earliestTimeToStart, lastCommandStart + tWRPRE + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndBank[Command::PREPB][bank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR);
 
         if (last4Activates[rank].size() >= 4)
             earliestTimeToStart =
-                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec->tFAW);
+                std::max(earliestTimeToStart, last4Activates[rank].front() + memSpec.tFAW);
     }
     else if (command == Command::PDEA)
     {
@@ -436,13 +433,13 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else if (command == Command::PDXA)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEA][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else if (command == Command::PDEP)
     {
@@ -460,71 +457,71 @@ sc_time CheckerWideIO2::timeToSatisfyConstraints(Command command,
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR);
     }
     else if (command == Command::PDXP)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDEP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKE);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKE);
     }
     else if (command == Command::SREFEN)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::ACT][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::RDA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart = std::max(
-                earliestTimeToStart, lastCommandStart + std::max(tRDPDEN, tRDPRE + memSpec->tRPpb));
+                earliestTimeToStart, lastCommandStart + std::max(tRDPDEN, tRDPRE + memSpec.tRPpb));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::WRA][rank];
         if (lastCommandStart != scMaxTime)
             earliestTimeToStart =
                 std::max(earliestTimeToStart,
-                         lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec->tRPpb));
+                         lastCommandStart + std::max(tWRAPDEN, tWRPRE + memSpec.tRPpb));
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PREAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRPab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRPab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::PDXP][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXP);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXP);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFAB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCab);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCab);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::REFPB][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tRFCpb);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tRFCpb);
 
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEX][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tXSR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tXSR);
     }
     else if (command == Command::SREFEX)
     {
         lastCommandStart = lastScheduledByCommandAndRank[Command::SREFEN][rank];
         if (lastCommandStart != scMaxTime)
-            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec->tCKESR);
+            earliestTimeToStart = std::max(earliestTimeToStart, lastCommandStart + memSpec.tCKESR);
     }
     else
         SC_REPORT_FATAL("CheckerWideIO2", "Unknown command!");
 
     // Check if command bus is free
     if (lastCommandOnBus != scMaxTime)
-        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec->tCK);
+        earliestTimeToStart = std::max(earliestTimeToStart, lastCommandOnBus + memSpec.tCK);
 
     return earliestTimeToStart;
 }
diff --git a/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO2.h b/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO2.h
index 31a4035c..ea2cced7 100644
--- a/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO2.h
+++ b/src/libdramsys/DRAMSys/controller/checker/CheckerWideIO2.h
@@ -35,7 +35,6 @@
 #ifndef CHECKERWIDEIO2_H
 #define CHECKERWIDEIO2_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpecWideIO2.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 
@@ -48,14 +47,14 @@ namespace DRAMSys
 class CheckerWideIO2 final : public CheckerIF
 {
 public:
-    explicit CheckerWideIO2(const Configuration& config);
+    explicit CheckerWideIO2(const MemSpecWideIO2& memSpec);
     [[nodiscard]] sc_core::sc_time
     timeToSatisfyConstraints(Command command,
                              const tlm::tlm_generic_payload& payload) const override;
     void insert(Command command, const tlm::tlm_generic_payload& payload) override;
 
 private:
-    const MemSpecWideIO2* memSpec;
+    const MemSpecWideIO2& memSpec;
 
     std::vector<ControllerVector<Bank, sc_core::sc_time>> lastScheduledByCommandAndBank;
     std::vector<ControllerVector<Rank, sc_core::sc_time>> lastScheduledByCommandAndRank;
diff --git a/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxOldest.cpp b/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxOldest.cpp
index 5a1540b7..e1672a36 100644
--- a/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxOldest.cpp
+++ b/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxOldest.cpp
@@ -41,7 +41,7 @@ using namespace sc_core;
 namespace DRAMSys
 {
 
-CmdMuxOldest::CmdMuxOldest(const Configuration& config) : memSpec(*config.memSpec)
+CmdMuxOldest::CmdMuxOldest(const MemSpec& memSpec) : memSpec(memSpec)
 {
 }
 
@@ -79,7 +79,7 @@ CommandTuple::Type CmdMuxOldest::selectCommand(const ReadyCommands& readyCommand
     return {Command::NOP, nullptr, scMaxTime};
 }
 
-CmdMuxOldestRasCas::CmdMuxOldestRasCas(const Configuration& config) : memSpec(*config.memSpec)
+CmdMuxOldestRasCas::CmdMuxOldestRasCas(const MemSpec& memSpec) : memSpec(memSpec)
 {
     readyRasCommands.reserve(memSpec.banksPerChannel);
     readyCasCommands.reserve(memSpec.banksPerChannel);
diff --git a/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxOldest.h b/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxOldest.h
index a83251c3..d08e5948 100644
--- a/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxOldest.h
+++ b/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxOldest.h
@@ -35,7 +35,7 @@
 #ifndef CMDMUXOLDEST_H
 #define CMDMUXOLDEST_H
 
-#include "DRAMSys/configuration/Configuration.h"
+#include "DRAMSys/configuration/memspec/MemSpec.h"
 #include "DRAMSys/controller/cmdmux/CmdMuxIF.h"
 
 namespace DRAMSys
@@ -44,7 +44,7 @@ namespace DRAMSys
 class CmdMuxOldest : public CmdMuxIF
 {
 public:
-    explicit CmdMuxOldest(const Configuration& config);
+    explicit CmdMuxOldest(const MemSpec& memSpec);
     CommandTuple::Type selectCommand(const ReadyCommands& readyCommands) override;
 
 private:
@@ -55,7 +55,7 @@ private:
 class CmdMuxOldestRasCas : public CmdMuxIF
 {
 public:
-    explicit CmdMuxOldestRasCas(const Configuration& config);
+    explicit CmdMuxOldestRasCas(const MemSpec& memSpec);
     CommandTuple::Type selectCommand(const ReadyCommands& readyCommands) override;
 
 private:
diff --git a/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxStrict.cpp b/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxStrict.cpp
index d4ae105a..f742d8e1 100644
--- a/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxStrict.cpp
+++ b/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxStrict.cpp
@@ -41,7 +41,7 @@ using namespace sc_core;
 namespace DRAMSys
 {
 
-CmdMuxStrict::CmdMuxStrict(const Configuration& config) : memSpec(*config.memSpec)
+CmdMuxStrict::CmdMuxStrict(const MemSpec& memSpec) : memSpec(memSpec)
 {
 }
 
@@ -91,7 +91,7 @@ CommandTuple::Type CmdMuxStrict::selectCommand(const ReadyCommands& readyCommand
     return {Command::NOP, nullptr, scMaxTime};
 }
 
-CmdMuxStrictRasCas::CmdMuxStrictRasCas(const Configuration& config) : memSpec(*config.memSpec)
+CmdMuxStrictRasCas::CmdMuxStrictRasCas(const MemSpec& memSpec) : memSpec(memSpec)
 {
     readyRasCommands.reserve(memSpec.banksPerChannel);
     readyCasCommands.reserve(memSpec.banksPerChannel);
diff --git a/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxStrict.h b/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxStrict.h
index b0572a3f..07c4173b 100644
--- a/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxStrict.h
+++ b/src/libdramsys/DRAMSys/controller/cmdmux/CmdMuxStrict.h
@@ -35,7 +35,7 @@
 #ifndef CMDMUXSTRICT_H
 #define CMDMUXSTRICT_H
 
-#include "DRAMSys/configuration/Configuration.h"
+#include "DRAMSys/configuration/memspec/MemSpec.h"
 #include "DRAMSys/controller/cmdmux/CmdMuxIF.h"
 
 namespace DRAMSys
@@ -44,7 +44,7 @@ namespace DRAMSys
 class CmdMuxStrict : public CmdMuxIF
 {
 public:
-    explicit CmdMuxStrict(const Configuration& config);
+    explicit CmdMuxStrict(const MemSpec& memSpec);
     CommandTuple::Type selectCommand(const ReadyCommands& readyCommands) override;
 
 private:
@@ -56,7 +56,7 @@ private:
 class CmdMuxStrictRasCas : public CmdMuxIF
 {
 public:
-    explicit CmdMuxStrictRasCas(const Configuration& config);
+    explicit CmdMuxStrictRasCas(const MemSpec& memSpec);
     CommandTuple::Type selectCommand(const ReadyCommands& readyCommands) override;
 
 private:
diff --git a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerAllBank.cpp b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerAllBank.cpp
index 4cb4fd25..67f4cafa 100644
--- a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerAllBank.cpp
+++ b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerAllBank.cpp
@@ -45,11 +45,12 @@ namespace DRAMSys
 {
 
 RefreshManagerAllBank::RefreshManagerAllBank(
-    const Configuration& config,
+    const McConfig& config,
+    const MemSpec& memSpec,
     ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
     PowerDownManagerIF& powerDownManager,
     Rank rank) :
-    memSpec(*config.memSpec),
+    memSpec(memSpec),
     bankMachinesOnRank(bankMachinesOnRank),
     powerDownManager(powerDownManager),
     maxPostponed(static_cast<int>(config.refreshMaxPostponed)),
diff --git a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerAllBank.h b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerAllBank.h
index ca79af6c..0e77588c 100644
--- a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerAllBank.h
+++ b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerAllBank.h
@@ -35,8 +35,8 @@
 #ifndef REFRESHMANAGERALLBANK_H
 #define REFRESHMANAGERALLBANK_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpec.h"
+#include "DRAMSys/controller/McConfig.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 #include "DRAMSys/controller/refresh/RefreshManagerIF.h"
 
@@ -53,7 +53,8 @@ class PowerDownManagerIF;
 class RefreshManagerAllBank final : public RefreshManagerIF
 {
 public:
-    RefreshManagerAllBank(const Configuration& config,
+    RefreshManagerAllBank(const McConfig& config,
+                          const MemSpec& memSpec,
                           ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
                           PowerDownManagerIF& powerDownManager,
                           Rank rank);
diff --git a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerIF.h b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerIF.h
index cd0f0e81..64283457 100644
--- a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerIF.h
+++ b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerIF.h
@@ -35,7 +35,7 @@
 #ifndef REFRESHMANAGERIF_H
 #define REFRESHMANAGERIF_H
 
-#include "DRAMSys/configuration/Configuration.h"
+#include "DRAMSys/common/dramExtensions.h"
 #include "DRAMSys/controller/Command.h"
 #include "DRAMSys/controller/ManagerIF.h"
 
diff --git a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPer2Bank.cpp b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPer2Bank.cpp
index bd37eb2a..b87619bf 100644
--- a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPer2Bank.cpp
+++ b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPer2Bank.cpp
@@ -44,11 +44,12 @@ namespace DRAMSys
 {
 
 RefreshManagerPer2Bank::RefreshManagerPer2Bank(
-    const Configuration& config,
+    const McConfig& config,
+    const MemSpec& memSpec,
     ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
     PowerDownManagerIF& powerDownManager,
     Rank rank) :
-    memSpec(*config.memSpec),
+    memSpec(memSpec),
     powerDownManager(powerDownManager),
     maxPostponed(static_cast<int>(config.refreshMaxPostponed * memSpec.banksPerRank / 2)),
     maxPulledin(-static_cast<int>(config.refreshMaxPulledin * memSpec.banksPerRank / 2))
diff --git a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPer2Bank.h b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPer2Bank.h
index 4a3c07a3..1a7ea9bd 100644
--- a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPer2Bank.h
+++ b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPer2Bank.h
@@ -35,8 +35,8 @@
 #ifndef REFRESHMANAGERPER2BANK_H
 #define REFRESHMANAGERPER2BANK_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpec.h"
+#include "DRAMSys/controller/McConfig.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 #include "DRAMSys/controller/refresh/RefreshManagerIF.h"
 
@@ -55,7 +55,8 @@ class PowerDownManagerIF;
 class RefreshManagerPer2Bank final : public RefreshManagerIF
 {
 public:
-    RefreshManagerPer2Bank(const Configuration& config,
+    RefreshManagerPer2Bank(const McConfig& config,
+                           const MemSpec& memSpec,
                            ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
                            PowerDownManagerIF& powerDownManager,
                            Rank rank);
diff --git a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPerBank.cpp b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPerBank.cpp
index 954bddcb..c15c2e48 100644
--- a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPerBank.cpp
+++ b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPerBank.cpp
@@ -44,11 +44,12 @@ namespace DRAMSys
 {
 
 RefreshManagerPerBank::RefreshManagerPerBank(
-    const Configuration& config,
+    const McConfig& config,
+    const MemSpec& memSpec,
     ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
     PowerDownManagerIF& powerDownManager,
     Rank rank) :
-    memSpec(*config.memSpec),
+    memSpec(memSpec),
     powerDownManager(powerDownManager),
     maxPostponed(static_cast<int>(config.refreshMaxPostponed * memSpec.banksPerRank)),
     maxPulledin(-static_cast<int>(config.refreshMaxPulledin * memSpec.banksPerRank))
diff --git a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPerBank.h b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPerBank.h
index 491829f5..758be44a 100644
--- a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPerBank.h
+++ b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerPerBank.h
@@ -35,9 +35,9 @@
 #ifndef REFRESHMANAGERPERBANK_H
 #define REFRESHMANAGERPERBANK_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpec.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
+#include "DRAMSys/controller/McConfig.h"
 #include "DRAMSys/controller/refresh/RefreshManagerIF.h"
 
 #include <list>
@@ -55,7 +55,8 @@ class PowerDownManagerIF;
 class RefreshManagerPerBank final : public RefreshManagerIF
 {
 public:
-    RefreshManagerPerBank(const Configuration& config,
+    RefreshManagerPerBank(const McConfig& config,
+                          const MemSpec& memSpec,
                           ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
                           PowerDownManagerIF& powerDownManager,
                           Rank rank);
diff --git a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerSameBank.cpp b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerSameBank.cpp
index 6b73ce5f..81f6b160 100644
--- a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerSameBank.cpp
+++ b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerSameBank.cpp
@@ -44,11 +44,12 @@ namespace DRAMSys
 {
 
 RefreshManagerSameBank::RefreshManagerSameBank(
-    const Configuration& config,
+    const McConfig& config,
+    const MemSpec& memSpec,
     ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
     PowerDownManagerIF& powerDownManager,
     Rank rank) :
-    memSpec(*config.memSpec),
+    memSpec(memSpec),
     powerDownManager(powerDownManager),
     maxPostponed(static_cast<int>(config.refreshMaxPostponed * memSpec.banksPerGroup)),
     maxPulledin(-static_cast<int>(config.refreshMaxPulledin * memSpec.banksPerGroup)),
diff --git a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerSameBank.h b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerSameBank.h
index 4f66bce7..c520a913 100644
--- a/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerSameBank.h
+++ b/src/libdramsys/DRAMSys/controller/refresh/RefreshManagerSameBank.h
@@ -35,8 +35,8 @@
 #ifndef REFRESHMANAGERSAMEBANK_H
 #define REFRESHMANAGERSAMEBANK_H
 
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpec.h"
+#include "DRAMSys/controller/McConfig.h"
 #include "DRAMSys/controller/checker/CheckerIF.h"
 #include "DRAMSys/controller/refresh/RefreshManagerIF.h"
 
@@ -54,7 +54,8 @@ class PowerDownManagerIF;
 class RefreshManagerSameBank final : public RefreshManagerIF
 {
 public:
-    RefreshManagerSameBank(const Configuration& config,
+    RefreshManagerSameBank(const McConfig& config,
+                           const MemSpec& memSpec,
                            ControllerVector<Bank, BankMachine*>& bankMachinesOnRank,
                            PowerDownManagerIF& powerDownManager,
                            Rank rank);
diff --git a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFifo.cpp b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFifo.cpp
index 0c3181c3..b118ee58 100644
--- a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFifo.cpp
+++ b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFifo.cpp
@@ -43,17 +43,17 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-SchedulerFifo::SchedulerFifo(const Configuration& config)
+SchedulerFifo::SchedulerFifo(const McConfig& config, const MemSpec& memSpec)
 {
-    buffer =
-        ControllerVector<Bank, std::deque<tlm_generic_payload*>>(config.memSpec->banksPerChannel);
+    buffer = ControllerVector<Bank, std::deque<tlm_generic_payload*>>(memSpec.banksPerChannel);
 
-    if (config.schedulerBuffer == Configuration::SchedulerBuffer::Bankwise)
+    if (config.schedulerBuffer == Config::SchedulerBufferType::Bankwise)
         bufferCounter = std::make_unique<BufferCounterBankwise>(config.requestBufferSize,
-                                                                config.memSpec->banksPerChannel);
-    else if (config.schedulerBuffer == Configuration::SchedulerBuffer::ReadWrite)
-        bufferCounter = std::make_unique<BufferCounterReadWrite>(config.requestBufferSizeRead, config.requestBufferSizeWrite);
-    else if (config.schedulerBuffer == Configuration::SchedulerBuffer::Shared)
+                                                                memSpec.banksPerChannel);
+    else if (config.schedulerBuffer == Config::SchedulerBufferType::ReadWrite)
+        bufferCounter = std::make_unique<BufferCounterReadWrite>(config.requestBufferSizeRead,
+                                                                 config.requestBufferSizeWrite);
+    else if (config.schedulerBuffer == Config::SchedulerBufferType::Shared)
         bufferCounter = std::make_unique<BufferCounterShared>(config.requestBufferSize);
 }
 
diff --git a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFifo.h b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFifo.h
index 8a2a6df3..4dbe87ff 100644
--- a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFifo.h
+++ b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFifo.h
@@ -39,6 +39,7 @@
 #include "DRAMSys/controller/BankMachine.h"
 #include "DRAMSys/controller/scheduler/BufferCounterIF.h"
 #include "DRAMSys/controller/scheduler/SchedulerIF.h"
+#include "DRAMSys/controller/McConfig.h"
 
 #include <deque>
 #include <memory>
@@ -51,7 +52,7 @@ namespace DRAMSys
 class SchedulerFifo final : public SchedulerIF
 {
 public:
-    explicit SchedulerFifo(const Configuration& config);
+    explicit SchedulerFifo(const McConfig& config, const MemSpec& memSpec);
     [[nodiscard]] bool hasBufferSpace() const override;
     void storeRequest(tlm::tlm_generic_payload& payload) override;
     void removeRequest(tlm::tlm_generic_payload& payload) override;
diff --git a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfs.cpp b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfs.cpp
index 267b9e8d..eda8a955 100644
--- a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfs.cpp
+++ b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfs.cpp
@@ -43,17 +43,17 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-SchedulerFrFcfs::SchedulerFrFcfs(const Configuration& config)
+SchedulerFrFcfs::SchedulerFrFcfs(const McConfig& config, const MemSpec& memSpec)
 {
-    buffer =
-        ControllerVector<Bank, std::list<tlm_generic_payload*>>(config.memSpec->banksPerChannel);
+    buffer = ControllerVector<Bank, std::list<tlm_generic_payload*>>(memSpec.banksPerChannel);
 
-    if (config.schedulerBuffer == Configuration::SchedulerBuffer::Bankwise)
+    if (config.schedulerBuffer == Config::SchedulerBufferType::Bankwise)
         bufferCounter = std::make_unique<BufferCounterBankwise>(config.requestBufferSize,
-                                                                config.memSpec->banksPerChannel);
-    else if (config.schedulerBuffer == Configuration::SchedulerBuffer::ReadWrite)
-        bufferCounter = std::make_unique<BufferCounterReadWrite>(config.requestBufferSizeRead, config.requestBufferSizeWrite);
-    else if (config.schedulerBuffer == Configuration::SchedulerBuffer::Shared)
+                                                                memSpec.banksPerChannel);
+    else if (config.schedulerBuffer == Config::SchedulerBufferType::ReadWrite)
+        bufferCounter = std::make_unique<BufferCounterReadWrite>(config.requestBufferSizeRead,
+                                                                 config.requestBufferSizeWrite);
+    else if (config.schedulerBuffer == Config::SchedulerBufferType::Shared)
         bufferCounter = std::make_unique<BufferCounterShared>(config.requestBufferSize);
 }
 
diff --git a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfs.h b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfs.h
index e3bdab83..21418adb 100644
--- a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfs.h
+++ b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfs.h
@@ -37,6 +37,7 @@
 
 #include "DRAMSys/common/dramExtensions.h"
 #include "DRAMSys/controller/BankMachine.h"
+#include "DRAMSys/controller/McConfig.h"
 #include "DRAMSys/controller/scheduler/BufferCounterIF.h"
 #include "DRAMSys/controller/scheduler/SchedulerIF.h"
 
@@ -51,7 +52,7 @@ namespace DRAMSys
 class SchedulerFrFcfs final : public SchedulerIF
 {
 public:
-    explicit SchedulerFrFcfs(const Configuration& config);
+    explicit SchedulerFrFcfs(const McConfig& config, const MemSpec& memSpec);
     [[nodiscard]] bool hasBufferSpace() const override;
     void storeRequest(tlm::tlm_generic_payload& payload) override;
     void removeRequest(tlm::tlm_generic_payload& payload) override;
diff --git a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfsGrp.cpp b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfsGrp.cpp
index 582e4e25..0f7e00fd 100644
--- a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfsGrp.cpp
+++ b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfsGrp.cpp
@@ -43,18 +43,17 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-SchedulerFrFcfsGrp::SchedulerFrFcfsGrp(const Configuration& config)
+SchedulerFrFcfsGrp::SchedulerFrFcfsGrp(const McConfig& config, const MemSpec& memSpec)
 {
-    buffer =
-        ControllerVector<Bank, std::list<tlm_generic_payload*>>(config.memSpec->banksPerChannel);
+    buffer = ControllerVector<Bank, std::list<tlm_generic_payload*>>(memSpec.banksPerChannel);
 
-    if (config.schedulerBuffer == Configuration::SchedulerBuffer::Bankwise)
+    if (config.schedulerBuffer == Config::SchedulerBufferType::Bankwise)
         bufferCounter = std::make_unique<BufferCounterBankwise>(config.requestBufferSize,
-                                                                config.memSpec->banksPerChannel);
-    else if (config.schedulerBuffer == Configuration::SchedulerBuffer::ReadWrite)
+                                                                memSpec.banksPerChannel);
+    else if (config.schedulerBuffer == Config::SchedulerBufferType::ReadWrite)
         bufferCounter = std::make_unique<BufferCounterReadWrite>(config.requestBufferSizeRead,
                                                                  config.requestBufferSizeWrite);
-    else if (config.schedulerBuffer == Configuration::SchedulerBuffer::Shared)
+    else if (config.schedulerBuffer == Config::SchedulerBufferType::Shared)
         bufferCounter = std::make_unique<BufferCounterShared>(config.requestBufferSize);
 }
 
diff --git a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfsGrp.h b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfsGrp.h
index f7bd73db..ac1e2ea9 100644
--- a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfsGrp.h
+++ b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerFrFcfsGrp.h
@@ -51,7 +51,7 @@ namespace DRAMSys
 class SchedulerFrFcfsGrp final : public SchedulerIF
 {
 public:
-    explicit SchedulerFrFcfsGrp(const Configuration& config);
+    explicit SchedulerFrFcfsGrp(const McConfig& config, const MemSpec& memSpec);
     [[nodiscard]] bool hasBufferSpace() const override;
     void storeRequest(tlm::tlm_generic_payload& payload) override;
     void removeRequest(tlm::tlm_generic_payload& payload) override;
diff --git a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfs.cpp b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfs.cpp
index 1f61b38a..e86eb072 100644
--- a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfs.cpp
+++ b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfs.cpp
@@ -43,20 +43,18 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-SchedulerGrpFrFcfs::SchedulerGrpFrFcfs(const Configuration& config)
+SchedulerGrpFrFcfs::SchedulerGrpFrFcfs(const McConfig& config, const MemSpec& memSpec)
 {
-    readBuffer =
-        ControllerVector<Bank, std::list<tlm_generic_payload*>>(config.memSpec->banksPerChannel);
-    writeBuffer =
-        ControllerVector<Bank, std::list<tlm_generic_payload*>>(config.memSpec->banksPerChannel);
+    readBuffer = ControllerVector<Bank, std::list<tlm_generic_payload*>>(memSpec.banksPerChannel);
+    writeBuffer = ControllerVector<Bank, std::list<tlm_generic_payload*>>(memSpec.banksPerChannel);
 
-    if (config.schedulerBuffer == Configuration::SchedulerBuffer::Bankwise)
+    if (config.schedulerBuffer == Config::SchedulerBufferType::Bankwise)
         bufferCounter = std::make_unique<BufferCounterBankwise>(config.requestBufferSize,
-                                                                config.memSpec->banksPerChannel);
-    else if (config.schedulerBuffer == Configuration::SchedulerBuffer::ReadWrite)
+                                                                memSpec.banksPerChannel);
+    else if (config.schedulerBuffer == Config::SchedulerBufferType::ReadWrite)
         bufferCounter = std::make_unique<BufferCounterReadWrite>(config.requestBufferSizeRead,
                                                                  config.requestBufferSizeWrite);
-    else if (config.schedulerBuffer == Configuration::SchedulerBuffer::Shared)
+    else if (config.schedulerBuffer == Config::SchedulerBufferType::Shared)
         bufferCounter = std::make_unique<BufferCounterShared>(config.requestBufferSize);
 
     SC_REPORT_WARNING("SchedulerGrpFrFcfs", "Hazard detection not yet implemented!");
diff --git a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfs.h b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfs.h
index bb28d2b9..fe955b58 100644
--- a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfs.h
+++ b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfs.h
@@ -51,7 +51,7 @@ namespace DRAMSys
 class SchedulerGrpFrFcfs final : public SchedulerIF
 {
 public:
-    explicit SchedulerGrpFrFcfs(const Configuration& config);
+    explicit SchedulerGrpFrFcfs(const McConfig& config, const MemSpec& memSpec);
     [[nodiscard]] bool hasBufferSpace() const override;
     void storeRequest(tlm::tlm_generic_payload& payload) override;
     void removeRequest(tlm::tlm_generic_payload& payload) override;
diff --git a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfsWm.cpp b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfsWm.cpp
index 7068c78e..0e9f5b7a 100644
--- a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfsWm.cpp
+++ b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfsWm.cpp
@@ -43,22 +43,22 @@ using namespace tlm;
 namespace DRAMSys
 {
 
-SchedulerGrpFrFcfsWm::SchedulerGrpFrFcfsWm(const Configuration& config) :
+SchedulerGrpFrFcfsWm::SchedulerGrpFrFcfsWm(const McConfig& config, const MemSpec& memSpec) :
     lowWatermark(config.lowWatermark),
     highWatermark(config.highWatermark)
 {
     readBuffer =
-        ControllerVector<Bank, std::list<tlm_generic_payload*>>(config.memSpec->banksPerChannel);
+        ControllerVector<Bank, std::list<tlm_generic_payload*>>(memSpec.banksPerChannel);
     writeBuffer =
-        ControllerVector<Bank, std::list<tlm_generic_payload*>>(config.memSpec->banksPerChannel);
+        ControllerVector<Bank, std::list<tlm_generic_payload*>>(memSpec.banksPerChannel);
 
-    if (config.schedulerBuffer == Configuration::SchedulerBuffer::Bankwise)
+    if (config.schedulerBuffer == Config::SchedulerBufferType::Bankwise)
         bufferCounter = std::make_unique<BufferCounterBankwise>(config.requestBufferSize,
-                                                                config.memSpec->banksPerChannel);
-    else if (config.schedulerBuffer == Configuration::SchedulerBuffer::ReadWrite)
+                                                                memSpec.banksPerChannel);
+    else if (config.schedulerBuffer == Config::SchedulerBufferType::ReadWrite)
         bufferCounter = std::make_unique<BufferCounterReadWrite>(config.requestBufferSizeRead,
                                                                  config.requestBufferSizeWrite);
-    else if (config.schedulerBuffer == Configuration::SchedulerBuffer::Shared)
+    else if (config.schedulerBuffer == Config::SchedulerBufferType::Shared)
         bufferCounter = std::make_unique<BufferCounterShared>(config.requestBufferSize);
 
     if (lowWatermark == 0 || lowWatermark >= highWatermark)
diff --git a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfsWm.h b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfsWm.h
index a9bfcba2..85ce52a3 100644
--- a/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfsWm.h
+++ b/src/libdramsys/DRAMSys/controller/scheduler/SchedulerGrpFrFcfsWm.h
@@ -36,7 +36,6 @@
 #define SCHEDULERGRPFRFCFSWM_H
 
 #include "DRAMSys/common/dramExtensions.h"
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/controller/BankMachine.h"
 #include "DRAMSys/controller/scheduler/BufferCounterIF.h"
 #include "DRAMSys/controller/scheduler/SchedulerIF.h"
@@ -52,7 +51,7 @@ namespace DRAMSys
 class SchedulerGrpFrFcfsWm final : public SchedulerIF
 {
 public:
-    explicit SchedulerGrpFrFcfsWm(const Configuration& config);
+    explicit SchedulerGrpFrFcfsWm(const McConfig& config, const MemSpec& memSpec);
     [[nodiscard]] bool hasBufferSpace() const override;
     void storeRequest(tlm::tlm_generic_payload& payload) override;
     void removeRequest(tlm::tlm_generic_payload& payload) override;
diff --git a/src/libdramsys/DRAMSys/simulation/AddressDecoder.cpp b/src/libdramsys/DRAMSys/simulation/AddressDecoder.cpp
index 62aa2c61..bff01a41 100644
--- a/src/libdramsys/DRAMSys/simulation/AddressDecoder.cpp
+++ b/src/libdramsys/DRAMSys/simulation/AddressDecoder.cpp
@@ -37,7 +37,6 @@
  */
 
 #include "AddressDecoder.h"
-#include "DRAMSys/configuration/Configuration.h"
 
 #include <bitset>
 #include <cmath>
@@ -71,7 +70,7 @@ static void addMapping(std::vector<Config::AddressMapping::BitEntry> const& mapp
     }
 }
 
-AddressDecoder::AddressDecoder(const DRAMSys::Config::AddressMapping& addressMapping)
+AddressDecoder::AddressDecoder(const Config::AddressMapping& addressMapping)
 {
     if (const auto& channelBits = addressMapping.CHANNEL_BIT)
     {
diff --git a/src/libdramsys/DRAMSys/simulation/AddressDecoder.h b/src/libdramsys/DRAMSys/simulation/AddressDecoder.h
index 053940da..540dfe92 100644
--- a/src/libdramsys/DRAMSys/simulation/AddressDecoder.h
+++ b/src/libdramsys/DRAMSys/simulation/AddressDecoder.h
@@ -40,7 +40,7 @@
 #define ADDRESSDECODER_H
 
 #include "DRAMSys/config/DRAMSysConfiguration.h"
-#include "DRAMSys/configuration/Configuration.h"
+#include "DRAMSys/configuration/memspec/MemSpec.h"
 
 #include <utility>
 #include <vector>
@@ -81,7 +81,7 @@ struct DecodedAddress
 class AddressDecoder
 {
 public:
-    AddressDecoder(const DRAMSys::Config::AddressMapping& addressMapping);
+    AddressDecoder(const Config::AddressMapping& addressMapping);
 
     [[nodiscard]] DecodedAddress decodeAddress(uint64_t encAddr) const;
     [[nodiscard]] unsigned decodeChannel(uint64_t encAddr) const;
diff --git a/src/libdramsys/DRAMSys/simulation/Arbiter.cpp b/src/libdramsys/DRAMSys/simulation/Arbiter.cpp
index a5349142..b81d1dd1 100644
--- a/src/libdramsys/DRAMSys/simulation/Arbiter.cpp
+++ b/src/libdramsys/DRAMSys/simulation/Arbiter.cpp
@@ -40,10 +40,8 @@
 #include "Arbiter.h"
 
 #include "DRAMSys/common/DebugManager.h"
-#include "DRAMSys/configuration/Configuration.h"
-#include "DRAMSys/simulation/AddressDecoder.h"
-
 #include "DRAMSys/config/DRAMSysConfiguration.h"
+#include "DRAMSys/simulation/AddressDecoder.h"
 
 using namespace sc_core;
 using namespace tlm;
@@ -52,16 +50,18 @@ namespace DRAMSys
 {
 
 Arbiter::Arbiter(const sc_module_name& name,
-                 const Configuration& config,
+                 const SimConfig& simConfig,
+                 const McConfig& mcConfig,
+                 const MemSpec& memSpec,
                  const AddressDecoder& addressDecoder) :
     sc_module(name),
     addressDecoder(addressDecoder),
     payloadEventQueue(this, &Arbiter::peqCallback),
-    tCK(config.memSpec->tCK),
-    arbitrationDelayFw(config.arbitrationDelayFw),
-    arbitrationDelayBw(config.arbitrationDelayBw),
-    bytesPerBeat(config.memSpec->dataBusWidth / 8),
-    addressOffset(config.addressOffset)
+    tCK(memSpec.tCK),
+    arbitrationDelayFw(mcConfig.arbitrationDelayFw),
+    arbitrationDelayBw(mcConfig.arbitrationDelayBw),
+    bytesPerBeat(memSpec.dataBusWidth / 8),
+    addressOffset(simConfig.addressOffset)
 {
     iSocket.register_nb_transport_bw(this, &Arbiter::nb_transport_bw);
     tSocket.register_nb_transport_fw(this, &Arbiter::nb_transport_fw);
@@ -70,25 +70,31 @@ Arbiter::Arbiter(const sc_module_name& name,
 }
 
 ArbiterSimple::ArbiterSimple(const sc_module_name& name,
-                             const Configuration& config,
+                             const SimConfig& simConfig,
+                             const McConfig& mcConfig,
+                             const MemSpec& memSpec,
                              const AddressDecoder& addressDecoder) :
-    Arbiter(name, config, addressDecoder)
+    Arbiter(name, simConfig, mcConfig, memSpec, addressDecoder)
 {
 }
 
 ArbiterFifo::ArbiterFifo(const sc_module_name& name,
-                         const Configuration& config,
+                         const SimConfig& simConfig,
+                         const McConfig& mcConfig,
+                         const MemSpec& memSpec,
                          const AddressDecoder& addressDecoder) :
-    Arbiter(name, config, addressDecoder),
-    maxActiveTransactionsPerThread(config.maxActiveTransactions)
+    Arbiter(name, simConfig, mcConfig, memSpec, addressDecoder),
+    maxActiveTransactionsPerThread(mcConfig.maxActiveTransactions)
 {
 }
 
 ArbiterReorder::ArbiterReorder(const sc_module_name& name,
-                               const Configuration& config,
+                               const SimConfig& simConfig,
+                               const McConfig& mcConfig,
+                               const MemSpec& memSpec,
                                const AddressDecoder& addressDecoder) :
-    Arbiter(name, config, addressDecoder),
-    maxActiveTransactions(config.maxActiveTransactions)
+    Arbiter(name, simConfig, mcConfig, memSpec, addressDecoder),
+    maxActiveTransactions(mcConfig.maxActiveTransactions)
 {
 }
 
diff --git a/src/libdramsys/DRAMSys/simulation/Arbiter.h b/src/libdramsys/DRAMSys/simulation/Arbiter.h
index d40a7056..80f5214a 100644
--- a/src/libdramsys/DRAMSys/simulation/Arbiter.h
+++ b/src/libdramsys/DRAMSys/simulation/Arbiter.h
@@ -41,7 +41,9 @@
 #define ARBITER_H
 
 #include "DRAMSys/common/dramExtensions.h"
+#include "DRAMSys/controller/McConfig.h"
 #include "DRAMSys/simulation/AddressDecoder.h"
+#include "DRAMSys/simulation/SimConfig.h"
 
 #include <iostream>
 #include <queue>
@@ -67,7 +69,9 @@ public:
 
 protected:
     Arbiter(const sc_core::sc_module_name& name,
-            const Configuration& config,
+            const SimConfig& simConfig,
+            const McConfig& mcConfig,
+            const MemSpec& memSpec,
             const AddressDecoder& addressDecoder);
     SC_HAS_PROCESS(Arbiter);
 
@@ -109,7 +113,9 @@ class ArbiterSimple final : public Arbiter
 {
 public:
     ArbiterSimple(const sc_core::sc_module_name& name,
-                  const Configuration& config,
+                  const SimConfig& simConfig,
+                  const McConfig& mcConfig,
+                  const MemSpec& memSpec,
                   const AddressDecoder& addressDecoder);
     SC_HAS_PROCESS(ArbiterSimple);
 
@@ -124,7 +130,9 @@ class ArbiterFifo final : public Arbiter
 {
 public:
     ArbiterFifo(const sc_core::sc_module_name& name,
-                const Configuration& config,
+                const SimConfig& simConfig,
+                const McConfig& mcConfig,
+                const MemSpec& memSpec,
                 const AddressDecoder& addressDecoder);
     SC_HAS_PROCESS(ArbiterFifo);
 
@@ -146,7 +154,9 @@ class ArbiterReorder final : public Arbiter
 {
 public:
     ArbiterReorder(const sc_core::sc_module_name& name,
-                   const Configuration& config,
+                   const SimConfig& simConfig,
+                   const McConfig& mcConfig,
+                   const MemSpec& memSpec,
                    const AddressDecoder& addressDecoder);
     SC_HAS_PROCESS(ArbiterReorder);
 
diff --git a/src/libdramsys/DRAMSys/simulation/DRAMSys.cpp b/src/libdramsys/DRAMSys/simulation/DRAMSys.cpp
index dec0463d..aa965a18 100644
--- a/src/libdramsys/DRAMSys/simulation/DRAMSys.cpp
+++ b/src/libdramsys/DRAMSys/simulation/DRAMSys.cpp
@@ -42,7 +42,27 @@
 
 #include "DRAMSys/common/DebugManager.h"
 #include "DRAMSys/common/utils.h"
-#include "DRAMSys/controller/Controller.h"
+
+#include "DRAMSys/configuration/memspec/MemSpecDDR3.h"
+#include "DRAMSys/configuration/memspec/MemSpecDDR4.h"
+#include "DRAMSys/configuration/memspec/MemSpecGDDR5.h"
+#include "DRAMSys/configuration/memspec/MemSpecGDDR5X.h"
+#include "DRAMSys/configuration/memspec/MemSpecGDDR6.h"
+#include "DRAMSys/configuration/memspec/MemSpecHBM2.h"
+#include "DRAMSys/configuration/memspec/MemSpecLPDDR4.h"
+#include "DRAMSys/configuration/memspec/MemSpecSTTMRAM.h"
+#include "DRAMSys/configuration/memspec/MemSpecWideIO.h"
+#include "DRAMSys/configuration/memspec/MemSpecWideIO2.h"
+
+#ifdef DDR5_SIM
+#include "DRAMSys/configuration/memspec/MemSpecDDR5.h"
+#endif
+#ifdef LPDDR5_SIM
+#include "DRAMSys/configuration/memspec/MemSpecLPDDR5.h"
+#endif
+#ifdef HBM3_SIM
+#include "DRAMSys/configuration/memspec/MemSpecHBM3.h"
+#endif
 
 #include <cstdlib>
 #include <iostream>
@@ -53,36 +73,117 @@
 namespace DRAMSys
 {
 
-DRAMSys::DRAMSys(const sc_core::sc_module_name& name,
-                 const ::DRAMSys::Config::Configuration& configLib) :
-    DRAMSys(name, configLib, true)
-{
-}
-
-DRAMSys::DRAMSys(const sc_core::sc_module_name& name,
-                 const ::DRAMSys::Config::Configuration& configLib,
-                 bool initAndBind) :
+DRAMSys::DRAMSys(const sc_core::sc_module_name& name, const Config::Configuration& config) :
     sc_module(name),
-    tSocket("DRAMSys_tSocket")
+    memSpec(createMemSpec(config.memspec)),
+    simConfig(config.simconfig),
+    mcConfig(config.mcconfig, *memSpec),
+    addressDecoder(std::make_unique<AddressDecoder>(config.addressmapping)),
+    arbiter(createArbiter(simConfig, mcConfig, *memSpec, *addressDecoder))
 {
     logo();
-
-    // Load configLib and initialize modules
-    // Important: The memSpec needs to be the first configuration to be loaded!
-    config.loadMemSpec(configLib.memspec);
-    config.loadMCConfig(configLib.mcconfig);
-    config.loadSimConfig(configLib.simconfig);
+    addressDecoder->plausibilityCheck(*memSpec);
+    addressDecoder->print();
 
     // Setup the debug manager:
-    setupDebugManager(config.simulationName);
+    setupDebugManager(simConfig.simulationName);
 
-    if (initAndBind)
+    // Instantiate all internal DRAMSys modules:
+    if (simConfig.databaseRecording)
     {
-        // Instantiate all internal DRAMSys modules:
-        instantiateModules(configLib.addressmapping);
-        // Connect all internal DRAMSys modules:
-        bindSockets();
-        report(headline);
+        std::string traceName = simConfig.simulationName;
+
+        if (!config.simulationid.empty())
+            traceName = config.simulationid + '_' + traceName;
+
+        // Create and properly initialize TLM recorders.
+        // They need to be ready before creating some modules.
+        setupTlmRecorders(traceName, config);
+
+        // Create controllers and DRAMs
+        for (std::size_t i = 0; i < memSpec->numberOfChannels; i++)
+        {
+            controllers.emplace_back(
+                std::make_unique<ControllerRecordable>(("controller" + std::to_string(i)).c_str(),
+                                                       mcConfig,
+                                                       simConfig,
+                                                       *memSpec,
+                                                       *addressDecoder,
+                                                       tlmRecorders[i]));
+
+            drams.emplace_back(std::make_unique<DramRecordable>(
+                ("dram" + std::to_string(i)).c_str(), simConfig, *memSpec, tlmRecorders[i]));
+
+            if (simConfig.checkTLM2Protocol)
+                controllersTlmCheckers.emplace_back(
+                    std::make_unique<tlm_utils::tlm2_base_protocol_checker<>>(
+                        ("TLMCheckerController" + std::to_string(i)).c_str()));
+        }
+    }
+    else
+    {
+        for (std::size_t i = 0; i < memSpec->numberOfChannels; i++)
+        {
+            controllers.emplace_back(std::make_unique<Controller>(
+                ("controller" + std::to_string(i)).c_str(), mcConfig, *memSpec, *addressDecoder));
+
+            drams.emplace_back(
+                std::make_unique<Dram>(("dram" + std::to_string(i)).c_str(), simConfig, *memSpec));
+
+            if (simConfig.checkTLM2Protocol)
+            {
+                controllersTlmCheckers.push_back(
+                    std::make_unique<tlm_utils::tlm2_base_protocol_checker<>>(
+                        ("TlmCheckerController" + std::to_string(i)).c_str()));
+            }
+        }
+    }
+
+    // Connect all internal DRAMSys modules:
+    tSocket.bind(arbiter->tSocket);
+    for (unsigned i = 0; i < memSpec->numberOfChannels; i++)
+    {
+        if (simConfig.checkTLM2Protocol)
+        {
+            arbiter->iSocket.bind(controllersTlmCheckers[i]->target_socket);
+            controllersTlmCheckers[i]->initiator_socket.bind(controllers[i]->tSocket);
+        }
+        else
+        {
+            arbiter->iSocket.bind(controllers[i]->tSocket);
+        }
+        controllers[i]->iSocket.bind(drams[i]->tSocket);
+    }
+
+    report();
+}
+
+void DRAMSys::setupTlmRecorders(const std::string& traceName, const Config::Configuration& config)
+{
+    // Create TLM Recorders, one per channel.
+    // Reserve is required because the recorders use double buffers that are accessed with pointers.
+    // Without a reserve, the vector reallocates storage before inserting a second
+    // element and the pointers are not valid anymore.
+    tlmRecorders.reserve(memSpec->numberOfChannels);
+    for (std::size_t i = 0; i < memSpec->numberOfChannels; i++)
+    {
+        std::string dbName =
+            std::string(name()) + "_" + traceName + "_ch" + std::to_string(i) + ".tdb";
+        std::string recorderName = "tlmRecorder" + std::to_string(i);
+
+        nlohmann::json mcconfig;
+        nlohmann::json memspec;
+        mcconfig[Config::McConfig::KEY] = config.mcconfig;
+        memspec[Config::MemSpec::KEY] = config.memspec;
+
+        tlmRecorders.emplace_back(recorderName,
+                                  simConfig,
+                                  mcConfig,
+                                  *memSpec,
+                                  dbName,
+                                  mcconfig.dump(),
+                                  memspec.dump(),
+                                  simConfig.simulationName);
     }
 }
 
@@ -101,18 +202,16 @@ void DRAMSys::registerIdleCallback(const std::function<void()>& idleCallback)
     }
 }
 
-const Configuration& DRAMSys::getConfig() const
-{
-    return config;
-}
-
 void DRAMSys::end_of_simulation()
 {
-    if (config.powerAnalysis)
+    if (simConfig.powerAnalysis)
     {
         for (auto& dram : drams)
             dram->reportPower();
     }
+
+    for (auto& tlmRecorder : tlmRecorders)
+        tlmRecorder.finalize();
 }
 
 void DRAMSys::logo()
@@ -140,7 +239,7 @@ void DRAMSys::setupDebugManager([[maybe_unused]] const std::string& traceName) c
 {
 #ifndef NDEBUG
     auto& dbg = DebugManager::getInstance();
-    bool debugEnabled = config.debug;
+    bool debugEnabled = simConfig.debug;
     bool writeToConsole = false;
     bool writeToFile = true;
     dbg.setup(debugEnabled, writeToConsole, writeToFile);
@@ -149,58 +248,84 @@ void DRAMSys::setupDebugManager([[maybe_unused]] const std::string& traceName) c
 #endif
 }
 
-void DRAMSys::instantiateModules(const ::DRAMSys::Config::AddressMapping& addressMapping)
+void DRAMSys::report()
 {
-    addressDecoder = std::make_unique<AddressDecoder>(addressMapping);
-    addressDecoder->plausibilityCheck(*config.memSpec);
-    addressDecoder->print();
-
-    // Create arbiter
-    if (config.arbiter == Configuration::Arbiter::Simple)
-        arbiter = std::make_unique<ArbiterSimple>("arbiter", config, *addressDecoder);
-    else if (config.arbiter == Configuration::Arbiter::Fifo)
-        arbiter = std::make_unique<ArbiterFifo>("arbiter", config, *addressDecoder);
-    else if (config.arbiter == Configuration::Arbiter::Reorder)
-        arbiter = std::make_unique<ArbiterReorder>("arbiter", config, *addressDecoder);
-
-    // Create controllers and DRAMs
-    for (std::size_t i = 0; i < config.memSpec->numberOfChannels; i++)
-    {
-        controllers.emplace_back(std::make_unique<Controller>(
-            ("controller" + std::to_string(i)).c_str(), config, *addressDecoder));
-
-        drams.emplace_back(std::make_unique<Dram>(("dram" + std::to_string(i)).c_str(), config));
-
-        if (config.checkTLM2Protocol)
-            controllersTlmCheckers.push_back(
-                std::make_unique<tlm_utils::tlm2_base_protocol_checker<>>(
-                    ("TlmCheckerController" + std::to_string(i)).c_str()));
-    }
+    PRINTDEBUGMESSAGE(name(), headline.data());
+    std::cout << headline << std::endl;
 }
 
-void DRAMSys::bindSockets()
+std::unique_ptr<const MemSpec> DRAMSys::createMemSpec(const Config::MemSpec& memSpec)
 {
-    tSocket.bind(arbiter->tSocket);
+    auto memoryType = memSpec.memoryType;
 
-    for (unsigned i = 0; i < config.memSpec->numberOfChannels; i++)
-    {
-        if (config.checkTLM2Protocol)
-        {
-            arbiter->iSocket.bind(controllersTlmCheckers[i]->target_socket);
-            controllersTlmCheckers[i]->initiator_socket.bind(controllers[i]->tSocket);
-        }
-        else
-        {
-            arbiter->iSocket.bind(controllers[i]->tSocket);
-        }
-        controllers[i]->iSocket.bind(drams[i]->tSocket);
-    }
+    if (memoryType == Config::MemoryType::DDR3)
+        return std::make_unique<const MemSpecDDR3>(memSpec);
+
+    if (memoryType == Config::MemoryType::DDR4)
+        return std::make_unique<const MemSpecDDR4>(memSpec);
+
+    if (memoryType == Config::MemoryType::LPDDR4)
+        return std::make_unique<const MemSpecLPDDR4>(memSpec);
+
+    if (memoryType == Config::MemoryType::WideIO)
+        return std::make_unique<const MemSpecWideIO>(memSpec);
+
+    if (memoryType == Config::MemoryType::WideIO2)
+        return std::make_unique<const MemSpecWideIO2>(memSpec);
+
+    if (memoryType == Config::MemoryType::HBM2)
+        return std::make_unique<const MemSpecHBM2>(memSpec);
+
+    if (memoryType == Config::MemoryType::GDDR5)
+        return std::make_unique<const MemSpecGDDR5>(memSpec);
+
+    if (memoryType == Config::MemoryType::GDDR5X)
+        return std::make_unique<const MemSpecGDDR5X>(memSpec);
+
+    if (memoryType == Config::MemoryType::GDDR6)
+        return std::make_unique<const MemSpecGDDR6>(memSpec);
+
+    if (memoryType == Config::MemoryType::STTMRAM)
+        return std::make_unique<const MemSpecSTTMRAM>(memSpec);
+
+#ifdef DDR5_SIM
+    if (memoryType == Config::MemoryType::DDR5)
+        return std::make_unique<const MemSpecDDR5>(memSpec);
+#endif
+
+#ifdef LPDDR5_SIM
+    if (memoryType == Config::MemoryType::LPDDR5)
+        return std::make_unique<const MemSpecLPDDR5>(memSpec);
+#endif
+
+#ifdef HBM3_SIM
+    if (memoryType == Config::MemoryType::HBM3)
+        return std::make_unique<const MemSpecHBM3>(memSpec);
+#endif
+
+    SC_REPORT_FATAL("Configuration", "Unsupported DRAM type");
+    return {};
 }
 
-void DRAMSys::report(std::string_view message)
+std::unique_ptr<Arbiter> DRAMSys::createArbiter(const SimConfig& simConfig,
+                                                const McConfig& mcConfig,
+                                                const MemSpec& memSpec,
+                                                const AddressDecoder& addressDecoder)
 {
-    PRINTDEBUGMESSAGE(name(), message.data());
-    std::cout << message << std::endl;
+    if (mcConfig.arbiter == Config::ArbiterType::Simple)
+        return std::make_unique<ArbiterSimple>(
+            "arbiter", simConfig, mcConfig, memSpec, addressDecoder);
+
+    if (mcConfig.arbiter == Config::ArbiterType::Fifo)
+        return std::make_unique<ArbiterFifo>(
+            "arbiter", simConfig, mcConfig, memSpec, addressDecoder);
+
+    if (mcConfig.arbiter == Config::ArbiterType::Reorder)
+        return std::make_unique<ArbiterReorder>(
+            "arbiter", simConfig, mcConfig, memSpec, addressDecoder);
+
+    SC_REPORT_FATAL("DRAMSys", "Invalid Arbiter");
+    return {};
 }
 
 } // namespace DRAMSys
diff --git a/src/libdramsys/DRAMSys/simulation/DRAMSys.h b/src/libdramsys/DRAMSys/simulation/DRAMSys.h
index 3202b88b..00c492ae 100644
--- a/src/libdramsys/DRAMSys/simulation/DRAMSys.h
+++ b/src/libdramsys/DRAMSys/simulation/DRAMSys.h
@@ -41,14 +41,17 @@
 #ifndef DRAMSYS_H
 #define DRAMSYS_H
 
-#include "DRAMSys/common/Serialize.h"
+#include "DRAMSys/common/TlmRecorder.h"
 #include "DRAMSys/common/tlm2_base_protocol_checker.h"
 #include "DRAMSys/config/DRAMSysConfiguration.h"
 #include "DRAMSys/controller/Controller.h"
+#include "DRAMSys/controller/ControllerRecordable.h"
+#include "DRAMSys/controller/McConfig.h"
 #include "DRAMSys/simulation/AddressDecoder.h"
 #include "DRAMSys/simulation/Arbiter.h"
-#include "DRAMSys/simulation/ReorderBuffer.h"
-#include "DRAMSys/simulation/dram/Dram.h"
+#include "DRAMSys/simulation/Dram.h"
+#include "DRAMSys/simulation/DramRecordable.h"
+#include "DRAMSys/simulation/SimConfig.h"
 
 #include <list>
 #include <memory>
@@ -64,13 +67,15 @@ namespace DRAMSys
 class DRAMSys : public sc_core::sc_module
 {
 public:
-    tlm_utils::multi_passthrough_target_socket<DRAMSys> tSocket;
+    tlm_utils::multi_passthrough_target_socket<DRAMSys> tSocket{"DRAMSys_tSocket"};
 
     SC_HAS_PROCESS(DRAMSys);
-    DRAMSys(const sc_core::sc_module_name& name, const ::DRAMSys::Config::Configuration& configLib);
+    DRAMSys(const sc_core::sc_module_name& name, const Config::Configuration& config);
 
-    const Configuration& getConfig() const;
-    const AddressDecoder& getAddressDecoder() const { return *addressDecoder; }
+    const auto& getSimConfig() const { return simConfig; }
+    const auto& getMcConfig() const { return mcConfig; }
+    const auto& getMemSpec() const { return *memSpec; }
+    const auto& getAddressDecoder() const { return *addressDecoder; }
 
     /**
      * Returns true if all memory controllers are in idle state.
@@ -83,21 +88,30 @@ public:
      */
     void registerIdleCallback(const std::function<void()>& idleCallback);
 
-protected:
-    DRAMSys(const sc_core::sc_module_name& name,
-            const ::DRAMSys::Config::Configuration& configLib,
-            bool initAndBind);
+private:
+    static void logo();
+    static std::unique_ptr<const MemSpec> createMemSpec(const Config::MemSpec& memSpec);
+    static std::unique_ptr<Arbiter> createArbiter(const SimConfig& simConfig,
+                                                  const McConfig& mcConfig,
+                                                  const MemSpec& memSpec,
+                                                  const AddressDecoder& addressDecoder);
 
     void end_of_simulation() override;
 
-    Configuration config;
+    void setupDebugManager(const std::string& traceName) const;
+    void setupTlmRecorders(const std::string& traceName, const Config::Configuration& configLib);
+
+    void report();
+
+    std::unique_ptr<const MemSpec> memSpec;
+    SimConfig simConfig;
+    McConfig mcConfig;
+
+    std::unique_ptr<AddressDecoder> addressDecoder;
 
     // TLM 2.0 Protocol Checkers
     std::vector<std::unique_ptr<tlm_utils::tlm2_base_protocol_checker<>>> controllersTlmCheckers;
 
-    // TODO: Each DRAM has a reorder buffer (check this!)
-    std::unique_ptr<ReorderBuffer> reorder;
-
     // All transactions pass through the same arbiter
     std::unique_ptr<Arbiter> arbiter;
 
@@ -107,15 +121,9 @@ protected:
     // DRAM units
     std::vector<std::unique_ptr<Dram>> drams;
 
-    std::unique_ptr<AddressDecoder> addressDecoder;
-
-    void report(std::string_view message);
-    void bindSockets();
-
-private:
-    static void logo();
-    void instantiateModules(const ::DRAMSys::Config::AddressMapping& addressMapping);
-    void setupDebugManager(const std::string& traceName) const;
+    // Transaction Recorders (one per channel).
+    // They generate the output databases.
+    std::vector<TlmRecorder> tlmRecorders;
 };
 
 } // namespace DRAMSys
diff --git a/src/libdramsys/DRAMSys/simulation/DRAMSysRecordable.cpp b/src/libdramsys/DRAMSys/simulation/DRAMSysRecordable.cpp
deleted file mode 100644
index 5c4159df..00000000
--- a/src/libdramsys/DRAMSys/simulation/DRAMSysRecordable.cpp
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright (c) 2020, 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.
- *
- * Authors:
- *    Lukas Steiner
- *    Derek Christ
- */
-
-#include "DRAMSysRecordable.h"
-
-#include "DRAMSys/common/TlmRecorder.h"
-#include "DRAMSys/controller/ControllerRecordable.h"
-#include "DRAMSys/simulation/dram/DramRecordable.h"
-
-#include <memory>
-
-namespace DRAMSys
-{
-
-DRAMSysRecordable::DRAMSysRecordable(const sc_core::sc_module_name& name,
-                                     const ::DRAMSys::Config::Configuration& configLib) :
-    DRAMSys(name, configLib, false)
-{
-    // If a simulation file is passed as argument to DRAMSys the simulation ID
-    // is prepended to the simulation name if found.
-    std::string traceName;
-
-    if (!configLib.simulationid.empty())
-    {
-        std::string sid = configLib.simulationid;
-        traceName = sid + '_' + config.simulationName;
-    }
-    else
-        traceName = config.simulationName;
-
-    instantiateModules(traceName, configLib);
-    bindSockets();
-    report(headline);
-}
-
-void DRAMSysRecordable::end_of_simulation()
-{
-    // Report power before TLM recorders are finalized
-    if (config.powerAnalysis)
-    {
-        for (auto& dram : drams)
-            dram->reportPower();
-    }
-
-    for (auto& tlmRecorder : tlmRecorders)
-        tlmRecorder.finalize();
-}
-
-void DRAMSysRecordable::setupTlmRecorders(const std::string& traceName,
-                                          const ::DRAMSys::Config::Configuration& configLib)
-{
-    // Create TLM Recorders, one per channel.
-    // Reserve is required because the recorders use double buffers that are accessed with pointers.
-    // Without a reserve, the vector reallocates storage before inserting a second
-    // element and the pointers are not valid anymore.
-    tlmRecorders.reserve(config.memSpec->numberOfChannels);
-    for (std::size_t i = 0; i < config.memSpec->numberOfChannels; i++)
-    {
-        std::string dbName =
-            std::string(name()) + "_" + traceName + "_ch" + std::to_string(i) + ".tdb";
-        std::string recorderName = "tlmRecorder" + std::to_string(i);
-
-        nlohmann::json mcconfig;
-        nlohmann::json memspec;
-        mcconfig[Config::McConfig::KEY] = configLib.mcconfig;
-        memspec[Config::MemSpec::KEY] = configLib.memspec;
-
-        tlmRecorders.emplace_back(
-            recorderName, config, dbName, mcconfig.dump(), memspec.dump(), config.simulationName);
-    }
-}
-
-void DRAMSysRecordable::instantiateModules(const std::string& traceName,
-                                           const ::DRAMSys::Config::Configuration& configLib)
-{
-    addressDecoder = std::make_unique<AddressDecoder>(configLib.addressmapping);
-    addressDecoder->plausibilityCheck(*config.memSpec);
-    addressDecoder->print();
-
-    // Create and properly initialize TLM recorders.
-    // They need to be ready before creating some modules.
-    setupTlmRecorders(traceName, configLib);
-
-    // Create arbiter
-    if (config.arbiter == Configuration::Arbiter::Simple)
-        arbiter = std::make_unique<ArbiterSimple>("arbiter", config, *addressDecoder);
-    else if (config.arbiter == Configuration::Arbiter::Fifo)
-        arbiter = std::make_unique<ArbiterFifo>("arbiter", config, *addressDecoder);
-    else if (config.arbiter == Configuration::Arbiter::Reorder)
-        arbiter = std::make_unique<ArbiterReorder>("arbiter", config, *addressDecoder);
-
-    // Create controllers and DRAMs
-    for (std::size_t i = 0; i < config.memSpec->numberOfChannels; i++)
-    {
-        controllers.emplace_back(std::make_unique<ControllerRecordable>(
-            ("controller" + std::to_string(i)).c_str(), config, *addressDecoder, tlmRecorders[i]));
-
-        drams.emplace_back(std::make_unique<DramRecordable>(
-            ("dram" + std::to_string(i)).c_str(), config, tlmRecorders[i]));
-
-        if (config.checkTLM2Protocol)
-            controllersTlmCheckers.emplace_back(
-                std::make_unique<tlm_utils::tlm2_base_protocol_checker<>>(
-                    ("TLMCheckerController" + std::to_string(i)).c_str()));
-    }
-}
-
-} // namespace DRAMSys
diff --git a/src/libdramsys/DRAMSys/simulation/dram/Dram.cpp b/src/libdramsys/DRAMSys/simulation/Dram.cpp
similarity index 92%
rename from src/libdramsys/DRAMSys/simulation/dram/Dram.cpp
rename to src/libdramsys/DRAMSys/simulation/Dram.cpp
index a7301c18..6f767fe4 100644
--- a/src/libdramsys/DRAMSys/simulation/dram/Dram.cpp
+++ b/src/libdramsys/DRAMSys/simulation/Dram.cpp
@@ -41,6 +41,7 @@
 #include "Dram.h"
 
 #include "DRAMSys/common/DebugManager.h"
+#include "DRAMSys/config/SimConfig.h"
 
 #ifdef DRAMPOWER
 #include "LibDRAMPower.h"
@@ -66,16 +67,15 @@ using namespace DRAMPower;
 namespace DRAMSys
 {
 
-Dram::Dram(const sc_module_name& name, const Configuration& config) :
+Dram::Dram(const sc_module_name& name, const SimConfig& simConfig, const MemSpec& memSpec) :
     sc_module(name),
-    memSpec(*config.memSpec),
-    storeMode(config.storeMode),
-    powerAnalysis(config.powerAnalysis),
+    memSpec(memSpec),
+    storeMode(simConfig.storeMode),
+    powerAnalysis(simConfig.powerAnalysis),
     channelSize(memSpec.getSimMemSizeInBytes() / memSpec.numberOfChannels),
-    useMalloc(config.useMalloc),
-    tSocket("socket")
+    useMalloc(simConfig.useMalloc)
 {
-    if (storeMode == Configuration::StoreMode::Store)
+    if (storeMode == Config::StoreModeType::Store)
     {
         if (useMalloc)
         {
@@ -107,7 +107,6 @@ Dram::Dram(const sc_module_name& name, const Configuration& config) :
 #ifdef DRAMPOWER
     if (powerAnalysis)
     {
-        const auto& memSpec = *config.memSpec;
         DRAMPower = std::make_unique<libDRAMPower>(memSpec.toDramPowerMemSpec(), false);
     }
 #endif
@@ -149,7 +148,7 @@ tlm_sync_enum Dram::nb_transport_fw(tlm_generic_payload& trans, tlm_phase& phase
     }
 #endif
 
-    if (storeMode == Configuration::StoreMode::Store)
+    if (storeMode == Config::StoreModeType::Store)
     {
         if (phase == BEGIN_RD || phase == BEGIN_RDA)
         {
@@ -170,11 +169,11 @@ unsigned int Dram::transport_dbg(tlm_generic_payload& trans)
     PRINTDEBUGMESSAGE(name(), "transport_dgb");
 
     // TODO: This part is not tested yet, neither with traceplayers nor with GEM5 coupling
-    if (storeMode == Configuration::StoreMode::NoStorage)
+    if (storeMode == Config::StoreModeType::NoStorage)
     {
         SC_REPORT_FATAL("DRAM", "Debug Transport is used in combination with NoStorage");
     }
-    else if (storeMode == Configuration::StoreMode::Store)
+    else if (storeMode == Config::StoreModeType::Store)
     {
         if (trans.is_read())
         {
@@ -184,7 +183,7 @@ unsigned int Dram::transport_dbg(tlm_generic_payload& trans)
         {
             executeWrite(trans);
         }
-        
+
         return trans.get_data_length();
     }
 
@@ -201,7 +200,7 @@ void Dram::b_transport(tlm_generic_payload& trans, [[maybe_unused]] sc_time& del
         printedWarning = true;
     }
 
-    if (storeMode == Configuration::StoreMode::Store)
+    if (storeMode == Config::StoreModeType::Store)
     {
         if (trans.is_read())
         {
diff --git a/src/libdramsys/DRAMSys/simulation/dram/Dram.h b/src/libdramsys/DRAMSys/simulation/Dram.h
similarity index 93%
rename from src/libdramsys/DRAMSys/simulation/dram/Dram.h
rename to src/libdramsys/DRAMSys/simulation/Dram.h
index b8277baa..d8c7125a 100644
--- a/src/libdramsys/DRAMSys/simulation/dram/Dram.h
+++ b/src/libdramsys/DRAMSys/simulation/Dram.h
@@ -43,8 +43,8 @@
 
 #include "DRAMSys/common/Deserialize.h"
 #include "DRAMSys/common/Serialize.h"
-#include "DRAMSys/configuration/Configuration.h"
 #include "DRAMSys/configuration/memspec/MemSpec.h"
+#include "DRAMSys/simulation/SimConfig.h"
 
 #include <memory>
 #include <systemc>
@@ -62,7 +62,7 @@ protected:
     const MemSpec& memSpec;
 
     // Data Storage:
-    const Configuration::StoreMode storeMode;
+    const Config::StoreModeType storeMode;
     const bool powerAnalysis;
     unsigned char* memory;
     const uint64_t channelSize;
@@ -82,7 +82,7 @@ protected:
     void executeWrite(const tlm::tlm_generic_payload& trans);
 
 public:
-    Dram(const sc_core::sc_module_name& name, const Configuration& config);
+    Dram(const sc_core::sc_module_name& name, const SimConfig& simConfig, const MemSpec& memSpec);
     SC_HAS_PROCESS(Dram);
 
     Dram(const Dram&) = delete;
@@ -95,7 +95,7 @@ public:
         "Use the blocking mode of DRAMSys with caution! "
         "The simulated timings do not reflect the real system!";
 
-    tlm_utils::simple_target_socket<Dram> tSocket;
+    tlm_utils::simple_target_socket<Dram> tSocket{"tSocket"};
 
     virtual void reportPower();
 
diff --git a/src/libdramsys/DRAMSys/simulation/dram/DramRecordable.cpp b/src/libdramsys/DRAMSys/simulation/DramRecordable.cpp
similarity index 91%
rename from src/libdramsys/DRAMSys/simulation/dram/DramRecordable.cpp
rename to src/libdramsys/DRAMSys/simulation/DramRecordable.cpp
index a4e2925a..6723e4cc 100644
--- a/src/libdramsys/DRAMSys/simulation/dram/DramRecordable.cpp
+++ b/src/libdramsys/DRAMSys/simulation/DramRecordable.cpp
@@ -46,16 +46,17 @@ namespace DRAMSys
 {
 
 DramRecordable::DramRecordable(const sc_module_name& name,
-                               const Configuration& config,
+                               const SimConfig& simConfig,
+                               const MemSpec& memSpec,
                                TlmRecorder& tlmRecorder) :
-    Dram(name, config),
+    Dram(name, simConfig, memSpec),
     tlmRecorder(tlmRecorder),
-    powerWindowSize(config.memSpec->tCK * config.windowSize)
+    powerWindowSize(memSpec.tCK * simConfig.windowSize)
 {
 #ifdef DRAMPOWER
     // Create a thread that is triggered every $powerWindowSize
     // to generate a Power over Time plot in the Trace analyzer:
-    if (config.powerAnalysis && config.enableWindowing)
+    if (simConfig.powerAnalysis && simConfig.enableWindowing)
         SC_THREAD(powerWindow);
 #endif
 }
@@ -70,9 +71,8 @@ void DramRecordable::reportPower()
 #endif
 }
 
-tlm_sync_enum DramRecordable::nb_transport_fw(tlm_generic_payload& trans,
-                                                        tlm_phase& phase,
-                                                        sc_time& delay)
+tlm_sync_enum
+DramRecordable::nb_transport_fw(tlm_generic_payload& trans, tlm_phase& phase, sc_time& delay)
 {
     tlmRecorder.recordPhase(trans, phase, delay);
     return Dram::nb_transport_fw(trans, phase, delay);
diff --git a/src/libdramsys/DRAMSys/simulation/dram/DramRecordable.h b/src/libdramsys/DRAMSys/simulation/DramRecordable.h
similarity index 94%
rename from src/libdramsys/DRAMSys/simulation/dram/DramRecordable.h
rename to src/libdramsys/DRAMSys/simulation/DramRecordable.h
index bbb7c277..5c332a80 100644
--- a/src/libdramsys/DRAMSys/simulation/dram/DramRecordable.h
+++ b/src/libdramsys/DRAMSys/simulation/DramRecordable.h
@@ -37,7 +37,6 @@
 #define DRAMRECORDABLE_H
 
 #include "DRAMSys/common/TlmRecorder.h"
-#include "DRAMSys/configuration/Configuration.h"
 #include "Dram.h"
 
 #ifdef DRAMPOWER
@@ -54,7 +53,8 @@ class DramRecordable : public Dram
 {
 public:
     DramRecordable(const sc_core::sc_module_name& name,
-                   const Configuration& config,
+                   const SimConfig& simConfig,
+                   const MemSpec& memSpec,
                    TlmRecorder& tlmRecorder);
     SC_HAS_PROCESS(DramRecordable);
 
@@ -72,7 +72,7 @@ private:
     // When working with floats, we have to decide ourselves what is an
     // acceptable definition for "equal". Here the number is compared with a
     // suitable error margin (0.00001).
-    bool isEqual(double a, double b, const double epsilon = 1e-05)
+    static bool isEqual(double a, double b, const double epsilon = 1e-05)
     {
         return std::fabs(a - b) < epsilon;
     }
diff --git a/src/libdramsys/DRAMSys/simulation/ReorderBuffer.h b/src/libdramsys/DRAMSys/simulation/ReorderBuffer.h
deleted file mode 100644
index 82bd0a5e..00000000
--- a/src/libdramsys/DRAMSys/simulation/ReorderBuffer.h
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
- * Copyright (c) 2015, 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.
- *
- * Authors:
- *    Janik Schlemminger
- *    Robert Gernhardt
- *    Matthias Jung
- */
-
-#ifndef REORDERBUFFER_H
-#define REORDERBUFFER_H
-
-#include <deque>
-#include <set>
-#include <systemc>
-#include <tlm>
-#include <tlm_utils/peq_with_cb_and_phase.h>
-#include <tlm_utils/simple_initiator_socket.h>
-#include <tlm_utils/simple_target_socket.h>
-
-namespace DRAMSys
-{
-
-struct ReorderBuffer : public sc_core::sc_module
-{
-public:
-    tlm_utils::simple_initiator_socket<ReorderBuffer> iSocket;
-    tlm_utils::simple_target_socket<ReorderBuffer> tSocket;
-
-    SC_CTOR(ReorderBuffer) : payloadEventQueue(this, &ReorderBuffer::peqCallback)
-    {
-        iSocket.register_nb_transport_bw(this, &ReorderBuffer::nb_transport_bw);
-        tSocket.register_nb_transport_fw(this, &ReorderBuffer::nb_transport_fw);
-    }
-
-private:
-    tlm_utils::peq_with_cb_and_phase<ReorderBuffer> payloadEventQueue;
-    std::deque<tlm::tlm_generic_payload*> pendingRequestsInOrder;
-    std::set<tlm::tlm_generic_payload*> receivedResponses;
-
-    bool responseIsPendingInInitator = false;
-
-    // Initiated by dram side
-    tlm::tlm_sync_enum nb_transport_bw(tlm::tlm_generic_payload& trans,
-                                       tlm::tlm_phase& phase,
-                                       sc_core::sc_time& bwDelay)
-    {
-        payloadEventQueue.notify(trans, phase, bwDelay);
-        return tlm::TLM_ACCEPTED;
-    }
-
-    // Initiated by initator side (players)
-    tlm::tlm_sync_enum nb_transport_fw(tlm::tlm_generic_payload& trans,
-                                       tlm::tlm_phase& phase,
-                                       sc_core::sc_time& fwDelay)
-    {
-        if (phase == tlm::BEGIN_REQ)
-        {
-            trans.acquire();
-        }
-        else if (phase == tlm::END_RESP)
-        {
-            trans.release();
-        }
-
-        payloadEventQueue.notify(trans, phase, fwDelay);
-        return tlm::TLM_ACCEPTED;
-    }
-
-    void peqCallback(tlm::tlm_generic_payload& trans, const tlm::tlm_phase& phase)
-    {
-        // Phases initiated by initiator side
-        if (phase == tlm::BEGIN_REQ)
-        {
-            pendingRequestsInOrder.push_back(&trans);
-            sendToTarget(trans, phase, sc_core::SC_ZERO_TIME);
-        }
-
-        else if (phase == tlm::END_RESP)
-        {
-            responseIsPendingInInitator = false;
-            pendingRequestsInOrder.pop_front();
-            receivedResponses.erase(&trans);
-            sendNextResponse();
-        }
-
-        // Phases initiated by dram side
-        else if (phase == tlm::END_REQ)
-        {
-            sendToInitiator(trans, phase, sc_core::SC_ZERO_TIME);
-        }
-        else if (phase == tlm::BEGIN_RESP)
-        {
-            sendToTarget(trans, tlm::END_RESP, sc_core::SC_ZERO_TIME);
-            receivedResponses.emplace(&trans);
-            sendNextResponse();
-        }
-
-        else
-        {
-            SC_REPORT_FATAL(0, "Payload event queue in arbiter was triggered with unknown phase");
-        }
-    }
-
-    void sendToTarget(tlm::tlm_generic_payload& trans,
-                      const tlm::tlm_phase& phase,
-                      const sc_core::sc_time& delay)
-    {
-        tlm::tlm_phase TPhase = phase;
-        sc_core::sc_time TDelay = delay;
-        iSocket->nb_transport_fw(trans, TPhase, TDelay);
-    }
-
-    void sendToInitiator(tlm::tlm_generic_payload& trans,
-                         const tlm::tlm_phase& phase,
-                         const sc_core::sc_time& delay)
-    {
-
-        sc_assert(phase == tlm::END_REQ ||
-                  (phase == tlm::BEGIN_RESP && pendingRequestsInOrder.front() == &trans &&
-                   receivedResponses.count(&trans)));
-
-        tlm::tlm_phase TPhase = phase;
-        sc_core::sc_time TDelay = delay;
-        tSocket->nb_transport_bw(trans, TPhase, TDelay);
-    }
-
-    void sendNextResponse()
-    {
-        // only send the next response when there response for the oldest pending request
-        // (requestsInOrder.front()) has been received
-        if (!responseIsPendingInInitator &&
-            (receivedResponses.count(pendingRequestsInOrder.front()) != 0))
-        {
-            tlm::tlm_generic_payload* payloadToSend = pendingRequestsInOrder.front();
-            responseIsPendingInInitator = true;
-            sendToInitiator(*payloadToSend, tlm::BEGIN_RESP, sc_core::SC_ZERO_TIME);
-        }
-        //        else if(!responseIsPendingInInitator && receivedResponses.size()>0 &&
-        //        !receivedResponses.count(pendingRequestsInOrder.front())>0)
-        //        {
-        //            cout << "cant send this response, because we are still waiting for response of
-        //            oldest pending request. Elemts in buffer: " <<  receivedResponses.size() <<
-        //            endl;
-        //        }
-    }
-};
-
-} // namespace DRAMSys
-
-#endif // REORDERBUFFER_H
diff --git a/src/libdramsys/DRAMSys/simulation/SimConfig.cpp b/src/libdramsys/DRAMSys/simulation/SimConfig.cpp
new file mode 100644
index 00000000..f2958faf
--- /dev/null
+++ b/src/libdramsys/DRAMSys/simulation/SimConfig.cpp
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2024, 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.
+ *
+ * Authors:
+ *    Derek Christ
+ */
+
+#include "SimConfig.h"
+#include "DRAMSys/config/SimConfig.h"
+
+#include <systemc>
+
+namespace DRAMSys
+{
+
+SimConfig::SimConfig(const Config::SimConfig& simConfig) :
+    simulationName(simConfig.SimulationName.value_or(DEFAULT_SIMULATION_NAME.data())),
+    databaseRecording(simConfig.DatabaseRecording.value_or(DEFAULT_DATABASE_RECORDING)),
+    powerAnalysis(simConfig.PowerAnalysis.value_or(DEFAULT_POWER_ANALYSIS)),
+    enableWindowing(simConfig.EnableWindowing.value_or(DEFAULT_ENABLE_WINDOWING)),
+    windowSize(simConfig.WindowSize.value_or(DEFAULT_WINDOW_SIZE)),
+    debug(simConfig.Debug.value_or(DEFAULT_DEBUG)),
+    simulationProgressBar(
+        simConfig.SimulationProgressBar.value_or(DEFAULT_SIMULATION_PROGRESS_BAR)),
+    checkTLM2Protocol(simConfig.CheckTLM2Protocol.value_or(DEFAULT_CHECK_TLM2_PROTOCOL)),
+    useMalloc(simConfig.UseMalloc.value_or(DEFAULT_USE_MALLOC)),
+    addressOffset(simConfig.AddressOffset.value_or(DEFAULT_ADDRESS_OFFSET)),
+    storeMode(simConfig.StoreMode.value_or(DEFAULT_STORE_MODE))
+{
+    if (storeMode == Config::StoreModeType::Invalid)
+        SC_REPORT_FATAL("SimConfig", "Invalid StoreMode");
+
+    if (windowSize == 0)
+        SC_REPORT_FATAL("SimConfig", "Minimum window size is 1");
+
+#ifndef DRAMPOWER
+    if (powerAnalysis)
+        SC_REPORT_FATAL("SimConfig",
+                        "Power analysis is only supported with included DRAMPower library!");
+#endif
+}
+
+} // namespace DRAMSys
diff --git a/src/libdramsys/DRAMSys/simulation/DRAMSysRecordable.h b/src/libdramsys/DRAMSys/simulation/SimConfig.h
similarity index 56%
rename from src/libdramsys/DRAMSys/simulation/DRAMSysRecordable.h
rename to src/libdramsys/DRAMSys/simulation/SimConfig.h
index 69efdda9..d02454d8 100644
--- a/src/libdramsys/DRAMSys/simulation/DRAMSysRecordable.h
+++ b/src/libdramsys/DRAMSys/simulation/SimConfig.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, RPTU Kaiserslautern-Landau
+ * Copyright (c) 2024, RPTU Kaiserslautern-Landau
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,42 +30,48 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Authors:
- *    Lukas Steiner
  *    Derek Christ
  */
 
-#ifndef DRAMSYSRECORDABLE_H
-#define DRAMSYSRECORDABLE_H
+#ifndef SIM_CONFIG_H
+#define SIM_CONFIG_H
 
-#include "DRAMSys/common/TlmRecorder.h"
-#include "DRAMSys/simulation/DRAMSys.h"
+#include <DRAMSys/config/SimConfig.h>
 
-#include "DRAMSys/config/DRAMSysConfiguration.h"
+#include <string>
 
 namespace DRAMSys
 {
 
-class DRAMSysRecordable : public DRAMSys
+struct SimConfig
 {
-public:
-    DRAMSysRecordable(const sc_core::sc_module_name& name,
-                      const ::DRAMSys::Config::Configuration& configLib);
+    SimConfig(const Config::SimConfig& simConfig);
 
-protected:
-    void end_of_simulation() override;
+    std::string simulationName;
+    bool databaseRecording;
+    bool powerAnalysis;
+    bool enableWindowing;
+    unsigned int windowSize;
+    bool debug;
+    bool simulationProgressBar;
+    bool checkTLM2Protocol;
+    bool useMalloc;
+    unsigned long long int addressOffset;
+    Config::StoreModeType storeMode;
 
-private:
-    // Transaction Recorders (one per channel).
-    // They generate the output databases.
-    std::vector<TlmRecorder> tlmRecorders;
-
-    void setupTlmRecorders(const std::string& traceName,
-                           const ::DRAMSys::Config::Configuration& configLib);
-
-    void instantiateModules(const std::string& traceName,
-                            const ::DRAMSys::Config::Configuration& configLib);
+    static constexpr std::string_view DEFAULT_SIMULATION_NAME = "default";
+    static constexpr bool DEFAULT_DATABASE_RECORDING = false;
+    static constexpr bool DEFAULT_POWER_ANALYSIS = false;
+    static constexpr bool DEFAULT_ENABLE_WINDOWING = false;
+    static constexpr unsigned int DEFAULT_WINDOW_SIZE = 1000;
+    static constexpr bool DEFAULT_DEBUG = false;
+    static constexpr bool DEFAULT_SIMULATION_PROGRESS_BAR = false;
+    static constexpr bool DEFAULT_CHECK_TLM2_PROTOCOL = false;
+    static constexpr bool DEFAULT_USE_MALLOC = false;
+    static constexpr unsigned long long int DEFAULT_ADDRESS_OFFSET = 0;
+    static constexpr Config::StoreModeType DEFAULT_STORE_MODE = Config::StoreModeType::NoStorage;
 };
 
 } // namespace DRAMSys
 
-#endif // DRAMSYSRECORDABLE_H
+#endif
diff --git a/src/simulator/simulator/Simulator.cpp b/src/simulator/simulator/Simulator.cpp
index 305808d0..6a118353 100644
--- a/src/simulator/simulator/Simulator.cpp
+++ b/src/simulator/simulator/Simulator.cpp
@@ -46,17 +46,9 @@ Simulator::Simulator(DRAMSys::Config::Configuration configuration,
     storageEnabled(configuration.simconfig.StoreMode == DRAMSys::Config::StoreModeType::Store),
     memoryManager(storageEnabled),
     configuration(std::move(configuration)),
-    resourceDirectory(std::move(resourceDirectory))
+    resourceDirectory(std::move(resourceDirectory)),
+    dramSys(std::make_unique<DRAMSys::DRAMSys>("DRAMSys", this->configuration))
 {
-    if (this->configuration.simconfig.DatabaseRecording.value_or(false))
-    {
-        dramSys = std::make_unique<DRAMSys::DRAMSysRecordable>("DRAMSys", this->configuration);
-    }
-    else
-    {
-        dramSys = std::make_unique<DRAMSys::DRAMSys>("DRAMSys", this->configuration);
-    }
-
     terminateInitiator = [this]()
     {
         terminatedInitiators++;
@@ -74,7 +66,10 @@ Simulator::Simulator(DRAMSys::Config::Configuration configuration,
     };
 
     if (!configuration.tracesetup.has_value())
+    {
         SC_REPORT_FATAL("Simulator", "No traffic initiators specified");
+        std::abort(); // Silence warning
+    }
 
     for (const auto& initiatorConfig : *this->configuration.tracesetup)
     {
@@ -88,8 +83,8 @@ Simulator::Simulator(DRAMSys::Config::Configuration configuration,
 std::unique_ptr<Initiator>
 Simulator::instantiateInitiator(const DRAMSys::Config::Initiator& initiator)
 {
-    uint64_t memorySize = dramSys->getConfig().memSpec->getSimMemSizeInBytes();
-    unsigned int defaultDataLength = dramSys->getConfig().memSpec->defaultBytesPerBurst;
+    uint64_t memorySize = dramSys->getMemSpec().getSimMemSizeInBytes();
+    unsigned int defaultDataLength = dramSys->getMemSpec().defaultBytesPerBurst;
 
     return std::visit(
         [=](auto&& config) -> std::unique_ptr<Initiator>
diff --git a/src/simulator/simulator/Simulator.h b/src/simulator/simulator/Simulator.h
index 35f2ddf8..05573c6a 100644
--- a/src/simulator/simulator/Simulator.h
+++ b/src/simulator/simulator/Simulator.h
@@ -39,7 +39,7 @@
 #include "MemoryManager.h"
 
 #include <DRAMSys/config/DRAMSysConfiguration.h>
-#include <DRAMSys/simulation/DRAMSysRecordable.h>
+#include <DRAMSys/simulation/DRAMSys.h>
 
 static constexpr std::string_view TRACE_DIRECTORY = "traces";
 
diff --git a/tests/tests_configuration/reference.json b/tests/tests_configuration/reference.json
index bac5c903..820bf82c 100644
--- a/tests/tests_configuration/reference.json
+++ b/tests/tests_configuration/reference.json
@@ -145,8 +145,6 @@
             "DatabaseRecording": true,
             "Debug": false,
             "EnableWindowing": false,
-            "ErrorCSVFile": "error.csv",
-            "ErrorChipSeed": 42,
             "PowerAnalysis": false,
             "SimulationName": "ddr5",
             "SimulationProgressBar": true,
@@ -207,4 +205,4 @@
             }
         ]
     }
-}
\ No newline at end of file
+}
diff --git a/tests/tests_configuration/resources/simconfig/ddr5.json b/tests/tests_configuration/resources/simconfig/ddr5.json
index d3987d37..8512eee0 100644
--- a/tests/tests_configuration/resources/simconfig/ddr5.json
+++ b/tests/tests_configuration/resources/simconfig/ddr5.json
@@ -6,8 +6,6 @@
         "Debug": false,
         "ECCControllerMode": "Disabled",
         "EnableWindowing": false,
-        "ErrorCSVFile": "",
-        "ErrorChipSeed": 42,
         "PowerAnalysis": false,
         "SimulationName": "ddr5",
         "SimulationProgressBar": true,
diff --git a/tests/tests_configuration/test_configuration.cpp b/tests/tests_configuration/test_configuration.cpp
index 7b0bb8b6..ce44f156 100644
--- a/tests/tests_configuration/test_configuration.cpp
+++ b/tests/tests_configuration/test_configuration.cpp
@@ -108,8 +108,6 @@ protected:
                                          true,
                                          false,
                                          false,
-                                         {"error.csv"},
-                                         42,
                                          false,
                                          {"ddr5"},
                                          true,
@@ -168,7 +166,11 @@ DRAMSys::Config::MemSpec ConfigurationTest::createMemSpec()
         {"clkMhz", 1600},
     }}};
 
-    return {memArchitectureSpec, "JEDEC_2x8x2Gbx4_DDR5-3200A", "DDR5", memTimingSpec, {}};
+    return {memArchitectureSpec,
+            "JEDEC_2x8x2Gbx4_DDR5-3200A",
+            DRAMSys::Config::MemoryType::DDR5,
+            memTimingSpec,
+            {}};
 }
 
 DRAMSys::Config::TracePlayer ConfigurationTest::createTracePlayer()
@@ -319,8 +321,6 @@ TEST_F(ConfigurationTest, SimConfig)
                     "DatabaseRecording": true,
                     "Debug": false,
                     "EnableWindowing": false,
-                    "ErrorCSVFile": "error.csv",
-                    "ErrorChipSeed": 42,
                     "PowerAnalysis": false,
                     "SimulationName": "ddr5",
                     "SimulationProgressBar": true,
diff --git a/tests/tests_dramsys/b_transport/b_transport.cpp b/tests/tests_dramsys/b_transport/b_transport.cpp
index 3a4aff20..1ffe788e 100644
--- a/tests/tests_dramsys/b_transport/b_transport.cpp
+++ b/tests/tests_dramsys/b_transport/b_transport.cpp
@@ -36,7 +36,6 @@
 #include <gtest/gtest.h>
 
 #include <DRAMSys/simulation/DRAMSys.h>
-#include <DRAMSys/simulation/dram/Dram.h>
 
 class SystemCTest : public testing::Test
 {
@@ -92,7 +91,7 @@ struct BlockingInitiator : sc_core::sc_module
         sc_core::sc_time delay = sc_core::SC_ZERO_TIME;
         iSocket->b_transport(payload, delay);
 
-        EXPECT_EQ(delay, dramSys.getConfig().blockingReadDelay);
+        EXPECT_EQ(delay, dramSys.getMcConfig().blockingReadDelay);
     }
 
     void writeAccess()
@@ -105,7 +104,7 @@ struct BlockingInitiator : sc_core::sc_module
         sc_core::sc_time delay = sc_core::SC_ZERO_TIME;
         iSocket->b_transport(payload, delay);
 
-        EXPECT_EQ(delay, dramSys.getConfig().blockingWriteDelay);
+        EXPECT_EQ(delay, dramSys.getMcConfig().blockingWriteDelay);
     }
 };
 
diff --git a/tests/tests_dramsys/b_transport/configs/no_storage.json b/tests/tests_dramsys/b_transport/configs/no_storage.json
index 1515e3bf..94c45781 100644
--- a/tests/tests_dramsys/b_transport/configs/no_storage.json
+++ b/tests/tests_dramsys/b_transport/configs/no_storage.json
@@ -138,8 +138,6 @@
             "DatabaseRecording": true,
             "Debug": false,
             "EnableWindowing": false,
-            "ErrorCSVFile": "",
-            "ErrorChipSeed": 42,
             "PowerAnalysis": false,
             "SimulationName": "example",
             "SimulationProgressBar": true,
diff --git a/tests/tests_dramsys/b_transport/configs/storage.json b/tests/tests_dramsys/b_transport/configs/storage.json
index dbe694c5..283008db 100644
--- a/tests/tests_dramsys/b_transport/configs/storage.json
+++ b/tests/tests_dramsys/b_transport/configs/storage.json
@@ -136,8 +136,6 @@
             "DatabaseRecording": true,
             "Debug": false,
             "EnableWindowing": false,
-            "ErrorCSVFile": "",
-            "ErrorChipSeed": 42,
             "PowerAnalysis": false,
             "SimulationName": "example",
             "SimulationProgressBar": true,