ruby: add stats to .sm files, remove cache profiler

This patch changes the way cache statistics are collected in ruby.

As of now, there is separate entity called CacheProfiler which holds
statistical variables for caches. The CacheMemory class defines different
functions for accessing the CacheProfiler. These functions are then invoked
in the .sm files. I find this approach opaque and prone to error. Secondly,
we probably should not be paying the cost of a function call for recording
statistics.

Instead, this patch allows for accessing statistical variables in the
.sm files. The collection would become transparent. Secondly, it would happen
in place, so no function calls. The patch also removes the CacheProfiler class.

--HG--
rename : src/mem/slicc/ast/InfixOperatorExprAST.py => src/mem/slicc/ast/OperatorExprAST.py

2 files changed, 100 insertions, 74 deletions

diff --git a/src/mem/ruby/system/CacheMemory.cc b/src/mem/ruby/system/CacheMemory.cc
index 81d73f5b4..f57c4c7ad 100644
--- a/src/mem/ruby/system/CacheMemory.cc
+++ b/src/mem/ruby/system/CacheMemory.cc
@@ -60,7 +60,6 @@ CacheMemory::CacheMemory(const Params *p)
     m_latency = p->latency;
     m_cache_assoc = p->assoc;
     m_policy = p->replacement_policy;
-    m_profiler_ptr = new CacheProfiler(name());
     m_start_index_bit = p->start_index_bit;
     m_is_instruction_only_cache = p->is_icache;
     m_resource_stalls = p->resourceStalls;
@@ -97,7 +96,6 @@ CacheMemory::~CacheMemory()
 {
     if (m_replacementPolicy_ptr != NULL)
         delete m_replacementPolicy_ptr;
-    delete m_profiler_ptr;
     for (int i = 0; i < m_cache_num_sets; i++) {
         for (int j = 0; j < m_cache_assoc; j++) {
             delete m_cache[i][j];
@@ -325,24 +323,6 @@ CacheMemory::setMRU(const Address& address)
 }
 
 void
-CacheMemory::profileMiss(const RubyRequest& msg)
-{
-    m_profiler_ptr->addCacheStatSample(msg.getType(), 
-                                       msg.getAccessMode(),
-                                       msg.getPrefetch());
-}
-
-void
-CacheMemory::profileGenericRequest(GenericRequestType requestType,
-                                   RubyAccessMode accessType,
-                                   PrefetchBit pfBit)
-{
-    m_profiler_ptr->addGenericStatSample(requestType, 
-                                         accessType, 
-                                         pfBit);
-}
-
-void
 CacheMemory::recordCacheContents(int cntrl, CacheRecorder* tr) const
 {
     uint64 warmedUpBlocks = 0;
@@ -407,18 +387,6 @@ CacheMemory::printData(ostream& out) const
 }
 
 void
-CacheMemory::clearStats() const
-{
-    m_profiler_ptr->clearStats();
-}
-
-void
-CacheMemory::printStats(ostream& out) const
-{
-    m_profiler_ptr->printStats(out);
-}
-
-void
 CacheMemory::setLocked(const Address& address, int context)
 {
     DPRINTF(RubyCache, "Setting Lock for addr: %x to %d\n", address, context);
@@ -453,63 +421,118 @@ CacheMemory::isLocked(const Address& address, int context)
 }
 
 void
-CacheMemory::recordRequestType(CacheRequestType requestType) {
-    DPRINTF(RubyStats, "Recorded statistic: %s\n",
-            CacheRequestType_to_string(requestType));
-    switch(requestType) {
-    case CacheRequestType_DataArrayRead:
-        numDataArrayReads++;
-        return;
-    case CacheRequestType_DataArrayWrite:
-        numDataArrayWrites++;
-        return;
-    case CacheRequestType_TagArrayRead:
-        numTagArrayReads++;
-        return;
-    case CacheRequestType_TagArrayWrite:
-        numTagArrayWrites++;
-        return;
-    default:
-        warn("CacheMemory access_type not found: %s",
-             CacheRequestType_to_string(requestType));
-    }
-}
+CacheMemory::regStats()
+{
+    m_demand_hits
+        .name(name() + ".demand_hits")
+        .desc("Number of cache demand hits")
+        ;
 
-void
-CacheMemory::regStats() {
-    using namespace Stats;
+    m_demand_misses
+        .name(name() + ".demand_misses")
+        .desc("Number of cache demand misses")
+        ;
+
+    m_demand_accesses
+        .name(name() + ".demand_accesses")
+        .desc("Number of cache demand accesses")
+        ;
+
+    m_demand_accesses = m_demand_hits + m_demand_misses;
+
+    m_sw_prefetches
+        .name(name() + ".total_sw_prefetches")
+        .desc("Number of software prefetches")
+        .flags(Stats::nozero)
+        ;
+
+    m_hw_prefetches
+        .name(name() + ".total_hw_prefetches")
+        .desc("Number of hardware prefetches")
+        .flags(Stats::nozero)
+        ;
+
+    m_prefetches
+        .name(name() + ".total_prefetches")
+        .desc("Number of prefetches")
+        .flags(Stats::nozero)
+        ;
+
+    m_prefetches = m_sw_prefetches + m_hw_prefetches;
+
+    m_accessModeType
+        .init(RubyRequestType_NUM)
+        .name(name() + ".access_mode")
+        .flags(Stats::pdf | Stats::total)
+        ;
+    for (int i = 0; i < RubyAccessMode_NUM; i++) {
+        m_accessModeType
+            .subname(i, RubyAccessMode_to_string(RubyAccessMode(i)))
+            .flags(Stats::nozero)
+            ;
+    }
 
     numDataArrayReads
         .name(name() + ".num_data_array_reads")
         .desc("number of data array reads")
+        .flags(Stats::nozero)
         ;
 
     numDataArrayWrites
         .name(name() + ".num_data_array_writes")
         .desc("number of data array writes")
+        .flags(Stats::nozero)
         ;
 
     numTagArrayReads
         .name(name() + ".num_tag_array_reads")
         .desc("number of tag array reads")
+        .flags(Stats::nozero)
         ;
 
     numTagArrayWrites
         .name(name() + ".num_tag_array_writes")
         .desc("number of tag array writes")
+        .flags(Stats::nozero)
         ;
 
     numTagArrayStalls
         .name(name() + ".num_tag_array_stalls")
         .desc("number of stalls caused by tag array")
+        .flags(Stats::nozero)
         ;
 
     numDataArrayStalls
         .name(name() + ".num_data_array_stalls")
         .desc("number of stalls caused by data array")
+        .flags(Stats::nozero)
         ;
 }
 
+void
+CacheMemory::recordRequestType(CacheRequestType requestType)
+{
+    DPRINTF(RubyStats, "Recorded statistic: %s\n",
+            CacheRequestType_to_string(requestType));
+    switch(requestType) {
+    case CacheRequestType_DataArrayRead:
+        numDataArrayReads++;
+        return;
+    case CacheRequestType_DataArrayWrite:
+        numDataArrayWrites++;
+        return;
+    case CacheRequestType_TagArrayRead:
+        numTagArrayReads++;
+        return;
+    case CacheRequestType_TagArrayWrite:
+        numTagArrayWrites++;
+        return;
+    default:
+        warn("CacheMemory access_type not found: %s",
+             CacheRequestType_to_string(requestType));
+    }
+}
+
 bool
 CacheMemory::checkResourceAvailable(CacheResourceType res, Address addr)
 {
@@ -520,14 +543,18 @@ CacheMemory::checkResourceAvailable(CacheResourceType res, Address addr)
     if (res == CacheResourceType_TagArray) {
         if (tagArray.tryAccess(addressToCacheSet(addr))) return true;
         else {
-            DPRINTF(RubyResourceStalls, "Tag array stall on addr %s in set %d\n", addr, addressToCacheSet(addr));
+            DPRINTF(RubyResourceStalls,
+                    "Tag array stall on addr %s in set %d\n",
+                    addr, addressToCacheSet(addr));
             numTagArrayStalls++;
             return false;
         }
     } else if (res == CacheResourceType_DataArray) {
         if (dataArray.tryAccess(addressToCacheSet(addr))) return true;
         else {
-            DPRINTF(RubyResourceStalls, "Data array stall on addr %s in set %d\n", addr, addressToCacheSet(addr));
+            DPRINTF(RubyResourceStalls,
+                    "Data array stall on addr %s in set %d\n",
+                    addr, addressToCacheSet(addr));
             numDataArrayStalls++;
             return false;
         }
diff --git a/src/mem/ruby/system/CacheMemory.hh b/src/mem/ruby/system/CacheMemory.hh
index 8aca250b3..db9e00e21 100644
--- a/src/mem/ruby/system/CacheMemory.hh
+++ b/src/mem/ruby/system/CacheMemory.hh
@@ -36,10 +36,8 @@
 #include "base/statistics.hh"
 #include "mem/protocol/CacheResourceType.hh"
 #include "mem/protocol/CacheRequestType.hh"
-#include "mem/protocol/GenericRequestType.hh"
 #include "mem/protocol/RubyRequest.hh"
 #include "mem/ruby/common/DataBlock.hh"
-#include "mem/ruby/profiler/CacheProfiler.hh"
 #include "mem/ruby/recorder/CacheRecorder.hh"
 #include "mem/ruby/slicc_interface/AbstractCacheEntry.hh"
 #include "mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh"
@@ -100,34 +98,37 @@ class CacheMemory : public SimObject
     // Set this address to most recently used
     void setMRU(const Address& address);
 
-    void profileMiss(const RubyRequest & msg);
-
-    void profileGenericRequest(GenericRequestType requestType,
-                               RubyAccessMode accessType,
-                               PrefetchBit pfBit);
-
     void setLocked (const Address& addr, int context);
     void clearLocked (const Address& addr);
     bool isLocked (const Address& addr, int context);
+
     // Print cache contents
     void print(std::ostream& out) const;
     void printData(std::ostream& out) const;
 
-    void clearStats() const;
-    void printStats(std::ostream& out) const;
-
-    void recordRequestType(CacheRequestType requestType);
     void regStats();
+    bool checkResourceAvailable(CacheResourceType res, Address addr);
+    void recordRequestType(CacheRequestType requestType);
+
+  public:
+    Stats::Scalar m_demand_hits;
+    Stats::Scalar m_demand_misses;
+    Stats::Formula m_demand_accesses;
+
+    Stats::Scalar m_sw_prefetches;
+    Stats::Scalar m_hw_prefetches;
+    Stats::Formula m_prefetches;
+
+    Stats::Vector m_accessModeType;
 
     Stats::Scalar numDataArrayReads;
     Stats::Scalar numDataArrayWrites;
     Stats::Scalar numTagArrayReads;
     Stats::Scalar numTagArrayWrites;
 
-    bool checkResourceAvailable(CacheResourceType res, Address addr);
-
     Stats::Scalar numTagArrayStalls;
     Stats::Scalar numDataArrayStalls;
+
   private:
     // convert a Address to its location in the cache
     Index addressToCacheSet(const Address& address) const;
@@ -156,8 +157,6 @@ class CacheMemory : public SimObject
 
     AbstractReplacementPolicy *m_replacementPolicy_ptr;
 
-    CacheProfiler* m_profiler_ptr;
-
     BankedArray dataArray;
     BankedArray tagArray;