ruby: enable multiple clock domains

This patch allows ruby to have multiple clock domains. As I understand
with this patch, controllers can have different frequencies. The entire
network needs to run at a single frequency.

The idea is that with in an object, time is treated in terms of cycles.
But the messages that are passed from one entity to another should contain
the time in Ticks. As of now, this is only true for the message buffers,
but not for the links in the network. As I understand the code, all the
entities in different networks (simple, garnet-fixed, garnet-flexible) should
be clocked at the same frequency.

Another problem is that the directory controller has to operate at the same
frequency as the ruby system. This is because the memory controller does
not make use of the Message Buffer, and instead implements a buffer of its
own. So, it has no idea of the frequency at which the directory controller
is operating and uses ruby system's frequency for scheduling events.

3 files changed, 23 insertions, 65 deletions

diff --git a/src/mem/ruby/slicc_interface/Message.hh b/src/mem/ruby/slicc_interface/Message.hh
index c99d66f5c..e78ad9a76 100644
--- a/src/mem/ruby/slicc_interface/Message.hh
+++ b/src/mem/ruby/slicc_interface/Message.hh
@@ -40,16 +40,16 @@ typedef RefCountingPtr<Message> MsgPtr;
 class Message : public RefCounted
 {
   public:
-    Message(Cycles curTime)
+    Message(Tick curTime)
         : m_time(curTime),
           m_LastEnqueueTime(curTime),
-          m_DelayedCycles(0)
+          m_DelayedTicks(0)
     { }
 
     Message(const Message &other)
         : m_time(other.m_time),
           m_LastEnqueueTime(other.m_LastEnqueueTime),
-          m_DelayedCycles(other.m_DelayedCycles)
+          m_DelayedTicks(other.m_DelayedTicks)
     { }
 
     virtual ~Message() { }
@@ -71,19 +71,19 @@ class Message : public RefCounted
     virtual bool functionalWrite(Packet *pkt) = 0;
     //{ fatal("Write functional access not implemented!"); }
 
-    void setDelayedCycles(const Cycles cycles) { m_DelayedCycles = cycles; }
-    const Cycles getDelayedCycles() const {return m_DelayedCycles;}
+    void setDelayedTicks(const Tick ticks) { m_DelayedTicks = ticks; }
+    const Tick getDelayedTicks() const {return m_DelayedTicks;}
 
-    void setLastEnqueueTime(const Cycles& time) { m_LastEnqueueTime = time; }
-    const Cycles getLastEnqueueTime() const {return m_LastEnqueueTime;}
+    void setLastEnqueueTime(const Tick& time) { m_LastEnqueueTime = time; }
+    const Tick getLastEnqueueTime() const {return m_LastEnqueueTime;}
 
-    const Cycles& getTime() const { return m_time; }
-    void setTime(const Cycles& new_time) { m_time = new_time; }
+    const Tick& getTime() const { return m_time; }
+    void setTime(const Tick& new_time) { m_time = new_time; }
 
   private:
-    Cycles m_time;
-    Cycles m_LastEnqueueTime; // my last enqueue time
-    Cycles m_DelayedCycles; // my delayed cycles
+    Tick m_time;
+    Tick m_LastEnqueueTime; // my last enqueue time
+    Tick m_DelayedTicks; // my delayed cycles
 };
 
 inline std::ostream&
diff --git a/src/mem/ruby/slicc_interface/NetworkMessage.hh b/src/mem/ruby/slicc_interface/NetworkMessage.hh
index 4d2968f41..3ee13a44a 100644
--- a/src/mem/ruby/slicc_interface/NetworkMessage.hh
+++ b/src/mem/ruby/slicc_interface/NetworkMessage.hh
@@ -42,7 +42,7 @@ typedef RefCountingPtr<NetworkMessage> NetMsgPtr;
 class NetworkMessage : public Message
 {
   public:
-    NetworkMessage(Cycles curTime)
+    NetworkMessage(Tick curTime)
         : Message(curTime), m_internal_dest_valid(false)
     { }
 
diff --git a/src/mem/ruby/slicc_interface/RubyRequest.hh b/src/mem/ruby/slicc_interface/RubyRequest.hh
index 654656132..49964ebb9 100644
--- a/src/mem/ruby/slicc_interface/RubyRequest.hh
+++ b/src/mem/ruby/slicc_interface/RubyRequest.hh
@@ -51,7 +51,7 @@ class RubyRequest : public Message
     PacketPtr pkt;
     unsigned m_contextId;
 
-    RubyRequest(Cycles curTime, uint64_t _paddr, uint8_t* _data, int _len,
+    RubyRequest(Tick curTime, uint64_t _paddr, uint8_t* _data, int _len,
         uint64_t _pc, RubyRequestType _type, RubyAccessMode _access_mode,
         PacketPtr _pkt, PrefetchBit _pb = PrefetchBit_No,
         unsigned _proc_id = 100)
@@ -70,60 +70,18 @@ class RubyRequest : public Message
       m_LineAddress.makeLineAddress();
     }
 
-    RubyRequest(Cycles curTime) : Message(curTime)
-    {
-    }
-
-    RubyRequest*
-    clone() const
-    {
-        return new RubyRequest(*this);
-    }
-
-    const Address&
-    getLineAddress() const
-    {
-        return m_LineAddress;
-    }
-
-    const Address&
-    getPhysicalAddress() const
-    {
-        return m_PhysicalAddress;
-    }
-
-    const RubyRequestType&
-    getType() const
-    {
-        return m_Type;
-    }
+    RubyRequest(Tick curTime) : Message(curTime) {}
+    RubyRequest* clone() const { return new RubyRequest(*this); }
 
-    const Address&
-    getProgramCounter() const
-    {
-        return m_ProgramCounter;
-    }
-
-    const RubyAccessMode&
-    getAccessMode() const
-    {
-      return m_AccessMode;
-    }
-
-    const int&
-    getSize() const
-    {
-      return m_Size;
-    }
-
-    const PrefetchBit&
-    getPrefetch() const
-    {
-      return m_Prefetch;
-    }
+    const Address& getLineAddress() const { return m_LineAddress; }
+    const Address& getPhysicalAddress() const { return m_PhysicalAddress; }
+    const RubyRequestType& getType() const { return m_Type; }
+    const Address& getProgramCounter() const { return m_ProgramCounter; }
+    const RubyAccessMode& getAccessMode() const { return m_AccessMode; }
+    const int& getSize() const { return m_Size; }
+    const PrefetchBit& getPrefetch() const { return m_Prefetch; }
 
     void print(std::ostream& out) const;
-
     bool functionalRead(Packet *pkt);
     bool functionalWrite(Packet *pkt);
 };