Make a new stat type of Value which is a scalar stat that
authorNathan Binkert <binkertn@umich.edu>
Wed, 12 May 2004 19:49:01 +0000 (15:49 -0400)
committerNathan Binkert <binkertn@umich.edu>
Wed, 12 May 2004 19:49:01 +0000 (15:49 -0400)
proxies for a real C/C++ scalar value or scalar functor.
This replaces the scalar() and functor() terms that were
previously used in formulas.  This helps when dumping
statistics because the formulas are not supposed to change.

cpu/base_cpu.cc:
    Add a number of cycles stat to the cpu object that tracks the
    number of cycles that the cpu has executed.  This starts to pave
    the way for cpu cycles being different from event ticks.
cpu/base_cpu.hh:
    provide a functor for calculating all simulated instructions
    of all CPUs and a virtual function for determining that number.
    To deal with the change from functor() to Value::functor()
cpu/simple_cpu/simple_cpu.cc:
    simTicks -> numCycles
    numInsts is now a real Scalar stat, not a Formula
cpu/simple_cpu/simple_cpu.hh:
    numInsts is now a real Scalar stat, not a Formula
    count all instructions
sim/stat_control.cc:
    simInsts, simTicks, hostMemory, and hostSeconds are no
    longer Statistics::Formula but rather Statistics::Value
    add new stat for tick frequency
sim/stats.hh:
    don't need everything to be extern.
test/Makefile:
    Make stuff work a tad bit better
test/stattest.cc:
    test out Statistics::Value

--HG--
extra : convert_revision : c812e8baa2b17c08abf3a68ed1e1125dc6f2cfb4

base/statistics.hh
cpu/base_cpu.cc
cpu/base_cpu.hh
cpu/simple_cpu/simple_cpu.cc
cpu/simple_cpu/simple_cpu.hh
sim/stat_control.cc
sim/stats.hh
test/Makefile
test/stattest.cc

index e7fc18d74ecf2b1034094388fb2863586164ddc9..ee09cc62248ccc8fdaea795073b824b375aa3e94 100644 (file)
@@ -139,11 +139,13 @@ struct StatData
     static bool less(StatData *stat1, StatData *stat2);
 };
 
-struct ScalarData : public StatData
+class ScalarData : public StatData
 {
+  public:
     virtual Counter value() const = 0;
     virtual Result result() const = 0;
     virtual Result total() const = 0;
+    virtual void visit(Visit &visitor) { visitor.visit(*this); }
 };
 
 template <class Stat>
@@ -162,8 +164,6 @@ class ScalarStatData : public ScalarData
     virtual Result total() const { return s.total(); }
     virtual void reset() { s.reset(); }
     virtual bool zero() const { return s.zero(); }
-
-    virtual void visit(Visit &visitor) { visitor.visit(*this); }
 };
 
 struct VectorData : public StatData
@@ -394,6 +394,16 @@ class Wrap : public Child
         return ptr;
     }
 
+  protected:
+    /**
+     * Copy constructor, copies are not allowed.
+     */
+    Wrap(const Wrap &stat);
+    /**
+     * Can't copy stats.
+     */
+    void operator=(const Wrap &);
+
   public:
     Wrap()
     {
@@ -726,16 +736,6 @@ class ScalarBase : public DataAccess
         return _bin->data(*_params);
     }
 
-  protected:
-    /**
-     * Copy constructor, copies are not allowed.
-     */
-    ScalarBase(const ScalarBase &stat);
-    /**
-     * Can't copy stats.
-     */
-    const ScalarBase &operator=(const ScalarBase &);
-
   public:
     /**
      * Return the current value of this stat as its base type.
@@ -822,6 +822,79 @@ class ScalarBase : public DataAccess
 
 };
 
+class ProxyData : public ScalarData
+{
+  public:
+    virtual void visit(Visit &visitor) { visitor.visit(*this); }
+    virtual bool binned() const { return false; }
+    virtual std::string str() const { return to_string(value()); }
+    virtual size_t size() const { return 1; }
+    virtual bool zero() const { return value() == 0; }
+    virtual bool check() const { return true; }
+    virtual void reset() { }
+};
+
+template <class T>
+class ValueProxy : public ProxyData
+{
+  private:
+    T *scalar;
+
+  public:
+    ValueProxy(T &val) : scalar(&val) {}
+    virtual Counter value() const { return *scalar; }
+    virtual Result result() const { return *scalar; }
+    virtual Result total() const { return *scalar; }
+};
+
+template <class T>
+class FunctorProxy : public ProxyData
+{
+  private:
+    T *functor;
+
+  public:
+    FunctorProxy(T &func) : functor(&func) {}
+    virtual Counter value() const { return (*functor)(); }
+    virtual Result result() const { return (*functor)(); }
+    virtual Result total() const { return (*functor)(); }
+};
+
+class ValueBase : public DataAccess
+{
+  private:
+    ProxyData *proxy;
+
+  public:
+    ValueBase() : proxy(NULL) { }
+    ~ValueBase() { if (proxy) delete proxy; }
+
+    template <class T>
+    void scalar(T &value)
+    {
+        proxy = new ValueProxy<T>(value);
+        setInit();
+    }
+
+    template <class T>
+    void functor(T &func)
+    {
+        proxy = new FunctorProxy<T>(func);
+        setInit();
+    }
+
+    Counter value() { return proxy->value(); }
+    Result result() const { return proxy->result(); }
+    Result total() const { return proxy->total(); };
+    size_t size() const { return proxy->size(); }
+
+    bool binned() const { return proxy->binned(); }
+    std::string str() const { return proxy->str(); }
+    bool zero() const { return proxy->zero(); }
+    bool check() const { return proxy != NULL; }
+    void reset() { }
+};
+
 //////////////////////////////////////////////////////////////////////
 //
 // Vector Statistics
@@ -869,13 +942,6 @@ class VectorBase : public DataAccess
         return _bin->data(index, *_params);
     }
 
-  protected:
-    // Copying stats is not allowed
-    /** Copying stats isn't allowed. */
-    VectorBase(const VectorBase &stat);
-    /** Copying stats isn't allowed. */
-    const VectorBase &operator=(const VectorBase &);
-
   public:
     void value(VCounter &vec) const
     {
@@ -1127,11 +1193,6 @@ class Vector2dBase : public DataAccess
         return _bin->data(index, *_params);
     }
 
-  protected:
-    // Copying stats is not allowed
-    Vector2dBase(const Vector2dBase &stat);
-    const Vector2dBase &operator=(const Vector2dBase &);
-
   public:
     Vector2dBase() {}
 
@@ -1586,13 +1647,6 @@ class DistBase : public DataAccess
         return _bin->data(*_params);
     }
 
-  protected:
-    // Copying stats is not allowed
-    /** Copies are not allowed. */
-    DistBase(const DistBase &stat);
-    /** Copies are not allowed. */
-    const DistBase &operator=(const DistBase &);
-
   public:
     DistBase() { }
 
@@ -1659,11 +1713,6 @@ class VectorDistBase : public DataAccess
         return _bin->data(index, *_params);
     }
 
-  protected:
-    // Copying stats is not allowed
-    VectorDistBase(const VectorDistBase &stat);
-    const VectorDistBase &operator=(const VectorDistBase &);
-
   public:
     VectorDistBase() {}
 
@@ -1910,56 +1959,6 @@ class ConstNode : public Node
     virtual std::string str() const { return to_string(vresult[0]); }
 };
 
-template <class T>
-class FunctorNode : public Node
-{
-  private:
-    T &functor;
-    mutable VResult vresult;
-
-  public:
-    FunctorNode(T &f) : functor(f) { vresult.resize(1); }
-    const VResult &result() const
-    {
-        vresult[0] = (Result)functor();
-        return vresult;
-    }
-    virtual Result total() const { return (Result)functor(); };
-
-    virtual size_t size() const { return 1; }
-    /**
-     * Return true if stat is binned.
-     *@return False since Functors aren't binned
-     */
-    virtual bool binned() const { return false; }
-    virtual std::string str() const { return to_string(functor()); }
-};
-
-template <class T>
-class ScalarNode : public Node
-{
-  private:
-    T &scalar;
-    mutable VResult vresult;
-
-  public:
-    ScalarNode(T &s) : scalar(s) { vresult.resize(1); }
-    const VResult &result() const
-    {
-        vresult[0] = (Result)scalar;
-        return vresult;
-    }
-    virtual Result total() const { return (Result)scalar; };
-
-    virtual size_t size() const { return 1; }
-    /**
-     * Return true if stat is binned.
-     *@return False since Scalar's aren't binned
-     */
-    virtual bool binned() const { return false; }
-    virtual std::string str() const { return to_string(scalar); }
-};
-
 template <class Op>
 struct OpString;
 
@@ -2219,6 +2218,30 @@ class Scalar
     void operator=(const U &v) { Base::operator=(v); }
 };
 
+class Value
+    : public Wrap<Value,
+                  ValueBase,
+                  ScalarStatData>
+{
+  public:
+    /** The base implementation. */
+    typedef ValueBase Base;
+
+    template <class T>
+    Value &scalar(T &value)
+    {
+        Base::scalar(value);
+        return *this;
+    }
+
+    template <class T>
+    Value &functor(T &func)
+    {
+        Base::functor(func);
+        return *this;
+    }
+};
+
 /**
  * A stat that calculates the per cycle average of a value.
  * @sa Stat, ScalarBase, AvgStor
@@ -2694,6 +2717,13 @@ class Temp
     Temp(const Scalar<Bin> &s)
         : node(new ScalarStatNode(s.statData())) { }
 
+    /**
+     * Create a new ScalarStatNode.
+     * @param s The ScalarStat to place in a node.
+     */
+    Temp(const Value &s)
+        : node(new ScalarStatNode(s.statData())) { }
+
     /**
      * Create a new ScalarStatNode.
      * @param s The ScalarStat to place in a node.
@@ -2861,20 +2891,6 @@ constant(T val)
     return NodePtr(new ConstNode<T>(val));
 }
 
-template <typename T>
-inline Temp
-functor(T &val)
-{
-    return NodePtr(new FunctorNode<T>(val));
-}
-
-template <typename T>
-inline Temp
-scalar(T &val)
-{
-    return NodePtr(new ScalarNode<T>(val));
-}
-
 inline Temp
 sum(Temp val)
 {
index e00de838945952fa45e0ce25089d6c7d5ff64ee4..624023f0afe4e6a6859bd0cdc9f3d40faddf5ec0 100644 (file)
@@ -130,6 +130,13 @@ BaseCPU::BaseCPU(const string &_name, int _number_of_threads,
 void
 BaseCPU::regStats()
 {
+    using namespace Statistics;
+
+    numCycles
+        .name(name() + ".numCycles")
+        .desc("number of cpu cycles simulated")
+        ;
+
     int size = execContexts.size();
     if (size > 1) {
         for (int i = 0; i < size; ++i) {
index 64803573234d8693f6777463dc5dd7434c86f805..c4826cf15e36ce17a944b4923ee19cc872fd7327 100644 (file)
 
 #include <vector>
 
+#include "base/statistics.hh"
 #include "sim/eventq.hh"
 #include "sim/sim_object.hh"
-
-#include "targetarch/isa_traits.hh"    // for Addr
+#include "targetarch/isa_traits.hh"
 
 #ifdef FULL_SYSTEM
 class System;
@@ -147,11 +147,27 @@ class BaseCPU : public SimObject
      */
     virtual BranchPred *getBranchPred() { return NULL; };
 
+    virtual Counter totalInstructions() const { return 0; }
+
   private:
     static std::vector<BaseCPU *> cpuList;   //!< Static global cpu list
 
   public:
     static int numSimulatedCPUs() { return cpuList.size(); }
+    static Counter numSimulatedInstructions()
+    {
+        Counter total = 0;
+
+        int size = cpuList.size();
+        for (int i = 0; i < size; ++i)
+            total += cpuList[i]->totalInstructions();
+
+        return total;
+    }
+
+  public:
+    // Number of CPU cycles simulated
+    Statistics::Scalar<> numCycles;
 };
 
 #endif // __BASE_CPU_HH__
index 0651408836cda5355eaccbe1ffaa60a1125fe337..56ea0ae118ec1ab93cfabf325268c00072ff6f88 100644 (file)
@@ -287,8 +287,6 @@ SimpleCPU::regStats()
         ;
 
     idleFraction = constant(1.0) - notIdleFraction;
-    numInsts = Statistics::scalar(numInst) - Statistics::scalar(startNumInst);
-    simInsts += numInsts;
 }
 
 void
@@ -590,6 +588,8 @@ SimpleCPU::post_interrupt(int int_num, int index)
 void
 SimpleCPU::tick()
 {
+    numCycles++;
+
     traceData = NULL;
 
     Fault fault = No_Fault;
@@ -697,6 +697,7 @@ SimpleCPU::tick()
 
         // keep an instruction count
         numInst++;
+        numInsts++;
 
         // check for instruction-count-based events
         comInstEventQueue[0]->serviceEvents(numInst);
index 4977e69923e6c158eed7bb9715a3c707e66ee0fc..07d6cb0c961a840f904ba7e1d94305701f69ad97 100644 (file)
@@ -204,7 +204,12 @@ class SimpleCPU : public BaseCPU
     // number of simulated instructions
     Counter numInst;
     Counter startNumInst;
-    Statistics::Formula numInsts;
+    Statistics::Scalar<> numInsts;
+
+    virtual Counter totalInstructions() const
+    {
+        return numInst - startNumInst;
+    }
 
     // number of simulated memory references
     Statistics::Scalar<> numMemRefs;
index d6d7e2c91939b1433e4a9423f7322a3ef7800be9..c7d2fdd5bc878e2537ed3098c94d24364a7d5291 100644 (file)
@@ -39,6 +39,7 @@
 #include "base/str.hh"
 #include "base/time.hh"
 #include "base/stats/output.hh"
+#include "cpu/base_cpu.hh"
 #include "sim/eventq.hh"
 #include "sim/sim_object.hh"
 #include "sim/stat_control.hh"
 using namespace std;
 
 Statistics::Formula hostInstRate;
-Statistics::Formula hostMemory;
-Statistics::Formula hostSeconds;
 Statistics::Formula hostTickRate;
+Statistics::Value hostMemory;
+Statistics::Value hostSeconds;
 
-Statistics::Formula simInsts;
+Statistics::Value simTicks;
+Statistics::Value simInsts;
+Statistics::Value simFreq;
 Statistics::Formula simSeconds;
-Statistics::Formula simTicks;
 
 namespace Statistics {
 
@@ -84,6 +86,7 @@ void
 InitSimStats()
 {
     simInsts
+        .functor(BaseCPU::numSimulatedInstructions)
         .name("sim_insts")
         .desc("Number of instructions simulated")
         .precision(0)
@@ -95,7 +98,14 @@ InitSimStats()
         .desc("Number of seconds simulated")
         ;
 
+    simFreq
+        .scalar(ticksPerSecond)
+        .name("sim_freq")
+        .desc("Frequency of simulated ticks")
+        ;
+
     simTicks
+        .scalar(curTick)
         .name("sim_ticks")
         .desc("Number of ticks simulated")
         ;
@@ -108,12 +118,14 @@ InitSimStats()
         ;
 
     hostMemory
+        .functor(memUsage)
         .name("host_mem_usage")
         .desc("Number of bytes of host memory used")
         .prereq(hostMemory)
         ;
 
     hostSeconds
+        .functor(statElapsedTime)
         .name("host_seconds")
         .desc("Real time elapsed on the host")
         .precision(2)
@@ -125,11 +137,7 @@ InitSimStats()
         .precision(0)
         ;
 
-    simInsts = constant(0);
-    simTicks = scalar(curTick) - scalar(startTick);
-    simSeconds = simTicks / scalar(ticksPerSecond);
-    hostMemory = functor(memUsage);
-    hostSeconds = functor(statElapsedTime);
+    simSeconds = simTicks / simFreq;
     hostInstRate = simInsts / hostSeconds;
     hostTickRate = simTicks / hostSeconds;
 
index b736850e7d4b1d2621cebd23c411f2129379b51c..c5e791cfb3af525728ad1f1f1e238e75163d8590 100644 (file)
 
 #include "base/statistics.hh"
 
-extern Statistics::Formula simTicks;
 extern Statistics::Formula simSeconds;
-extern Statistics::Formula simInsts;
-extern Statistics::Formula hostSeconds;
-extern Statistics::Formula hostTickRate;
-extern Statistics::Formula hostInstRate;
+extern Statistics::Value simTicks;
 
 #endif // __SIM_SIM_STATS_HH__
index bf4200ba3d2360da20beeb852acb309a6ae71f21..15019a1f54fca3a14d1137bfb502b5ed0c04d925 100644 (file)
@@ -2,18 +2,24 @@
 
 CC?= gcc
 CXX?= g++
+PYTHON?=/usr/bin/env python
 
 CURDIR?= $(shell /bin/pwd)
-SRCDIR?= ..
+SRCDIR?= $(CURDIR)/..
 
 CCFLAGS= -g -O0 -MMD -I. -I$(SRCDIR) -I- -DTRACING_ON=0
 MYSQL= -I/usr/include/mysql -L/usr/lib/mysql -lmysqlclient
 
-VPATH=$(SRCDIR)
+VPATH=$(SRCDIR):$(CURDIR)
 
 default:
        @echo "You must specify a target"
 
+base/traceflags.cc base/traceflags.hh: $(SRCDIR)/base/traceflags.py
+       mkdir -p base; \
+       cd base; \
+       $(PYTHON) $<
+
 bitvectest: test/bitvectest.cc
        $(CXX) $(CCFLAGS) -o $@ $^
 
@@ -61,5 +67,5 @@ tracetest: $(TRACE)
        $(CXX) $(CCFLAGS) -o $@ $^
 
 clean:
-       @rm -f *test *~ .#* *.core core
+       @rm -rf *test *~ .#* *.core core base
 .PHONY: clean
index 7bf355c0eb57c021cb36e76c3d0a571108f0d028..9b7ba98579a902b20ec5a26733952e251f968e2a 100644 (file)
@@ -66,8 +66,8 @@ Vector2d<> s16;
 Formula f1;
 Formula f2;
 Formula f3;
-Formula f4;
-Formula f5;
+Value f4;
+Value f5;
 Formula f6;
 Formula f7;
 
@@ -279,11 +279,14 @@ main(int argc, char *argv[])
         ;
 
     f4
+        .functor(testfunc)
         .name("Formula4")
         .desc("this is formula 4")
         ;
 
+    TestClass testclass;
     f5
+        .functor(testclass)
         .name("Formula5")
         .desc("this is formula 5")
         ;
@@ -296,9 +299,6 @@ main(int argc, char *argv[])
     f1 = s1 + s2;
     f2 = (-s1) / (-s2) * (-s3 + ULL(100) + s4);
     f3 = sum(s5) * s7;
-    f4 = functor(testfunc);
-    TestClass testclass;
-    f5 = functor(testclass);
     f6 += constant(10.0);
     f6 += s5[3];
     f7 = constant(1);