Feature/refactor

CMakeLists.txt

@@ -2,19 +2,19 @@ if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
   message(FATAL_ERROR "Create a separate build directory")
 endif()
 
-cmake_minimum_required (VERSION 3.1)
+cmake_minimum_required (VERSION 3.12)
 
 project(mcpat DESCRIPTION "Power Timing Area Calculator"
               LANGUAGES CXX)
 
 find_package(Boost 1.56 REQUIRED COMPONENTS
-             program_options)
+             program_options
+             serialization)
 
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 
 find_package(Threads REQUIRED)
 
-
 set (MCPAT_VERSION_MAJOR 1)
 set (MCPAT_VERSION_MINOR 3)
 set (MCPAT_VERSION_PATCH 0)

src/CMakeLists.txt

@@ -1,5 +1,8 @@
 add_subdirectory(cacti)
+add_subdirectory(cache)
+add_subdirectory(core)
 add_subdirectory(iocontrollers)
+add_subdirectory(logic)
 add_subdirectory(memoryctrl)
 
 add_library(top
@@ -8,37 +11,39 @@ add_library(top
   array.cc
   basic_components.h
   basic_components.cc
-  core.h
-  core.cc
   globalvar.h
   interconnect.h
   interconnect.cc
-  logic.h
-  logic.cc
   noc.h
   noc.cc
   options.h
   options.cc
   processor.h
   processor.cc
-  sharedcache.h
-  sharedcache.cc
   version.h
   xmlParser.h
   xmlParser.cc
   XML_Parse.h
   XML_Parse.cc
 )
 target_include_directories(top PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
-target_link_libraries(top LINK_PUBLIC cacti iocontrollers memoryctrl)
+target_link_libraries(top
+                      LINK_PUBLIC
+                      cache
+                      cacti
+                      core
+                      logic
+                      iocontrollers
+                      memoryctrl)
 
 add_executable(mcpat main.cc)
 
 target_link_libraries(mcpat
                       LINK_PUBLIC
                       top
                       Threads::Threads
-                      Boost::program_options)
+                      Boost::program_options
+                      Boost::serialization)
 
 add_custom_command(TARGET mcpat POST_BUILD
   COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:mcpat> ${PROJECT_BINARY_DIR}/mcpat

src/array.cc

@@ -238,12 +238,13 @@ void ArrayST::optimize_array() {
       // For array structures except CAM and FA, Give warning but still provide
       // a result with best timing found
       if (throughput_overflow == true)
-        cout << "Warning: " << name
-             << " array structure cannot satisfy throughput constraint."
-             << endl;
+        std::cerr << "Warning: " << name
+                  << " array structure cannot satisfy throughput constraint."
+                  << std::endl;
       if (latency_overflow == true)
-        cout << "Warning: " << name
-             << " array structure cannot satisfy latency constraint." << endl;
+        std::cerr << "Warning: " << name
+                  << " array structure cannot satisfy latency constraint."
+                  << std::endl;
     }
 
     //	else

src/array.h

@@ -38,6 +38,10 @@
 #include "const.h"
 #include "parameter.h"
 
+#include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/base_object.hpp>
+#include <boost/serialization/list.hpp>
+#include <boost/serialization/utility.hpp>
 #include <iostream>
 #include <string>
 
@@ -79,51 +83,20 @@ class ArrayST : public Component {
   virtual void optimize_array();
   virtual void compute_base_power();
   void leakage_feedback(double temperature);
-};
 
-class InstCache : public Component {
-public:
-  ArrayST *caches;
-  ArrayST *missb;
-  ArrayST *ifb;
-  ArrayST *prefetchb;
-  powerDef power_t; // temp value holder for both (max) power and runtime power
-  InstCache() {
-    caches = 0;
-    missb = 0;
-    ifb = 0;
-    prefetchb = 0;
-  };
-  ~InstCache() {
-    if (caches) { // caches->local_result.cleanup();
-      delete caches;
-      caches = 0;
-    }
-    if (missb) { // missb->local_result.cleanup();
-      delete missb;
-      missb = 0;
-    }
-    if (ifb) { // ifb->local_result.cleanup();
-      delete ifb;
-      ifb = 0;
-    }
-    if (prefetchb) { // prefetchb->local_result.cleanup();
-      delete prefetchb;
-      prefetchb = 0;
-    }
-  };
-};
+  // Serialization
+  friend class boost::serialization::access;
 
-class DataCache : public InstCache {
-public:
-  ArrayST *wbb;
-  DataCache() { wbb = 0; };
-  ~DataCache() {
-    if (wbb) { // wbb->local_result.cleanup();
-      delete wbb;
-      wbb = 0;
-    }
-  };
+  template <class Archive>
+  void serialize(Archive &ar, const unsigned int version) {
+    ar &name;
+    ar &power_t;
+    ar &stats_t;
+    ar &tdp_stats;
+    ar &rtp_stats;
+    ar &local_result;
+    Component::serialize(ar, version);
+  }
 };
 
 #endif /* __ARRAY_H__ */

src/basic_components.h

@@ -35,6 +35,10 @@
 #include "XML_Parse.h"
 #include "parameter.h"
 
+#include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/base_object.hpp>
+#include <boost/serialization/list.hpp>
+#include <boost/serialization/utility.hpp>
 #include <vector>
 
 const double cdb_overhead = 1.1;
@@ -45,8 +49,6 @@ enum Renaming_type { RAMbased, CAMbased };
 
 enum Scheduler_type { PhysicalRegFile, ReservationStation };
 
-enum cache_level { L2, L3, L1Directory, L2Directory };
-
 enum MemoryCtrl_type {
   MC,    // memory controller
   FLASHC // flash controller
@@ -90,6 +92,16 @@ class statsComponents {
                                    const statsComponents &y);
   friend statsComponents operator*(const statsComponents &x,
                                    double const *const y);
+
+  // Serialization
+  friend class boost::serialization::access;
+
+  template <class Archive>
+  void serialize(Archive &ar, const unsigned int version) {
+    ar &access;
+    ar &hit;
+    ar &miss;
+  }
 };
 
 class statsDef {
@@ -107,6 +119,16 @@ class statsDef {
 
   friend statsDef operator+(const statsDef &x, const statsDef &y);
   friend statsDef operator*(const statsDef &x, double const *const y);
+
+  // Serialization
+  friend class boost::serialization::access;
+
+  template <class Archive>
+  void serialize(Archive &ar, const unsigned int version) {
+    ar &readAc;
+    ar &writeAc;
+    ar &searchAc;
+  }
 };
 
 double longer_channel_device_reduction(enum Device_ty device_ty = Core_device,
@@ -163,23 +185,6 @@ class CoreDynParam {
   ~CoreDynParam(){};
 };
 
-class CacheDynParam {
-public:
-  CacheDynParam(){};
-  CacheDynParam(ParseXML *XML_interface, int ithCache_);
-  string name;
-  enum Dir_type dir_ty;
-  double clockRate, executionTime;
-  double capacity, blockW, assoc, nbanks;
-  double throughput, latency;
-  double duty_cycle, dir_duty_cycle;
-  // double duty_cycle;
-  int missb_size, fu_size, prefetchb_size, wbb_size;
-  double vdd;
-  double power_gating_vcc;
-  ~CacheDynParam(){};
-};
-
 class MCParam {
 public:
   MCParam(){};

src/cache/CMakeLists.txt

@@ -0,0 +1,12 @@
+add_library(cache
+  cache_param.h
+  cache_param.cc
+  datacache.h
+  datacache.cc
+  instcache.h
+  instcache.cc
+  sharedcache.h
+  sharedcache.cc
+)
+target_include_directories(cache PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(cache LINK_PUBLIC cacti top)

src/cache/cache_param.cc

@@ -0,0 +1,132 @@
+/*****************************************************************************
+ *                                McPAT
+ *                      SOFTWARE LICENSE AGREEMENT
+ *            Copyright 2012 Hewlett-Packard Development Company, L.P.
+ *                          All Rights Reserved
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * 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;
+ * neither the name of the copyright holders 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
+ * OWNER 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.”
+ *
+ ***************************************************************************/
+
+#include "cache_param.h"
+
+#include <vector>
+
+void CacheDynParam::set_params_l2_cache(const ParseXML *XML,
+                                        const int ithCache) {
+  this->name = "L2";
+  this->clockRate = XML->sys.L2[ithCache].clockrate;
+  this->clockRate *= 1e6;
+  this->executionTime =
+      XML->sys.total_cycles / (XML->sys.target_core_clockrate * 1e6);
+  this->capacity = XML->sys.L2[ithCache].L2_config[0];
+  this->blockW = XML->sys.L2[ithCache].L2_config[1];
+  this->assoc = XML->sys.L2[ithCache].L2_config[2];
+  this->nbanks = XML->sys.L2[ithCache].L2_config[3];
+  this->throughput = XML->sys.L2[ithCache].L2_config[4] / this->clockRate;
+  this->latency = XML->sys.L2[ithCache].L2_config[5] / this->clockRate;
+  this->missb_size = XML->sys.L2[ithCache].buffer_sizes[0];
+  this->fu_size = XML->sys.L2[ithCache].buffer_sizes[1];
+  this->prefetchb_size = XML->sys.L2[ithCache].buffer_sizes[2];
+  this->wbb_size = XML->sys.L2[ithCache].buffer_sizes[3];
+  this->duty_cycle = XML->sys.L2[ithCache].duty_cycle;
+  if (!XML->sys.L2[ithCache].merged_dir) {
+    this->dir_ty = NonDir;
+  } else {
+    this->dir_ty = SBT;
+    this->dir_duty_cycle = XML->sys.L2[ithCache].dir_duty_cycle;
+  }
+}
+
+void CacheDynParam::set_params_l3_cache(const ParseXML *XML,
+                                        const int ithCache) {
+  this->name = "L3";
+  this->clockRate = XML->sys.L3[ithCache].clockrate;
+  this->clockRate *= 1e6;
+  this->executionTime =
+      XML->sys.total_cycles / (XML->sys.target_core_clockrate * 1e6);
+  this->capacity = XML->sys.L3[ithCache].L3_config[0];
+  this->blockW = XML->sys.L3[ithCache].L3_config[1];
+  this->assoc = XML->sys.L3[ithCache].L3_config[2];
+  this->nbanks = XML->sys.L3[ithCache].L3_config[3];
+  this->throughput = XML->sys.L3[ithCache].L3_config[4] / this->clockRate;
+  this->latency = XML->sys.L3[ithCache].L3_config[5] / this->clockRate;
+  this->missb_size = XML->sys.L3[ithCache].buffer_sizes[0];
+  this->fu_size = XML->sys.L3[ithCache].buffer_sizes[1];
+  this->prefetchb_size = XML->sys.L3[ithCache].buffer_sizes[2];
+  this->wbb_size = XML->sys.L3[ithCache].buffer_sizes[3];
+  this->duty_cycle = XML->sys.L3[ithCache].duty_cycle;
+  if (!XML->sys.L2[ithCache].merged_dir) {
+    this->dir_ty = NonDir;
+  } else {
+    this->dir_ty = SBT;
+    this->dir_duty_cycle = XML->sys.L2[ithCache].dir_duty_cycle;
+  }
+}
+
+void CacheDynParam::set_params_l1_directory(const ParseXML *XML,
+                                            const int ithCache) {
+  this->name = "First Level Directory";
+  this->dir_ty = (enum Dir_type)XML->sys.L1Directory[ithCache].Directory_type;
+  this->clockRate = XML->sys.L1Directory[ithCache].clockrate;
+  this->clockRate *= 1e6;
+  this->executionTime =
+      XML->sys.total_cycles / (XML->sys.target_core_clockrate * 1e6);
+  this->capacity = XML->sys.L1Directory[ithCache].Dir_config[0];
+  this->blockW = XML->sys.L1Directory[ithCache].Dir_config[1];
+  this->assoc = XML->sys.L1Directory[ithCache].Dir_config[2];
+  this->nbanks = XML->sys.L1Directory[ithCache].Dir_config[3];
+  this->throughput =
+      XML->sys.L1Directory[ithCache].Dir_config[4] / this->clockRate;
+  this->latency =
+      XML->sys.L1Directory[ithCache].Dir_config[5] / this->clockRate;
+  this->missb_size = XML->sys.L1Directory[ithCache].buffer_sizes[0];
+  this->fu_size = XML->sys.L1Directory[ithCache].buffer_sizes[1];
+  this->prefetchb_size = XML->sys.L1Directory[ithCache].buffer_sizes[2];
+  this->wbb_size = XML->sys.L1Directory[ithCache].buffer_sizes[3];
+  this->duty_cycle = XML->sys.L1Directory[ithCache].duty_cycle;
+}
+
+void CacheDynParam::set_params_l2_directory(const ParseXML *XML,
+                                            const int ithCache) {
+  this->name = "Second Level Directory";
+  this->dir_ty = (enum Dir_type)XML->sys.L2Directory[ithCache].Directory_type;
+  this->clockRate = XML->sys.L2Directory[ithCache].clockrate;
+  this->clockRate *= 1e6;
+  this->executionTime =
+      XML->sys.total_cycles / (XML->sys.target_core_clockrate * 1e6);
+  this->capacity = XML->sys.L2Directory[ithCache].Dir_config[0];
+  this->blockW = XML->sys.L2Directory[ithCache].Dir_config[1];
+  this->assoc = XML->sys.L2Directory[ithCache].Dir_config[2];
+  this->nbanks = XML->sys.L2Directory[ithCache].Dir_config[3];
+  this->throughput =
+      XML->sys.L2Directory[ithCache].Dir_config[4] / this->clockRate;
+  this->latency =
+      XML->sys.L2Directory[ithCache].Dir_config[5] / this->clockRate;
+  this->missb_size = XML->sys.L2Directory[ithCache].buffer_sizes[0];
+  this->fu_size = XML->sys.L2Directory[ithCache].buffer_sizes[1];
+  this->prefetchb_size = XML->sys.L2Directory[ithCache].buffer_sizes[2];
+  this->wbb_size = XML->sys.L2Directory[ithCache].buffer_sizes[3];
+  this->duty_cycle = XML->sys.L2Directory[ithCache].duty_cycle;
+}