changeset b67ea6252629 in /z/repo/gem5
details: http://repo.gem5.org/gem5?cmd=changeset;node=b67ea6252629
description:
        cpu: Block traffic generator when requests have to retry

        This patch changes the queued port for a conventional master port and
        stalls the traffic generator when requests are not immediately
        accepted. This is a first step to allowing elasticity in the injection
        of requests.

        The patch also adds stats for the sent packets and retries, and
        slightly changes how the nextPacketTick and getNextPacket
        interact. The advancing of the trace is now moved to getNextPacket and
        nextPacketTick is only responsible for answering the question when the
        next packet should be sent.

diffstat:

 src/cpu/testers/traffic_gen/generators.cc  |   77 ++++++++--------
 src/cpu/testers/traffic_gen/generators.hh  |   15 +-
 src/cpu/testers/traffic_gen/traffic_gen.cc |  128 +++++++++++++++++++++++-----
 src/cpu/testers/traffic_gen/traffic_gen.hh |   54 ++++++++---
 4 files changed, 187 insertions(+), 87 deletions(-)

diffs (truncated from 504 to 300 lines):

diff -r 1cfcc2960e9f -r b67ea6252629 src/cpu/testers/traffic_gen/generators.cc
--- a/src/cpu/testers/traffic_gen/generators.cc Thu May 30 12:54:04 2013 -0400
+++ b/src/cpu/testers/traffic_gen/generators.cc Thu May 30 12:54:05 2013 -0400
@@ -100,20 +100,20 @@
     // increment the address
     nextAddr += blocksize;
 
-    return pkt;
-}
-
-Tick
-LinearGen::nextPacketTick()
-{
     // If we have reached the end of the address space, reset the
     // address to the start of the range
-    if (nextAddr + blocksize > endAddr) {
+    if (nextAddr > endAddr) {
         DPRINTF(TrafficGen, "Wrapping address to the start of "
                 "the range\n");
         nextAddr = startAddr;
     }
 
+    return pkt;
+}
+
+Tick
+LinearGen::nextPacketTick() const
+{
     // Check to see if we have reached the data limit. If dataLimit is
     // zero we do not have a data limit and therefore we will keep
     // generating requests for the entire residency in this state.
@@ -162,7 +162,7 @@
 }
 
 Tick
-RandomGen::nextPacketTick()
+RandomGen::nextPacketTick() const
 {
     // Check to see if we have reached the data limit. If dataLimit is
     // zero we do not have a data limit and therefore we will keep
@@ -217,38 +217,19 @@
 }
 
 Tick
-TraceGen::nextPacketTick() {
-    if (traceComplete)
+TraceGen::nextPacketTick() const
+{
+    if (traceComplete) {
+        DPRINTF(TrafficGen, "No next tick as trace is finished\n");
         // We are at the end of the file, thus we have no more data in
         // the trace Return MaxTick to signal that there will be no
         // more transactions in this active period for the state.
         return MaxTick;
-
-
-    //Reset the nextElement to the default values
-    currElement = nextElement;
-    nextElement.clear();
-
-    // We need to look at the next line to calculate the next time an
-    // event occurs, or potentially return MaxTick to signal that
-    // nothing has to be done.
-    if (!trace.read(nextElement)) {
-        traceComplete = true;
-        return MaxTick;
     }
 
-    DPRINTF(TrafficGen, "currElement: %c addr %d size %d tick %d (%d)\n",
-            currElement.cmd.isRead() ? 'r' : 'w',
-            currElement.addr,
-            currElement.blocksize,
-            currElement.tick + tickOffset,
-            currElement.tick);
+    assert(nextElement.isValid());
 
-    DPRINTF(TrafficGen, "nextElement: %c addr %d size %d tick %d (%d)\n",
-            nextElement.cmd.isRead() ? 'r' : 'w',
-            nextElement.addr,
-            nextElement.blocksize,
-            nextElement.tick + tickOffset,
+    DPRINTF(TrafficGen, "Next packet tick is %d\n", tickOffset +
             nextElement.tick);
 
     return tickOffset + nextElement.tick;
@@ -261,17 +242,24 @@
     tickOffset = curTick();
 
     // clear everything
-    nextElement.clear();
     currElement.clear();
 
-    traceComplete = false;
+    // read the first element in the file and set the complete flag
+    traceComplete = !trace.read(nextElement);
 }
 
 PacketPtr
 TraceGen::getNextPacket()
 {
-    // it is the responsibility of nextPacketTick to prevent the
-    // state graph from executing the state if it should not
+    // shift things one step forward
+    currElement = nextElement;
+    nextElement.clear();
+
+    // read the next element and set the complete flag
+    traceComplete = !trace.read(nextElement);
+
+    // it is the responsibility of the traceComplete flag to ensure we
+    // always have a valid element here
     assert(currElement.isValid());
 
     DPRINTF(TrafficGen, "TraceGen::getNextPacket: %c %d %d %d 0x%x\n",
@@ -281,8 +269,19 @@
             currElement.tick,
             currElement.flags);
 
-    return getPacket(currElement.addr + addrOffset, currElement.blocksize,
-                     currElement.cmd, currElement.flags);
+    PacketPtr pkt = getPacket(currElement.addr + addrOffset,
+                              currElement.blocksize,
+                              currElement.cmd, currElement.flags);
+
+    if (!traceComplete)
+        DPRINTF(TrafficGen, "nextElement: %c addr %d size %d tick %d (%d)\n",
+                nextElement.cmd.isRead() ? 'r' : 'w',
+                nextElement.addr,
+                nextElement.blocksize,
+                nextElement.tick + tickOffset,
+                nextElement.tick);
+
+    return pkt;
 }
 
 void
diff -r 1cfcc2960e9f -r b67ea6252629 src/cpu/testers/traffic_gen/generators.hh
--- a/src/cpu/testers/traffic_gen/generators.hh Thu May 30 12:54:04 2013 -0400
+++ b/src/cpu/testers/traffic_gen/generators.hh Thu May 30 12:54:05 2013 -0400
@@ -126,7 +126,7 @@
      *
      * @return next tick when a packet is available
      */
-    virtual Tick nextPacketTick() = 0;
+    virtual Tick nextPacketTick() const = 0;
 
 };
 
@@ -146,7 +146,7 @@
 
     PacketPtr getNextPacket() { return NULL; }
 
-    Tick nextPacketTick() { return MaxTick; }
+    Tick nextPacketTick() const { return MaxTick; }
 };
 
 /**
@@ -192,7 +192,7 @@
 
     PacketPtr getNextPacket();
 
-    Tick nextPacketTick();
+    Tick nextPacketTick() const;
 
   private:
 
@@ -269,7 +269,7 @@
 
     PacketPtr getNextPacket();
 
-    Tick nextPacketTick();
+    Tick nextPacketTick() const;
 
   private:
 
@@ -415,12 +415,11 @@
     void exit();
 
     /**
-     * Read a line of the trace file. Returns the raw tick
-     * when the next request should be generated. If the end
-     * of the file has been reached, it returns MaxTick to
+     * Returns the tick when the next request should be generated. If
+     * the end of the file has been reached, it returns MaxTick to
      * indicate that there will be no more requests.
      */
-    Tick nextPacketTick();
+    Tick nextPacketTick() const;
 
   private:
 
diff -r 1cfcc2960e9f -r b67ea6252629 src/cpu/testers/traffic_gen/traffic_gen.cc
--- a/src/cpu/testers/traffic_gen/traffic_gen.cc        Thu May 30 12:54:04 
2013 -0400
+++ b/src/cpu/testers/traffic_gen/traffic_gen.cc        Thu May 30 12:54:05 
2013 -0400
@@ -56,8 +56,12 @@
       masterID(system->getMasterId(name())),
       configFile(p->config_file),
       nextTransitionTick(0),
+      nextPacketTick(0),
       port(name() + ".port", *this),
-      updateEvent(this)
+      retryPkt(NULL),
+      retryPktTick(0),
+      updateEvent(this),
+      drainManager(NULL)
 {
 }
 
@@ -102,7 +106,9 @@
 {
     // when not restoring from a checkpoint, make sure we kick things off
     if (system->isTimingMode()) {
-        schedule(updateEvent, nextEventTick());
+        // call nextPacketTick on the state to advance it
+        nextPacketTick = states[currState]->nextPacketTick();
+        schedule(updateEvent, std::min(nextPacketTick, nextTransitionTick));
     } else {
         DPRINTF(TrafficGen,
                 "Traffic generator is only active in timing mode\n");
@@ -112,9 +118,16 @@
 unsigned int
 TrafficGen::drain(DrainManager *dm)
 {
-    // @todo we should also stop putting new requests in the queue and
-    // either interrupt the current state or wait for a transition
-    return port.drain(dm);
+    if (retryPkt == NULL) {
+        // shut things down
+        nextPacketTick = MaxTick;
+        nextTransitionTick = MaxTick;
+        deschedule(updateEvent);
+        return 0;
+    } else {
+        drainManager = dm;
+        return 1;
+    }
 }
 
 void
@@ -123,18 +136,17 @@
     DPRINTF(Checkpoint, "Serializing TrafficGen\n");
 
     // save ticks of the graph event if it is scheduled
-    Tick nextEvent = updateEvent.scheduled() ?
-        updateEvent.when() : 0;
+    Tick nextEvent = updateEvent.scheduled() ? updateEvent.when() : 0;
 
-    DPRINTF(TrafficGen, "Saving nextEvent=%llu\n",
-            nextEvent);
+    DPRINTF(TrafficGen, "Saving nextEvent=%llu\n", nextEvent);
 
     SERIALIZE_SCALAR(nextEvent);
 
     SERIALIZE_SCALAR(nextTransitionTick);
 
-    // @todo: also serialise the current state, figure out the best
-    // way to drain and restore
+    SERIALIZE_SCALAR(nextPacketTick);
+
+    SERIALIZE_SCALAR(currState);
 }
 
 void
@@ -148,28 +160,43 @@
     }
 
     UNSERIALIZE_SCALAR(nextTransitionTick);
+
+    UNSERIALIZE_SCALAR(nextPacketTick);
+
+    // @todo In the case of a stateful generator state such as the
+    // trace player we would also have to restore the position in the
+    // trace playback
+    UNSERIALIZE_SCALAR(currState);
 }
 
 void
 TrafficGen::update()
 {
-    // schedule next update event based on either the next execute
-    // tick or the next transition, which ever comes first
-    Tick nextEvent = nextEventTick();
-    DPRINTF(TrafficGen, "Updating state graph, next event at %lld\n",
-            nextEvent);
-    schedule(updateEvent, nextEvent);
-
-    // perform the update associated with the current update event
-
     // if we have reached the time for the next state transition, then
     // perform the transition
     if (curTick() >= nextTransitionTick) {
         transition();
     } else {
-        // we are still in the current state and should execute it
+        assert(curTick() >= nextPacketTick);
+        // get the next packet and try to send it
         PacketPtr pkt = states[currState]->getNextPacket();
-        port.schedTimingReq(pkt, curTick());
+        numPackets++;
+        if (!port.sendTimingReq(pkt)) {
_______________________________________________
gem5-dev mailing list
[email protected]
http://m5sim.org/mailman/listinfo/gem5-dev

Reply via email to