Statistics: Add a function to configure periodic stats dumping

This patch adds a function, periodicStatDump(long long period), which will dump
and reset the statistics every period. This function is designed to be called
from the python configuration scripts. This allows the periodic stats dumping to
be configured more easilly at run time.

The period is currently specified as a long long as there are issues passing
Tick into the C++ from the python as they have conflicting definitions. If the
period is less than curTick, the first occurance occurs at curTick. If the
period is set to 0, then the event is descheduled and the stats are not
periodically dumped.

Due to issues when resumung from a checkpoint, the StatDump event must be moved
forward such that it occues AFTER the current tick. As the function is called
from the python, the event is scheduled before the system resumes from the
checkpoint. Therefore, the event is moved using the updateEvents() function.
This is called from simulate.py once the system has resumed from the checkpoint.

NOTE: It should be noted that this is a fairly temporary patch which re-adds the
capability to extract temporal information  from the communication monitors. It
should not be used at the same time as anything that relies on dumping the
statistics based on in simulation events i.e. a context switch.

1 files changed, 66 insertions, 2 deletions

diff --git a/src/sim/stat_control.cc b/src/sim/stat_control.cc
index 965c081ee..2b47ded8d 100644
--- a/src/sim/stat_control.cc
+++ b/src/sim/stat_control.cc
@@ -1,4 +1,16 @@
 /*
+ * Copyright (c) 2012 ARM Limited
+ * All rights reserved
+ *
+ * The license below extends only to copyright in the software and shall
+ * not be construed as granting a license to any other intellectual
+ * property including but not limited to intellectual property relating
+ * to a hardware implementation of the functionality of the software
+ * licensed hereunder.  You may use the software subject to the license
+ * terms below provided that you ensure that this notice is replicated
+ * unmodified and in its entirety in all distributions of the software,
+ * modified or unmodified, in source code or in binary form.
+ *
  * Copyright (c) 2004-2005 The Regents of The University of Michigan
  * All rights reserved.
  *
@@ -26,6 +38,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Authors: Nathan Binkert
+ *          Sascha Bischoff
  */
 
 // This file will contain default statistics for the simulator that
@@ -61,6 +74,8 @@ namespace Stats {
 Time statTime(true);
 Tick startTick;
 
+Event *dumpEvent;
+
 struct SimTicksReset : public Callback
 {
     void process()
@@ -198,6 +213,9 @@ initSimStats()
     static Global global;
 }
 
+/**
+ * Event to dump and/or reset the statistics.
+ */
 class StatEvent : public Event
 {
   private:
@@ -230,8 +248,54 @@ class StatEvent : public Event
 void
 schedStatEvent(bool dump, bool reset, Tick when, Tick repeat)
 {
-    Event *event = new StatEvent(dump, reset, repeat);
-    mainEventQueue.schedule(event, when);
+    dumpEvent = new StatEvent(dump, reset, repeat);
+    mainEventQueue.schedule(dumpEvent, when);
+}
+
+void
+periodicStatDump(uint64_t period)
+{
+    /*
+     * If the period is set to 0, then we do not want to dump periodically,
+     * thus we deschedule the event. Else, if the period is not 0, but the event
+     * has already been scheduled, we need to get rid of the old event before we
+     * create a new one, as the old event will no longer be moved forward in the
+     * event that we resume from a checkpoint.
+     */
+    if (dumpEvent != NULL && (period == 0 || dumpEvent->scheduled())) {
+        // Event should AutoDelete, so we do not need to free it.
+        mainEventQueue.deschedule(dumpEvent);
+    }
+
+    /*
+     * If the period is not 0, we schedule the event. If this is called with a
+     * period that is less than the current tick, then we shift the first dump
+     * by curTick. This ensures that we do not schedule the event is the past.
+     */
+    if (period != 0) {
+        // Schedule the event
+        if (period >= curTick()) {
+            schedStatEvent(true, true, (Tick)period, (Tick)period);
+        } else {
+            schedStatEvent(true, true, (Tick)period + curTick(), (Tick)period);
+        }
+    }
+}
+
+void
+updateEvents()
+{
+    /*
+     * If the dumpEvent has been scheduled, but is scheduled in the past, then
+     * we need to shift the event to be at a valid point in time. Therefore, we
+     * shift the event by curTick.
+     */
+    if (dumpEvent != NULL &&
+        (dumpEvent->scheduled() && dumpEvent->when() < curTick())) {
+        // shift by curTick() and reschedule
+        Tick _when = dumpEvent->when();
+        mainEventQueue.reschedule(dumpEvent, _when + curTick());
+    }
 }
 
 } // namespace Stats