From 050f24c7964cbe65633261e431e1105d1d5e8070 Mon Sep 17 00:00:00 2001
From: Andreas Sandberg <Andreas.Sandberg@arm.com>
Date: Fri, 2 Nov 2012 11:32:02 -0500
Subject: [PATCH] sim: Add drain methods to request additional cleanup
 operations

This patch adds the following two methods to the Drainable base class:

memWriteback() - Write back all dirty cache lines to memory using
functional accesses.

memInvalidate() - Invalidate memory system buffers. Dirty data
won't be written back.

Specifying calling memWriteback() after draining will allow us to
checkpoint systems with caches. memInvalidate() can be used to drop
memory system buffers in preparation for switching to an accelerated
CPU model that bypasses the gem5 memory system (e.g., hardware
virtualized CPUs).

Note: This patch only adds the methods to Drainable, the code for
flushing the TLB and the cache is committed separately.
---
 src/python/m5/simulate.py |  9 +++++++++
 src/sim/drain.hh          | 23 +++++++++++++++++++++++
 2 files changed, 32 insertions(+)

diff --git a/src/python/m5/simulate.py b/src/python/m5/simulate.py
index ca2cc4a9c..8ad273225 100644
--- a/src/python/m5/simulate.py
+++ b/src/python/m5/simulate.py
@@ -181,6 +181,14 @@ def drain(root):
     while (not all_drained):
         all_drained = _drain()
 
+def memWriteback(root):
+    for obj in root.descendants():
+        obj.memWriteback()
+
+def memInvalidate(root):
+    for obj in root.descendants():
+        obj.memInvalidate()
+
 def resume(root):
     for obj in root.descendants(): obj.drainResume()
 
@@ -189,6 +197,7 @@ def checkpoint(dir):
     if not isinstance(root, objects.Root):
         raise TypeError, "Checkpoint must be called on a root object."
     drain(root)
+    memWriteback(root)
     print "Writing checkpoint"
     internal.core.serializeAll(dir)
     resume(root)
diff --git a/src/sim/drain.hh b/src/sim/drain.hh
index 252022bc7..2f5d2d965 100644
--- a/src/sim/drain.hh
+++ b/src/sim/drain.hh
@@ -202,6 +202,29 @@ class Drainable
      */
     virtual void drainResume();
 
+    /**
+     * Write back dirty buffers to memory using functional writes.
+     *
+     * After returning, an object implementing this method should have
+     * written all its dirty data back to memory. This method is
+     * typically used to prepare a system with caches for
+     * checkpointing.
+     */
+    virtual void memWriteback() {};
+
+    /**
+     * Invalidate the contents of memory buffers.
+     *
+     * When the switching to hardware virtualized CPU models, we need
+     * to make sure that we don't have any cached state in the system
+     * that might become stale when we return. This method is used to
+     * flush all such state back to main memory.
+     *
+     * @warn This does <i>not</i> cause any dirty state to be written
+     * back to memory.
+     */
+    virtual void memInvalidate() {};
+
     State getDrainState() const { return _drainState; }
 
   protected:
-- 
2.30.2