ruby: message buffer: refactor code

Code in two of the functions was exactly the same.  This patch moves
this code to a new function which is called from the two functions
mentioned initially.

src/mem/ruby/buffers/MessageBuffer.cc

@@ -281,6 +281,22 @@ MessageBuffer::recycle()
         scheduleEventAbsolute(m_receiver->clockEdge(m_recycle_latency));
 }
 
+void
+MessageBuffer::reanalyzeList(list<MsgPtr> &lt, Tick nextTick)
+{
+    while(!lt.empty()) {
+        m_msg_counter++;
+        MessageBufferNode msgNode(nextTick, m_msg_counter, lt.front());
+
+        m_prio_heap.push_back(msgNode);
+        push_heap(m_prio_heap.begin(), m_prio_heap.end(),
+                  greater<MessageBufferNode>());
+
+        m_consumer->scheduleEventAbsolute(nextTick);
+        lt.pop_front();
+    }
+}
+
 void
 MessageBuffer::reanalyzeMessages(const Address& addr)
 {
@@ -292,18 +308,7 @@ MessageBuffer::reanalyzeMessages(const Address& addr)
     // Put all stalled messages associated with this address back on the
     // prio heap
     //
-    while(!m_stall_msg_map[addr].empty()) {
-        m_msg_counter++;
-        MessageBufferNode msgNode(nextTick, m_msg_counter,
-                                  m_stall_msg_map[addr].front());
-
-        m_prio_heap.push_back(msgNode);
-        push_heap(m_prio_heap.begin(), m_prio_heap.end(),
-                  greater<MessageBufferNode>());
-
-        m_consumer->scheduleEventAbsolute(nextTick);
-        m_stall_msg_map[addr].pop_front();
-    }
+    reanalyzeList(m_stall_msg_map[addr], nextTick);
     m_stall_msg_map.erase(addr);
 }
 
@@ -318,21 +323,8 @@ MessageBuffer::reanalyzeAllMessages()
     // prio heap
     //
     for (StallMsgMapType::iterator map_iter = m_stall_msg_map.begin();
-         map_iter != m_stall_msg_map.end();
-         ++map_iter) {
-
-        while(!(map_iter->second).empty()) {
-            m_msg_counter++;
-            MessageBufferNode msgNode(nextTick, m_msg_counter,
-                                      (map_iter->second).front());
-
-            m_prio_heap.push_back(msgNode);
-            push_heap(m_prio_heap.begin(), m_prio_heap.end(),
-                      greater<MessageBufferNode>());
-
-            m_consumer->scheduleEventAbsolute(nextTick);
-            (map_iter->second).pop_front();
-        }
+         map_iter != m_stall_msg_map.end(); ++map_iter) {
+        reanalyzeList(map_iter->second, nextTick);
     }
     m_stall_msg_map.clear();
 }

src/mem/ruby/buffers/MessageBuffer.hh

@@ -156,6 +156,9 @@ class MessageBuffer
     // This required for debugging the code.
     uint32_t functionalWrite(Packet *pkt);
 
+  private:
+    void reanalyzeList(std::list<MsgPtr> &, Tick);
+
   private:
     //added by SS
     Cycles m_recycle_latency;
@@ -172,7 +175,6 @@ class MessageBuffer
     // use a std::map for the stalled messages as this container is
     // sorted and ensures a well-defined iteration order
     typedef std::map< Address, std::list<MsgPtr> > StallMsgMapType;
-    typedef std::vector<MsgPtr>::iterator MsgListIter;
 
     StallMsgMapType m_stall_msg_map;
     std::string m_name;

src/mem/ruby/slicc_interface/AbstractController.hh

@@ -137,9 +137,11 @@ class AbstractController : public ClockedObject, public Consumer
     Network* m_net_ptr;
     bool m_is_blocking;
     std::map<Address, MessageBuffer*> m_block_map;
+
     typedef std::vector<MessageBuffer*> MsgVecType;
     typedef std::map< Address, MsgVecType* > WaitingBufType;
     WaitingBufType m_waiting_buffers;
+
     unsigned int m_in_ports;
     unsigned int m_cur_in_port;
     int m_number_of_TBEs;