adding statistic metrics gathering functions for upstream SST inclusion

Author: jleidel

DRAMSim.h

@@ -37,16 +37,16 @@
 
 using std::string;
 
-namespace DRAMSim 
+namespace DRAMSim
 {
-  class MultiChannelMemorySystem 
+  class MultiChannelMemorySystem
   {
-    public: 
+    public:
       bool addTransaction(bool isWrite, uint64_t addr);
       void update();
       void printStats(bool finalStats);
-      bool willAcceptTransaction(); 
-      bool willAcceptTransaction(uint64_t addr); 
+      bool willAcceptTransaction();
+      bool willAcceptTransaction(uint64_t addr);
 
       void RegisterCallbacks(TransactionCompleteCB *readDone, TransactionCompleteCB *writeDone);
   };

MemoryController.cpp

@@ -647,6 +647,96 @@ void MemoryController::resetStats()
   }
 }
 
+//retrieves the target 'metric' stat and returns the value as a double in *stat
+bool MemoryController::getStats( double *stat, DSIM_STAT metric ){
+  double totalBandwidth=0.0;
+  uint64_t cyclesElapsed =
+    (currentClockCycle % EPOCH_LENGTH == 0) ? EPOCH_LENGTH : currentClockCycle % EPOCH_LENGTH;
+  unsigned bytesPerTransaction = JEDEC_DATA_BUS_BITS*BL/8;
+  double secondsThisEpoch = (double)cyclesElapsed * tCK * 1E-9;
+  vector<double> bandwidth = vector<double>(NUM_RANKS*NUM_BANKS,0.0);
+
+  switch( metric ){
+  case TOTAL_BANDWIDTH:
+    for (unsigned i = 0; i < NUM_RANKS; ++i) {
+      for (unsigned j = 0; j < NUM_BANKS; ++j) {
+        bandwidth[SEQUENTIAL(i,j)] =
+          (((double)(totalReadsPerBank[SEQUENTIAL(i,j)] +
+                     totalWritesPerBank[SEQUENTIAL(i,j)]) *
+            (double)bytesPerTransaction)/(1024.0*1024.0*1024.0)) /
+          secondsThisEpoch;
+        totalBandwidth += bandwidth[SEQUENTIAL(i,j)];
+      }
+    }
+    *stat = totalBandwidth;
+    return true;
+    break;
+  case TOTAL_TRANSACTIONS:
+  case TOTAL_BYTES_TRANSFERRED:
+  case TOTAL_READS:
+  case TOTAL_WRITES:
+  case PENDING_READ_TRANSACTIONS:
+  case PENDING_RTN_TRANSACTIONS:
+  default:
+    // none of these are double values
+    return false;
+    break;
+  }
+}
+
+//retrieves the target 'metric' stat and returns the value as a uint64_t in *stat
+bool MemoryController::getStats( uint64_t *stat, DSIM_STAT metric ){
+  unsigned bytesPerTransaction = JEDEC_DATA_BUS_BITS*BL/8;
+  uint64_t totalReads = 0x00ull;
+  uint64_t totalWrites = 0x00ull;
+
+  switch( metric ){
+  case TOTAL_BYTES_TRANSFERRED:
+    if (operationMode == PseudoChannelMode)
+      bytesPerTransaction /= 2;
+
+    *stat = (uint64_t)(totalTransactions * bytesPerTransaction);
+    return true;
+    break;
+  case TOTAL_READS:
+    for (unsigned i = 0; i < NUM_RANKS; ++i) {
+      for (unsigned j = 0; j < NUM_BANKS; ++j) {
+        totalReads += totalReadsPerBank[SEQUENTIAL(i,j)];
+        totalWritesPerRank[i] += totalWritesPerBank[SEQUENTIAL(i,j)];
+      }
+    }
+    *stat = totalReads;
+    return true;
+    break;
+  case TOTAL_WRITES:
+    for (unsigned i = 0; i < NUM_RANKS; ++i) {
+      for (unsigned j = 0; j < NUM_BANKS; ++j) {
+        totalWrites += totalWritesPerBank[SEQUENTIAL(i,j)];
+      }
+    }
+    *stat = totalWrites;
+    return true;
+    break;
+  case TOTAL_TRANSACTIONS:
+    *stat = (uint64_t)(transactionQueue.size());
+    return true;
+    break;
+  case PENDING_READ_TRANSACTIONS:
+    *stat = (uint64_t)(pendingReadTransactions.size());
+    return true;
+    break;
+  case PENDING_RTN_TRANSACTIONS:
+    *stat = (uint64_t)(returnTransaction.size());
+    return true;
+    break;
+  case TOTAL_BANDWIDTH:
+  default:
+    // none of these are double values
+    return false;
+    break;
+  }
+}
+
 //prints statistics at the end of an epoch or  simulation
 void MemoryController::printStats(bool finalStats)
 {

MemoryController.h

@@ -45,6 +45,17 @@
 
 using namespace std;
 
+// stats enumerated types
+typedef enum{
+  TOTAL_TRANSACTIONS,
+  TOTAL_BYTES_TRANSFERRED,
+  TOTAL_BANDWIDTH,
+  TOTAL_READS,
+  TOTAL_WRITES,
+  PENDING_READ_TRANSACTIONS,
+  PENDING_RTN_TRANSACTIONS
+}DSIM_STAT;
+
 namespace DRAMSim
 {
 #ifdef DEBUG_LATENCY
@@ -92,7 +103,11 @@ class MemoryController : public SimulatorObject
   void updateBankStates();
   void update();
   void printStats(bool finalStats = false);
-  void resetStats(); 
+  void resetStats();
+
+  // retrieve the target stats entry 'metric' in 'stat'
+  bool getStats( double *stat, DSIM_STAT metric );
+  bool getStats( uint64_t *stat, DSIM_STAT metric );
 
 public:
   vector<Transaction*> transactionQueue;

MemorySystem.cpp

@@ -117,6 +117,14 @@ bool MemorySystem::addTransaction(bool isWrite, uint64_t addr)
   }
 }
 
+bool MemorySystem::getStats( double *stat, DSIM_STAT metric ){
+  return memoryController->getStats(stat, metric);
+}
+
+bool MemorySystem::getStats( uint64_t *stat, DSIM_STAT metric ){
+  return memoryController->getStats(stat, metric);
+}
+
 void MemorySystem::printStats(bool finalStats)
 {
   memoryController->printStats(finalStats);

MemorySystem.h

@@ -53,6 +53,9 @@ class MemorySystem : public SimulatorObject
     bool WillAcceptTransaction();
     void RegisterCallbacks(Callback_t *readDone, Callback_t *writeDone);
 
+    bool getStats( double *stat, DSIM_STAT metric );
+    bool getStats( uint64_t *stat, DSIM_STAT metric );
+
   public:
     Callback_t* ReturnReadData;
     Callback_t* WriteDataDone;

MultiChannelMemorySystem.cpp

@@ -122,6 +122,34 @@ bool MultiChannelMemorySystem::willAcceptTransaction(uint64_t addr)
   return channels[chan]->WillAcceptTransaction();
 }
 
+bool MultiChannelMemorySystem::getStats( double *stat, DSIM_STAT metric ){
+  double value = 0.;
+  double total = 0.;
+  for (unsigned i = 0; i < NUM_CHANS; ++i){
+    if( channels[i]->getStats( &value, metric ) ){
+      total += value;
+      value = 0.;
+    }else{
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MultiChannelMemorySystem::getStats( uint64_t *stat, DSIM_STAT metric ){
+  uint64_t value = 0.;
+  uint64_t total = 0.;
+  for (unsigned i = 0; i < NUM_CHANS; ++i){
+    if( channels[i]->getStats( &value, metric ) ){
+      total += value;
+      value = 0.;
+    }else{
+      return false;
+    }
+  }
+  return true;
+}
+
 void MultiChannelMemorySystem::printStats(bool finalStats) 
 {
   for (unsigned i = 0; i < NUM_CHANS; ++i) {

MultiChannelMemorySystem.h

@@ -47,6 +47,9 @@ class MultiChannelMemorySystem : public SimulatorObject
     void printStats(bool finalStats=false);
     void RegisterCallbacks(TransactionCompleteCB *readDone, TransactionCompleteCB *writeDone);
 
+    bool getStats( double *stat, DSIM_STAT metric );
+    bool getStats( uint64_t *stat, DSIM_STAT metric );
+
   private:
     unsigned findChannelNumber(uint64_t addr);