ruby: get rid of RefCnt and Allocator stuff use base/refcnt.hh

This was somewhat tricky because the RefCnt API was somewhat odd.  The
biggest confusion was that the the RefCnt object's constructor that
took a TYPE& cloned the object.  I created an explicit virtual clone()
function for things that took advantage of this version of the
constructor.  I was conservative and used clone() when I was in doubt
of whether or not it was necessary.  I still think that there are
probably too many instances of clone(), but hopefully not too many.

I converted several instances of const MsgPtr & to a simple MsgPtr.
If the function wants to avoid the overhead of creating another
reference, then it should just use a regular pointer instead of a ref
counting ptr.

There were a couple of instances where refcounted objects were created
on the stack.  This seems pretty dangerous since if you ever
accidentally make a reference to that object with a ref counting
pointer, bad things are bound to happen.

15 files changed, 75 insertions, 73 deletions

diff --git a/src/mem/ruby/buffers/MessageBuffer.cc b/src/mem/ruby/buffers/MessageBuffer.cc
index e64e47cad..26d187305 100644
--- a/src/mem/ruby/buffers/MessageBuffer.cc
+++ b/src/mem/ruby/buffers/MessageBuffer.cc
@@ -111,16 +111,12 @@ MessageBuffer::getMsgPtrCopy() const
 {
     assert(isReady());
 
-    MsgPtr temp_msg;
-    temp_msg = *(m_prio_heap.peekMin().m_msgptr.ref());
-    assert(temp_msg.ref() != NULL);
-    return temp_msg;
+    return m_prio_heap.peekMin().m_msgptr->clone();
 }
 
 const Message*
 MessageBuffer::peekAtHeadOfQueue() const
 {
-    const Message* msg_ptr;
     DEBUG_NEWLINE(QUEUE_COMP, MedPrio);
 
     DEBUG_MSG(QUEUE_COMP, MedPrio,
@@ -128,8 +124,8 @@ MessageBuffer::peekAtHeadOfQueue() const
                        m_name, g_eventQueue_ptr->getTime()));
     assert(isReady());
 
-    msg_ptr = m_prio_heap.peekMin().m_msgptr.ref();
-    assert(msg_ptr != NULL);
+    const Message* msg_ptr = m_prio_heap.peekMin().m_msgptr.get();
+    assert(msg_ptr);
 
     DEBUG_EXPR(QUEUE_COMP, MedPrio, *msg_ptr);
     DEBUG_NEWLINE(QUEUE_COMP, MedPrio);
@@ -149,7 +145,7 @@ random_time()
 }
 
 void
-MessageBuffer::enqueue(const MsgPtr& message, Time delta)
+MessageBuffer::enqueue(MsgPtr message, Time delta)
 {
     DEBUG_NEWLINE(QUEUE_COMP, HighPrio);
     DEBUG_MSG(QUEUE_COMP, HighPrio,
@@ -214,7 +210,7 @@ MessageBuffer::enqueue(const MsgPtr& message, Time delta)
     m_last_arrival_time = arrival_time;
 
     // compute the delay cycles and set enqueue time
-    Message* msg_ptr = message.mod_ref();
+    Message* msg_ptr = message.get();
     assert(msg_ptr != NULL);
 
     assert(g_eventQueue_ptr->getTime() >= msg_ptr->getLastEnqueueTime() &&
@@ -332,12 +328,11 @@ MessageBuffer::recycle()
 }
 
 int
-MessageBuffer::setAndReturnDelayCycles(MsgPtr& message)
+MessageBuffer::setAndReturnDelayCycles(MsgPtr msg_ptr)
 {
     int delay_cycles = -1;  // null value
 
     // get the delay cycles of the message at the top of the queue
-    Message* msg_ptr = message.ref();
 
     // this function should only be called on dequeue
     // ensure the msg hasn't been enqueued
diff --git a/src/mem/ruby/buffers/MessageBuffer.hh b/src/mem/ruby/buffers/MessageBuffer.hh
index 6b567d70d..1da6c15ae 100644
--- a/src/mem/ruby/buffers/MessageBuffer.hh
+++ b/src/mem/ruby/buffers/MessageBuffer.hh
@@ -102,8 +102,8 @@ class MessageBuffer
         return m_prio_heap.peekMin().m_msgptr;
     }
 
-    void enqueue(const MsgPtr& message) { enqueue(message, 1); }
-    void enqueue(const MsgPtr& message, Time delta);
+    void enqueue(MsgPtr message) { enqueue(message, 1); }
+    void enqueue(MsgPtr message, Time delta);
     //  void enqueueAbsolute(const MsgPtr& message, Time absolute_time);
     int dequeue_getDelayCycles(MsgPtr& message);  // returns delay
                                                   // cycles of the
@@ -136,7 +136,7 @@ class MessageBuffer
     int m_recycle_latency;
 
     // Private Methods
-    int setAndReturnDelayCycles(MsgPtr& message);
+    int setAndReturnDelayCycles(MsgPtr message);
 
     // Private copy constructor and assignment operator
     MessageBuffer(const MessageBuffer& obj);
diff --git a/src/mem/ruby/common/Debug.cc b/src/mem/ruby/common/Debug.cc
index 1bf7ae43b..eb6cc5c47 100644
--- a/src/mem/ruby/common/Debug.cc
+++ b/src/mem/ruby/common/Debug.cc
@@ -65,7 +65,6 @@ DebugComponentData debugComponents[] =
     {"Store Buffer",      'b' },
     {"Cache",             'c' },
     {"Predictor",         'p' },
-    {"Allocator",         'a' },
     {"Memory",            'M' },
 };
 
diff --git a/src/mem/ruby/common/Debug.hh b/src/mem/ruby/common/Debug.hh
index a2344e82d..f8c18a0b5 100644
--- a/src/mem/ruby/common/Debug.hh
+++ b/src/mem/ruby/common/Debug.hh
@@ -62,7 +62,6 @@ enum DebugComponents
     STOREBUFFER_COMP,
     CACHE_COMP,
     PREDICTOR_COMP,
-    ALLOCATOR_COMP,
     MEMORY_COMP,
     NUMBER_OF_COMPS
 };
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.cc
index da86c32fa..2a2536d53 100644
--- a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.cc
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.cc
@@ -107,7 +107,8 @@ void NetworkInterface_d::addNode(Vector<MessageBuffer*>& in,  Vector<MessageBuff
 
 bool NetworkInterface_d::flitisizeMessage(MsgPtr msg_ptr, int vnet)
 {
-        NetworkMessage *net_msg_ptr = dynamic_cast<NetworkMessage*>(msg_ptr.ref());
+        NetworkMessage *net_msg_ptr =
+            safe_cast<NetworkMessage *>(msg_ptr.get());
         NetDest net_msg_dest = net_msg_ptr->getInternalDestination();
         Vector<NodeID> dest_nodes = net_msg_dest.getAllDest(); // gets all the destinations associated with this message.
 
@@ -120,10 +121,11 @@ bool NetworkInterface_d::flitisizeMessage(MsgPtr msg_ptr, int vnet)
                 {
                         return false ;
                 }
-                MsgPtr new_msg_ptr = *(msg_ptr.ref());
+                MsgPtr new_msg_ptr = msg_ptr->clone();
                 NodeID destID = dest_nodes[ctr];
 
-                NetworkMessage *new_net_msg_ptr = dynamic_cast<NetworkMessage*>(new_msg_ptr.ref());
+                NetworkMessage *new_net_msg_ptr =
+                    safe_cast<NetworkMessage *>(new_msg_ptr.get());
                 if(dest_nodes.size() > 1)
                 {
                         NetDest personal_dest;
@@ -145,7 +147,7 @@ bool NetworkInterface_d::flitisizeMessage(MsgPtr msg_ptr, int vnet)
                 {
                         m_net_ptr->increment_injected_flits();
                         flit_d *fl = new flit_d(i, vc, vnet, num_flits, new_msg_ptr);
-                        fl->set_delay(g_eventQueue_ptr->getTime() - (msg_ptr.ref())->getTime());
+                        fl->set_delay(g_eventQueue_ptr->getTime() - msg_ptr->getTime());
                         m_ni_buffers[vc]->insert(fl);
                 }
                 m_ni_enqueue_time[vc] = g_eventQueue_ptr->getTime();
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/RoutingUnit_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/RoutingUnit_d.cc
index 0c215efd3..fabda735a 100644
--- a/src/mem/ruby/network/garnet/fixed-pipeline/RoutingUnit_d.cc
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/RoutingUnit_d.cc
@@ -61,8 +61,8 @@ void RoutingUnit_d::RC_stage(flit_d *t_flit, InputUnit_d *in_unit, int invc)
 int RoutingUnit_d::routeCompute(flit_d *t_flit)
 {
         MsgPtr msg_ptr = t_flit->get_msg_ptr();
-        NetworkMessage* net_msg_ptr = NULL;
-        net_msg_ptr = dynamic_cast<NetworkMessage*>(msg_ptr.ref());
+        NetworkMessage* net_msg_ptr =
+            safe_cast<NetworkMessage*>(msg_ptr.get());
         NetDest msg_destination = net_msg_ptr->getInternalDestination();
 
         int output_link = -1;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
index 697f954ab..c81f5e4b2 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
@@ -103,7 +103,8 @@ void NetworkInterface::request_vc(int in_vc, int in_port, NetDest destination, T
 
 bool NetworkInterface::flitisizeMessage(MsgPtr msg_ptr, int vnet)
 {
-        NetworkMessage *net_msg_ptr = dynamic_cast<NetworkMessage*>(msg_ptr.ref());
+        NetworkMessage *net_msg_ptr =
+            safe_cast<NetworkMessage*>(msg_ptr.get());
         NetDest net_msg_dest = net_msg_ptr->getInternalDestination();
         Vector<NodeID> dest_nodes = net_msg_dest.getAllDest(); // gets all the destinations associated with this message.
         int num_flits = (int) ceil((double) m_net_ptr->MessageSizeType_to_int(net_msg_ptr->getMessageSize())/m_net_ptr->getFlitSize() ); // Number of flits is dependent on the link bandwidth available. This is expressed in terms of bytes/cycle or the flit size
@@ -117,10 +118,11 @@ bool NetworkInterface::flitisizeMessage(MsgPtr msg_ptr, int vnet)
                         // did not find a free output vc
                         return false ;
                 }
-                MsgPtr new_msg_ptr = *(msg_ptr.ref());
+                MsgPtr new_msg_ptr = msg_ptr->clone();
                 NodeID destID = dest_nodes[ctr];
 
-                NetworkMessage *new_net_msg_ptr = dynamic_cast<NetworkMessage*>(new_msg_ptr.ref());
+                NetworkMessage *new_net_msg_ptr =
+                    safe_cast<NetworkMessage*>(new_msg_ptr.get());
                 if(dest_nodes.size() > 1)
                 {
                         NetDest personal_dest;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc b/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc
index 10696f1ad..4cdb9dad8 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc
@@ -252,7 +252,9 @@ void Router::routeCompute(flit *m_flit, int inport)
                 g_eventQueue_ptr->scheduleEvent(this, m_net_ptr->getNumPipeStages() -1 );
         if((m_flit->get_type() == HEAD_) || (m_flit->get_type() == HEAD_TAIL_))
         {
-                NetDest destination = dynamic_cast<NetworkMessage*>(m_flit->get_msg_ptr().ref())->getInternalDestination();
+                NetworkMessage *nm =
+                    safe_cast<NetworkMessage*>(m_flit->get_msg_ptr().get());
+                NetDest destination = nm->getInternalDestination();
                 if(m_net_ptr->getNumPipeStages() > 1)
                 {
                         m_out_vc_state[outport][outvc]->setState(VC_AB_, g_eventQueue_ptr->getTime() + 1);
diff --git a/src/mem/ruby/network/simple/PerfectSwitch.cc b/src/mem/ruby/network/simple/PerfectSwitch.cc
index cf3a5af9c..8e6114ba9 100644
--- a/src/mem/ruby/network/simple/PerfectSwitch.cc
+++ b/src/mem/ruby/network/simple/PerfectSwitch.cc
@@ -170,7 +170,7 @@ PerfectSwitch::wakeup()
 
                 // Peek at message
                 msg_ptr = m_in[incoming][vnet]->peekMsgPtr();
-                net_msg_ptr = dynamic_cast<NetworkMessage*>(msg_ptr.ref());
+                net_msg_ptr = safe_cast<NetworkMessage*>(msg_ptr.get());
                 DEBUG_EXPR(NETWORK_COMP, MedPrio, *net_msg_ptr);
 
                 output_links.clear();
@@ -272,7 +272,7 @@ PerfectSwitch::wakeup()
 
                     // This magic line creates a private copy of the
                     // message
-                    unmodified_msg_ptr = *(msg_ptr.ref());
+                    unmodified_msg_ptr = msg_ptr->clone();
                 }
 
                 // Enqueue it - for all outgoing queues
@@ -282,13 +282,13 @@ PerfectSwitch::wakeup()
                     if (i > 0) {
                         // create a private copy of the unmodified
                         // message
-                        msg_ptr = *(unmodified_msg_ptr.ref());
+                        msg_ptr = unmodified_msg_ptr->clone();
                     }
 
                     // Change the internal destination set of the
                     // message so it knows which destinations this
                     // link is responsible for.
-                    net_msg_ptr = safe_cast<NetworkMessage*>(msg_ptr.ref());
+                    net_msg_ptr = safe_cast<NetworkMessage*>(msg_ptr.get());
                     net_msg_ptr->getInternalDestination() =
                         output_link_destinations[i];
 
diff --git a/src/mem/ruby/network/simple/Throttle.cc b/src/mem/ruby/network/simple/Throttle.cc
index 2d15b1141..5d74afb24 100644
--- a/src/mem/ruby/network/simple/Throttle.cc
+++ b/src/mem/ruby/network/simple/Throttle.cc
@@ -157,7 +157,7 @@ Throttle::wakeup()
                 // Find the size of the message we are moving
                 MsgPtr msg_ptr = m_in[vnet]->peekMsgPtr();
                 NetworkMessage* net_msg_ptr =
-                    safe_cast<NetworkMessage*>(msg_ptr.ref());
+                    safe_cast<NetworkMessage*>(msg_ptr.get());
                 m_units_remaining[vnet] +=
                     network_message_to_size(net_msg_ptr);
 
diff --git a/src/mem/ruby/slicc_interface/Message.hh b/src/mem/ruby/slicc_interface/Message.hh
index d9df6f131..ff94fdd40 100644
--- a/src/mem/ruby/slicc_interface/Message.hh
+++ b/src/mem/ruby/slicc_interface/Message.hh
@@ -31,29 +31,31 @@
 
 #include <iostream>
 
-#include "mem/gems_common/RefCnt.hh"
-#include "mem/gems_common/RefCountable.hh"
+#include "base/refcnt.hh"
 #include "mem/ruby/common/Global.hh"
 #include "mem/ruby/eventqueue/RubyEventQueue.hh"
 
 class Message;
-typedef RefCnt<Message> MsgPtr;
+typedef RefCountingPtr<Message> MsgPtr;
 
-class Message : public RefCountable
+class Message : public RefCounted
 {
   public:
     Message()
-        : RefCountable()
-    {
-        m_time = g_eventQueue_ptr->getTime();
-        m_LastEnqueueTime = g_eventQueue_ptr->getTime();
-        m_DelayedCycles = 0;
-    }
+        : m_time(g_eventQueue_ptr->getTime()),
+          m_LastEnqueueTime(g_eventQueue_ptr->getTime()),
+          m_DelayedCycles(0)
+    { }
+
+    Message(const Message &other)
+        : m_time(other.m_time),
+          m_LastEnqueueTime(other.m_LastEnqueueTime),
+          m_DelayedCycles(other.m_DelayedCycles)
+    { }
 
     virtual ~Message() { }
 
     virtual Message* clone() const = 0;
-    virtual void destroy() = 0;
     virtual void print(std::ostream& out) const = 0;
 
     void setDelayedCycles(const int& cycles) { m_DelayedCycles = cycles; }
diff --git a/src/mem/ruby/slicc_interface/NetworkMessage.hh b/src/mem/ruby/slicc_interface/NetworkMessage.hh
index 41365ff9e..c92de0937 100644
--- a/src/mem/ruby/slicc_interface/NetworkMessage.hh
+++ b/src/mem/ruby/slicc_interface/NetworkMessage.hh
@@ -31,8 +31,7 @@
 
 #include <iostream>
 
-#include "mem/gems_common/RefCnt.hh"
-#include "mem/gems_common/RefCountable.hh"
+#include "base/refcnt.hh"
 #include "mem/protocol/MessageSizeType.hh"
 #include "mem/ruby/common/Global.hh"
 #include "mem/ruby/common/NetDest.hh"
@@ -41,16 +40,18 @@
 class Address;
 
 class NetworkMessage;
-typedef RefCnt<NetworkMessage> NetMsgPtr;
+typedef RefCountingPtr<NetworkMessage> NetMsgPtr;
 
 class NetworkMessage : public Message
 {
   public:
     NetworkMessage()
-        : Message()
-    {
-        m_internal_dest_valid = false;
-    }
+        : m_internal_dest_valid(false)
+    { }
+
+    NetworkMessage(const NetworkMessage &other)
+        : Message(other), m_internal_dest_valid(other.m_internal_dest_valid)
+    { }
 
     virtual ~NetworkMessage() { }
 
diff --git a/src/mem/ruby/system/DMASequencer.cc b/src/mem/ruby/system/DMASequencer.cc
index 5d9037358..a7f3a8aec 100644
--- a/src/mem/ruby/system/DMASequencer.cc
+++ b/src/mem/ruby/system/DMASequencer.cc
@@ -82,22 +82,22 @@ DMASequencer::makeRequest(const RubyRequest &request)
     active_request.bytes_issued = 0;
     active_request.pkt = request.pkt;
 
-    SequencerMsg msg;
-    msg.getPhysicalAddress() = Address(paddr);
-    msg.getLineAddress() = line_address(msg.getPhysicalAddress());
-    msg.getType() = write ? SequencerRequestType_ST : SequencerRequestType_LD;
+    SequencerMsg *msg = new SequencerMsg;
+    msg->getPhysicalAddress() = Address(paddr);
+    msg->getLineAddress() = line_address(msg->getPhysicalAddress());
+    msg->getType() = write ? SequencerRequestType_ST : SequencerRequestType_LD;
     int offset = paddr & m_data_block_mask;
 
-    msg.getLen() = (offset + len) <= RubySystem::getBlockSizeBytes() ?
+    msg->getLen() = (offset + len) <= RubySystem::getBlockSizeBytes() ?
         len : RubySystem::getBlockSizeBytes() - offset;
 
     if (write) {
-        msg.getDataBlk().setData(data, offset, msg.getLen());
+        msg->getDataBlk().setData(data, offset, msg->getLen());
     }
 
     assert(m_mandatory_q_ptr != NULL);
     m_mandatory_q_ptr->enqueue(msg);
-    active_request.bytes_issued += msg.getLen();
+    active_request.bytes_issued += msg->getLen();
 
     return RequestStatus_Issued;
 }
@@ -113,34 +113,34 @@ DMASequencer::issueNext()
         return;
     }
 
-    SequencerMsg msg;
-    msg.getPhysicalAddress() = Address(active_request.start_paddr +
+    SequencerMsg *msg = new SequencerMsg;
+    msg->getPhysicalAddress() = Address(active_request.start_paddr +
                                        active_request.bytes_completed);
 
-    assert((msg.getPhysicalAddress().getAddress() & m_data_block_mask) == 0);
-    msg.getLineAddress() = line_address(msg.getPhysicalAddress());
+    assert((msg->getPhysicalAddress().getAddress() & m_data_block_mask) == 0);
+    msg->getLineAddress() = line_address(msg->getPhysicalAddress());
 
-    msg.getType() = (active_request.write ? SequencerRequestType_ST :
+    msg->getType() = (active_request.write ? SequencerRequestType_ST :
                      SequencerRequestType_LD);
 
-    msg.getLen() =
+    msg->getLen() =
         (active_request.len -
          active_request.bytes_completed < RubySystem::getBlockSizeBytes() ?
          active_request.len - active_request.bytes_completed :
          RubySystem::getBlockSizeBytes());
 
     if (active_request.write) {
-        msg.getDataBlk().
+        msg->getDataBlk().
             setData(&active_request.data[active_request.bytes_completed],
-                    0, msg.getLen());
-        msg.getType() = SequencerRequestType_ST;
+                    0, msg->getLen());
+        msg->getType() = SequencerRequestType_ST;
     } else {
-        msg.getType() = SequencerRequestType_LD;
+        msg->getType() = SequencerRequestType_LD;
     }
 
     assert(m_mandatory_q_ptr != NULL);
     m_mandatory_q_ptr->enqueue(msg);
-    active_request.bytes_issued += msg.getLen();
+    active_request.bytes_issued += msg->getLen();
 }
 
 void
diff --git a/src/mem/ruby/system/MemoryControl.cc b/src/mem/ruby/system/MemoryControl.cc
index 3644a3e59..5c455049e 100644
--- a/src/mem/ruby/system/MemoryControl.cc
+++ b/src/mem/ruby/system/MemoryControl.cc
@@ -239,7 +239,7 @@ MemoryControl::enqueue(const MsgPtr& message, int latency)
 {
     Time current_time = g_eventQueue_ptr->getTime();
     Time arrival_time = current_time + latency;
-    const MemoryMsg* memMess = dynamic_cast<const MemoryMsg*>(message.ref());
+    const MemoryMsg* memMess = safe_cast<const MemoryMsg*>(message.get());
     physical_address_t addr = memMess->getAddress().getAddress();
     MemoryRequestType type = memMess->getType();
     bool is_mem_read = (type == MemoryRequestType_MEMORY_READ);
@@ -285,7 +285,7 @@ const Message*
 MemoryControl::peek()
 {
     MemoryNode node = peekNode();
-    Message* msg_ptr = node.m_msgptr.ref();
+    Message* msg_ptr = node.m_msgptr.get();
     assert(msg_ptr != NULL);
     return msg_ptr;
 }
@@ -536,7 +536,7 @@ MemoryControl::issueRequest(int bank)
                 req.m_msg_counter, req.m_addr, req.m_is_mem_read? 'R':'W',
                 current_time, bank);
     }
-    if (req.m_msgptr.ref() != NULL) {  // don't enqueue L3 writebacks
+    if (req.m_msgptr) {  // don't enqueue L3 writebacks
         enqueueToDirectory(req, m_mem_ctl_latency + m_mem_fixed_delay);
     }
     m_oldRequest[bank] = 0;
diff --git a/src/mem/ruby/system/Sequencer.cc b/src/mem/ruby/system/Sequencer.cc
index dd8cec967..641c8fcb9 100644
--- a/src/mem/ruby/system/Sequencer.cc
+++ b/src/mem/ruby/system/Sequencer.cc
@@ -536,9 +536,9 @@ Sequencer::issueRequest(const RubyRequest& request)
 
     Address line_addr(request.paddr);
     line_addr.makeLineAddress();
-    CacheMsg msg(line_addr, Address(request.paddr), ctype,
-                 Address(request.pc), amtype, request.len, PrefetchBit_No,
-                 request.proc_id);
+    CacheMsg *msg = new CacheMsg(line_addr, Address(request.paddr), ctype,
+        Address(request.pc), amtype, request.len, PrefetchBit_No,
+        request.proc_id);
 
     if (Debug::getProtocolTrace()) {
         g_system_ptr->getProfiler()->