Finished refactoring.

DRAMSys/traceAnalyzer/CMakeLists.txt

@@ -104,10 +104,12 @@ add_executable(TraceAnalyzer
     businessObjects/dependencymodels.cpp
 
     businessObjects/dramTimeDependencies/dbEntries/DDR3dbphaseentry.cpp
-    businessObjects/dramTimeDependencies/devices/activatewindowpoolcontroller.cpp
-    businessObjects/dramTimeDependencies/devices/dramtimedependenciesIF.cpp
-    businessObjects/dramTimeDependencies/devices/DDR3TimeDependencies.cpp
-    businessObjects/dramTimeDependencies/devices/dramtimedependencyfactory.cpp
+    businessObjects/dramTimeDependencies/deviceDependencies/activatewindowpoolcontroller.cpp
+    businessObjects/dramTimeDependencies/deviceDependencies/dramtimedependenciesIF.cpp
+    businessObjects/dramTimeDependencies/deviceDependencies/DDR3TimeDependencies.cpp
+    businessObjects/dramTimeDependencies/configurations/configurationfactory.cpp
+    businessObjects/dramTimeDependencies/configurations/configurationIF.cpp
+    businessObjects/dramTimeDependencies/configurations/DDR3Configuration.cpp
     businessObjects/dramTimeDependencies/phasedependenciestracker.cpp
 
     selectmetrics.ui

DRAMSys/traceAnalyzer/businessObjects/dramTimeDependencies/configurations/DDR3Configuration.cpp

@@ -0,0 +1,11 @@
+
+#include "DDR3Configuration.h"
+
+DDR3Configuration::DDR3Configuration(const TraceDB& tdb) {
+    mDeviceDeps = std::make_shared<DDR3TimeDependencies>(std::forward<const QJsonObject>(mGetMemspec(tdb)), mGetClk(tdb));
+
+}
+
+std::shared_ptr<DBPhaseEntryIF> DDR3Configuration::makePhaseEntry(const QSqlQuery& query) const {
+    return std::make_shared<DDR3DBPhaseEntry>(query);
+}

DRAMSys/traceAnalyzer/businessObjects/dramTimeDependencies/configurations/DDR3Configuration.h

@@ -0,0 +1,14 @@
+
+#pragma once
+
+#include "configurationIF.h"
+#include "businessObjects/dramTimeDependencies/deviceDependencies/DDR3TimeDependencies.h"
+#include "businessObjects/dramTimeDependencies/dbEntries/DDR3dbphaseentry.h"
+
+class DDR3Configuration : public ConfigurationIF {
+ public:
+    DDR3Configuration(const TraceDB& tdb);
+
+    std::shared_ptr<DBPhaseEntryIF> makePhaseEntry(const QSqlQuery&) const override;
+
+};

DRAMSys/traceAnalyzer/businessObjects/dramTimeDependencies/configurations/configurationIF.cpp

@@ -0,0 +1,53 @@
+
+#include "configurationIF.h"
+
+const uint ConfigurationIF::getClk() const {
+    if (!mDeviceDeps) 
+        throw std::invalid_argument("Invalid DRAMTimeDependenciesIF object in 'ConfigurationIF::getClk'.");
+
+    return mDeviceDeps->getClk();
+}
+
+DependencyMap ConfigurationIF::getDependencies(std::vector<QString>& commands) const {
+    if (!mDeviceDeps) 
+        throw std::invalid_argument("Invalid DRAMTimeDependenciesIF object in 'ConfigurationIF::getDependencies'.");
+
+    return mDeviceDeps->getDependencies(commands);
+}
+
+ActivateWindowPoolController ConfigurationIF::getAWPools() const {
+    if (!mDeviceDeps) 
+        throw std::invalid_argument("Invalid DRAMTimeDependenciesIF object in 'ConfigurationIF::getAWPools'.");
+
+    return mDeviceDeps->getAWPools();
+}
+
+const QString ConfigurationIF::getDeviceName(const TraceDB& tdb) {
+    return mGetMemspec(tdb)["memoryType"].toString();
+}
+
+const uint ConfigurationIF::mGetClk(const TraceDB& tdb) {
+    QSqlDatabase db = tdb.getDatabase();
+    QString query = "SELECT clk FROM GeneralInfo";
+    QSqlQuery sqlQuery = db.exec(query);
+
+    sqlQuery.next();
+    uint clock = sqlQuery.value(0).toLongLong();
+    sqlQuery.finish();
+
+    return clock;
+}
+
+const QJsonObject ConfigurationIF::mGetMemspec(const TraceDB& tdb) {
+    QSqlDatabase db = tdb.getDatabase();
+    QString query = "SELECT Memspec FROM GeneralInfo";
+    QSqlQuery sqlQuery = db.exec(query);
+
+    sqlQuery.next();
+    QString memSpecJson = sqlQuery.value(0).toString();
+    sqlQuery.finish();
+
+    QJsonDocument jsonDocument = QJsonDocument::fromJson(memSpecJson.toUtf8());
+
+    return jsonDocument.object()["memspec"].toObject();
+}

DRAMSys/traceAnalyzer/businessObjects/dramTimeDependencies/configurations/configurationIF.h

@@ -0,0 +1,29 @@
+
+#pragma once
+
+#include <QSqlQuery>
+
+#include "businessObjects/dramTimeDependencies/deviceDependencies/dramtimedependenciesIF.h"
+#include "businessObjects/dramTimeDependencies/dbEntries/dbphaseentryIF.h"
+
+class ConfigurationIF {
+ public:
+    ConfigurationIF() {};
+    virtual ~ConfigurationIF() = default;
+
+    virtual std::shared_ptr<DBPhaseEntryIF> makePhaseEntry(const QSqlQuery&) const { return nullptr; }
+    
+    // Delegated methods
+    const uint getClk() const;
+    DependencyMap getDependencies(std::vector<QString>& commands) const;
+    ActivateWindowPoolController getAWPools() const;
+
+    static const QString getDeviceName(const TraceDB& tdb);
+
+ protected:
+    std::shared_ptr<DRAMTimeDependenciesIF> mDeviceDeps = nullptr;
+
+    static const uint mGetClk(const TraceDB& tdb);
+    static const QJsonObject mGetMemspec(const TraceDB& tdb);
+
+};

DRAMSys/traceAnalyzer/businessObjects/dramTimeDependencies/configurations/configurationfactory.cpp

@@ -33,46 +33,41 @@
  *    Iron Prando da Silva
  */
 
-#include "dramtimedependencyfactory.h"
+#include "configurationfactory.h"
 
-std::shared_ptr<DRAMTimeDependenciesIF> DRAMTimeDependencyFactory::make(const TraceDB& tdb) {
-    uint clk = 0;
-    const QJsonObject& memspec = DRAMTimeDependenciesIF::getMemspec(tdb, clk);
-    QString deviceType = memspec["memoryType"].toString();
+std::shared_ptr<ConfigurationIF> ConfigurationFactory::make(const TraceDB& tdb) {
+    const QString deviceName = ConfigurationIF::getDeviceName(tdb);
     
-    if (deviceType == "DDR3") {
-        return std::make_shared<DDR3TimeDependencies>(memspec, clk);
+    if (deviceName == "DDR3") {
+        return std::make_shared<DDR3Configuration>(tdb);
 
     } else {
         // TODO maybe throw?
-        throw std::invalid_argument("Could not find the device type '" + deviceType.toStdString() + '\'');
+        throw std::invalid_argument("Could not find the device type '" + deviceName.toStdString() + '\'');
 
     }
 
 }
 
-const std::vector<QString> DRAMTimeDependencyFactory::possiblePhases(const TraceDB& tdb) {
-    uint clk; // Not used
-    const QJsonObject& memspec = DRAMTimeDependenciesIF::getMemspec(tdb, clk);
-    QString deviceType = memspec["memoryType"].toString();
+const std::vector<QString> ConfigurationFactory::possiblePhases(const TraceDB& tdb) {
+    const QString deviceName = ConfigurationIF::getDeviceName(tdb);
     
-    if (deviceType == "DDR3") {
+    if (deviceName == "DDR3") {
         return DDR3TimeDependencies::getPossiblePhases();
 
     } else {
         // TODO maybe throw?
-        throw std::invalid_argument("Could not find the device type '" + deviceType.toStdString() + '\'');
+        throw std::invalid_argument("Could not find the device type '" + deviceName.toStdString() + '\'');
 
     }
 
 }
 
-bool DRAMTimeDependencyFactory::deviceSupported(const TraceDB& tdb) {
+bool ConfigurationFactory::deviceSupported(const TraceDB& tdb) {
     uint clk; // Not used
-    const QJsonObject& memspec = DRAMTimeDependenciesIF::getMemspec(tdb, clk);
-    QString deviceType = memspec["memoryType"].toString();
+    const QString deviceName = ConfigurationIF::getDeviceName(tdb);
 
-    if (deviceType == "DDR3") {
+    if (deviceName == "DDR3") {
         return true;
 
     } else {

DRAMSys/traceAnalyzer/businessObjects/dramTimeDependencies/configurations/configurationfactory.h

@@ -37,19 +37,19 @@
 
 #include <memory>
 
-#include "dramtimedependenciesIF.h"
-#include "DDR3TimeDependencies.h"
+#include "configurationIF.h"
+#include "DDR3Configuration.h"
 #include "data/tracedb.h"
 
-class DRAMTimeDependencyFactory {
+class ConfigurationFactory {
 public:
-    static std::shared_ptr<DRAMTimeDependenciesIF> make(const TraceDB& tdb);
+    static std::shared_ptr<ConfigurationIF> make(const TraceDB& tdb);
 
     static const std::vector<QString> possiblePhases(const TraceDB& tdb);
 
     static bool deviceSupported(const TraceDB& tdb);
 
 private:
-    DRAMTimeDependencyFactory() = delete;
-    ~DRAMTimeDependencyFactory() = delete;
+    ConfigurationFactory() = delete;
+    ~ConfigurationFactory() = delete;
 };

DRAMSys/traceAnalyzer/businessObjects/dramTimeDependencies/dbEntries/dbphaseentryIF.h

@@ -9,7 +9,7 @@
 class DBPhaseEntryIF {
  public:
     DBPhaseEntryIF() = default;
-    ~DBPhaseEntryIF() = default;
+    virtual ~DBPhaseEntryIF() = default;
  
     virtual bool potentialDependency(const TimeDependency& dep, const std::shared_ptr<DBPhaseEntryIF> otherPhase) const { return false; }
 

DRAMSys/traceAnalyzer/businessObjects/dramTimeDependencies/deviceDependencies/dramtimedependenciesIF.cpp

@@ -73,22 +73,6 @@ ActivateWindowPoolController DRAMTimeDependenciesIF::getAWPools() const {
     return ActivateWindowPoolController(mPoolSizes);
 }
 
-const QJsonObject DRAMTimeDependenciesIF::getMemspec(const TraceDB& tdb, uint& tCK) {
-    QSqlDatabase db = tdb.getDatabase();
-    QString query = "SELECT clk, Memspec FROM GeneralInfo";
-    QSqlQuery sqlQuery = db.exec(query);
-
-    sqlQuery.next();
-    tCK = sqlQuery.value(0).toInt();
-    QString memSpecJson = sqlQuery.value(1).toString();
-    sqlQuery.finish();
-
-    QJsonDocument jsonDocument = QJsonDocument::fromJson(memSpecJson.toUtf8());
-
-    return jsonDocument.object()["memspec"].toObject();
-
-}
-
 void DRAMTimeDependenciesIF::mFilterDependencyList(std::vector<TimeDependency>& dependencyList, const std::vector<QString>& dependencyFilter) const {
     std::vector<TimeDependency> newDepList(dependencyList.size());
     

DRAMSys/traceAnalyzer/businessObjects/dramTimeDependencies/deviceDependencies/dramtimedependenciesIF.h

@@ -46,8 +46,6 @@ public:
 
     DependencyMap getDependencies(std::vector<QString>& dependencyFilter) const;
 
-    static const QJsonObject getMemspec(const TraceDB& tdb, uint& tCK);
-
     const uint getClk() const { return tCK; }
 
     ActivateWindowPoolController getAWPools() const;

DRAMSys/traceAnalyzer/businessObjects/dramTimeDependencies/phasedependenciestracker.cpp

@@ -37,15 +37,17 @@
 
 void 
 PhaseDependenciesTracker::calculateDependencies(TraceDB& tdb, std::vector<QString>& commands) {
+    auto deviceConfig = ConfigurationFactory::make(tdb);
+
     mBeginTransaction(tdb);
 
     mDropTable(tdb);
 
-    if (commands.size() > 0) {        
-        auto& phases = mGetFilteredPhases(tdb, commands);
+    if (commands.size() > 0) {
+        auto& phases = mGetFilteredPhases(deviceConfig, tdb, commands);
         
         if (phases.size() != 0) {
-            auto& entries = mCalculateDependencies(tdb, phases, commands);
+            auto& entries = mCalculateDependencies(deviceConfig, phases, commands);
             
             if (entries.size() > 0) {
                 mCreateTable(tdb);
@@ -121,7 +123,7 @@ void PhaseDependenciesTracker::mInsertIntoTable(TraceDB& tdb, const std::vector<
 }
 
 const std::vector<std::shared_ptr<DBPhaseEntryIF>>
-PhaseDependenciesTracker::mGetFilteredPhases(TraceDB& tdb, const std::vector<QString>& commands) {
+PhaseDependenciesTracker::mGetFilteredPhases(const std::shared_ptr<ConfigurationIF> deviceConfig, TraceDB& tdb, const std::vector<QString>& commands) {
     std::vector<std::shared_ptr<DBPhaseEntryIF>> phases;
 
     QString queryStr = "SELECT Phases.*, Transactions.TBank, Transactions.TBankgroup, Transactions.TRank "
@@ -160,7 +162,7 @@ PhaseDependenciesTracker::mGetFilteredPhases(TraceDB& tdb, const std::vector<QSt
     size_t rowIt = 0;
     do {
         // TODO factory method
-        phases[rowIt] = std::make_shared<DDR3DBPhaseEntry>(query);
+        phases[rowIt] = deviceConfig->makePhaseEntry(query);
 
         ++rowIt;
     } while (query.next());
@@ -175,22 +177,22 @@ PhaseDependenciesTracker::mGetFilteredPhases(TraceDB& tdb, const std::vector<QSt
 }
 
 const std::vector<DBDependencyEntry>
-PhaseDependenciesTracker::mCalculateDependencies(const TraceDB& tdb, const std::vector<std::shared_ptr<DBPhaseEntryIF>>& phases, std::vector<QString>& commands) {
+PhaseDependenciesTracker::mCalculateDependencies(const std::shared_ptr<ConfigurationIF> deviceConfig, const std::vector<std::shared_ptr<DBPhaseEntryIF>>& phases, std::vector<QString>& commands) {
     std::vector<DBDependencyEntry> entries;
     entries.reserve((size_t) (0.4 * phases.size()));
 
-    // Get dependencies for tdb device
-    auto device = DRAMTimeDependencyFactory::make(tdb);
-    DependencyMap deviceDependencies = device->getDependencies(commands);
+    // Get dependencies for device
+    DependencyMap deviceDependencies = deviceConfig->getDependencies(commands);
 
     // Tries to find all timing dependencies for each phase on the trace
-    ActivateWindowPoolController poolController = device->getAWPools();
+    ActivateWindowPoolController poolController = deviceConfig->getAWPools();
     for (size_t i = 1; i < phases.size(); i++) {
         // NAW dependencies variables reset
         poolController.clear();
 
         // Auxiliary variables
-        const auto& phase = phases[i];
+        const auto phase = phases[i];
+        if (phase == nullptr) continue;
         
         // Get time dependency descriptions for the current phase
         const auto& deps = deviceDependencies.at(phase->phaseName);
@@ -256,7 +258,7 @@ PhaseDependenciesTracker::mCalculateDependencies(const TraceDB& tdb, const std::
             }
 
             // Capture command bus dependencies
-            if (timeDiff == device->getClk()) {
+            if (timeDiff == deviceConfig->getClk()) {
                 entries.emplace_back(DBDependencyEntry{
                     phase->id,
                     phase->phaseName,

DRAMSys/traceAnalyzer/businessObjects/dramTimeDependencies/phasedependenciestracker.h

@@ -40,7 +40,7 @@
 #include <QString>
 
 #include "data/tracedb.h"
-#include "devices/dramtimedependencyfactory.h"
+#include "configurations/configurationfactory.h"
 #include "common/common.h"
 
 class PhaseDependenciesTracker {
@@ -52,8 +52,8 @@ private:
     static void mCreateTable(TraceDB& tdb);
     static void mInsertIntoTable(TraceDB& tdb, const std::vector<DBDependencyEntry>& entries);
 
-    static const std::vector<std::shared_ptr<DBPhaseEntryIF>> mGetFilteredPhases(TraceDB& tdb, const std::vector<QString>& commands);
-    static const std::vector<DBDependencyEntry> mCalculateDependencies(const TraceDB& tdb, const std::vector<std::shared_ptr<DBPhaseEntryIF>>& phases, std::vector<QString>& commands);
+    static const std::vector<std::shared_ptr<DBPhaseEntryIF>> mGetFilteredPhases(const std::shared_ptr<ConfigurationIF>, TraceDB& tdb, const std::vector<QString>& commands);
+    static const std::vector<DBDependencyEntry> mCalculateDependencies(const std::shared_ptr<ConfigurationIF>, const std::vector<std::shared_ptr<DBPhaseEntryIF>>& phases, std::vector<QString>& commands);
 
     static QSqlQuery mExecuteQuery(TraceDB& tdb, const QString queryStr);
 

DRAMSys/traceAnalyzer/tracefiletab.cpp

@@ -193,7 +193,7 @@ void TraceFileTab::setUpCommentView()
 }
 
 void TraceFileTab::setUpPossiblePhases() {
-    const auto possiblePhases = DRAMTimeDependencyFactory::possiblePhases(navigator->TraceFile());
+    const auto possiblePhases = ConfigurationFactory::possiblePhases(navigator->TraceFile());
     for (auto p : possiblePhases) {
         auto item = new QListWidgetItem(p, ui->depTabPossiblePhases);
         item->setFlags(item->flags() | Qt::ItemIsUserCheckable); // set checkable flag
@@ -201,7 +201,7 @@ void TraceFileTab::setUpPossiblePhases() {
 
     }
 
-    ui->calculateDependencies->setEnabled(DRAMTimeDependencyFactory::deviceSupported(navigator->TraceFile()));
+    ui->calculateDependencies->setEnabled(ConfigurationFactory::deviceSupported(navigator->TraceFile()));
 }
 
 void TraceFileTab::tracefileChanged()