summaryrefslogtreecommitdiff
path: root/src/mem/ruby/buffers
diff options
context:
space:
mode:
Diffstat (limited to 'src/mem/ruby/buffers')
-rw-r--r--src/mem/ruby/buffers/MessageBuffer.cc502
-rw-r--r--src/mem/ruby/buffers/MessageBuffer.hh254
-rw-r--r--src/mem/ruby/buffers/MessageBufferNode.cc11
-rw-r--r--src/mem/ruby/buffers/MessageBufferNode.hh80
4 files changed, 438 insertions, 409 deletions
diff --git a/src/mem/ruby/buffers/MessageBuffer.cc b/src/mem/ruby/buffers/MessageBuffer.cc
index d157e2a94..83bb34dad 100644
--- a/src/mem/ruby/buffers/MessageBuffer.cc
+++ b/src/mem/ruby/buffers/MessageBuffer.cc
@@ -1,4 +1,3 @@
-
/*
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* All rights reserved.
@@ -27,318 +26,341 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-/*
- * $Id$
- */
-
#include "mem/ruby/buffers/MessageBuffer.hh"
#include "mem/ruby/system/System.hh"
MessageBuffer::MessageBuffer(const string &name)
{
- m_msg_counter = 0;
- m_consumer_ptr = NULL;
- m_ordering_set = false;
- m_strict_fifo = true;
- m_size = 0;
- m_max_size = -1;
- m_last_arrival_time = 0;
- m_randomization = true;
- m_size_last_time_size_checked = 0;
- m_time_last_time_size_checked = 0;
- m_time_last_time_enqueue = 0;
- m_time_last_time_pop = 0;
- m_size_at_cycle_start = 0;
- m_msgs_this_cycle = 0;
- m_not_avail_count = 0;
- m_priority_rank = 0;
- m_name = name;
+ m_msg_counter = 0;
+ m_consumer_ptr = NULL;
+ m_ordering_set = false;
+ m_strict_fifo = true;
+ m_size = 0;
+ m_max_size = -1;
+ m_last_arrival_time = 0;
+ m_randomization = true;
+ m_size_last_time_size_checked = 0;
+ m_time_last_time_size_checked = 0;
+ m_time_last_time_enqueue = 0;
+ m_time_last_time_pop = 0;
+ m_size_at_cycle_start = 0;
+ m_msgs_this_cycle = 0;
+ m_not_avail_count = 0;
+ m_priority_rank = 0;
+ m_name = name;
}
-int MessageBuffer::getSize()
+int
+MessageBuffer::getSize()
{
- if(m_time_last_time_size_checked == g_eventQueue_ptr->getTime()){
- return m_size_last_time_size_checked;
- } else {
- m_time_last_time_size_checked = g_eventQueue_ptr->getTime();
- m_size_last_time_size_checked = m_size;
- return m_size;
- }
+ if (m_time_last_time_size_checked == g_eventQueue_ptr->getTime()) {
+ return m_size_last_time_size_checked;
+ } else {
+ m_time_last_time_size_checked = g_eventQueue_ptr->getTime();
+ m_size_last_time_size_checked = m_size;
+ return m_size;
+ }
}
-bool MessageBuffer::areNSlotsAvailable(int n)
+bool
+MessageBuffer::areNSlotsAvailable(int n)
{
- // fast path when message buffers have infinite size
- if(m_max_size == -1) {
- return true;
- }
-
- // determine my correct size for the current cycle
- // pop operations shouldn't effect the network's visible size until next cycle,
- // but enqueue operations effect the visible size immediately
- int current_size = max(m_size_at_cycle_start, m_size);
- if (m_time_last_time_pop < g_eventQueue_ptr->getTime()) { // no pops this cycle - m_size is correct
- current_size = m_size;
- } else {
- if (m_time_last_time_enqueue < g_eventQueue_ptr->getTime()) { // no enqueues this cycle - m_size_at_cycle_start is correct
- current_size = m_size_at_cycle_start;
- } else { // both pops and enqueues occured this cycle - add new enqueued msgs to m_size_at_cycle_start
- current_size = m_size_at_cycle_start+m_msgs_this_cycle;
+ // fast path when message buffers have infinite size
+ if (m_max_size == -1) {
+ return true;
+ }
+
+ // determine my correct size for the current cycle
+ // pop operations shouldn't effect the network's visible size
+ // until next cycle, but enqueue operations effect the visible
+ // size immediately
+ int current_size = max(m_size_at_cycle_start, m_size);
+ if (m_time_last_time_pop < g_eventQueue_ptr->getTime()) {
+ // no pops this cycle - m_size is correct
+ current_size = m_size;
+ } else {
+ if (m_time_last_time_enqueue < g_eventQueue_ptr->getTime()) {
+ // no enqueues this cycle - m_size_at_cycle_start is correct
+ current_size = m_size_at_cycle_start;
+ } else {
+ // both pops and enqueues occured this cycle - add new
+ // enqueued msgs to m_size_at_cycle_start
+ current_size = m_size_at_cycle_start+m_msgs_this_cycle;
+ }
+ }
+
+ // now compare the new size with our max size
+ if (current_size + n <= m_max_size) {
+ return true;
+ } else {
+ DEBUG_MSG(QUEUE_COMP, MedPrio, n);
+ DEBUG_MSG(QUEUE_COMP, MedPrio, current_size);
+ DEBUG_MSG(QUEUE_COMP, MedPrio, m_size);
+ DEBUG_MSG(QUEUE_COMP, MedPrio, m_max_size);
+ m_not_avail_count++;
+ return false;
}
- }
-
- // now compare the new size with our max size
- if(current_size+n <= m_max_size){
- return true;
- } else {
- DEBUG_MSG(QUEUE_COMP,MedPrio,n);
- DEBUG_MSG(QUEUE_COMP,MedPrio,current_size);
- DEBUG_MSG(QUEUE_COMP,MedPrio,m_size);
- DEBUG_MSG(QUEUE_COMP,MedPrio,m_max_size);
- m_not_avail_count++;
- return false;
- }
}
-const MsgPtr MessageBuffer::getMsgPtrCopy() const
+const MsgPtr
+MessageBuffer::getMsgPtrCopy() const
{
- assert(isReady());
+ assert(isReady());
- MsgPtr temp_msg;
- temp_msg = *(m_prio_heap.peekMin().m_msgptr.ref());
- assert(temp_msg.ref() != NULL);
- return temp_msg;
+ MsgPtr temp_msg;
+ temp_msg = *(m_prio_heap.peekMin().m_msgptr.ref());
+ assert(temp_msg.ref() != NULL);
+ return temp_msg;
}
-const Message* MessageBuffer::peekAtHeadOfQueue() const
+const Message*
+MessageBuffer::peekAtHeadOfQueue() const
{
- const Message* msg_ptr;
- DEBUG_NEWLINE(QUEUE_COMP,MedPrio);
+ const Message* msg_ptr;
+ DEBUG_NEWLINE(QUEUE_COMP, MedPrio);
- DEBUG_MSG(QUEUE_COMP,MedPrio,"Peeking at head of queue " + m_name + " time: "
- + int_to_string(g_eventQueue_ptr->getTime()) + ".");
- assert(isReady());
+ DEBUG_MSG(QUEUE_COMP, MedPrio,
+ "Peeking at head of queue " + m_name + " time: "
+ + int_to_string(g_eventQueue_ptr->getTime()) + ".");
+ assert(isReady());
- msg_ptr = m_prio_heap.peekMin().m_msgptr.ref();
- assert(msg_ptr != NULL);
+ msg_ptr = m_prio_heap.peekMin().m_msgptr.ref();
+ assert(msg_ptr != NULL);
- DEBUG_EXPR(QUEUE_COMP,MedPrio,*msg_ptr);
- DEBUG_NEWLINE(QUEUE_COMP,MedPrio);
- return msg_ptr;
+ DEBUG_EXPR(QUEUE_COMP, MedPrio, *msg_ptr);
+ DEBUG_NEWLINE(QUEUE_COMP, MedPrio);
+ return msg_ptr;
}
// FIXME - move me somewhere else
-int random_time()
+int
+random_time()
{
- int time = 1;
- time += random() & 0x3; // [0...3]
- if ((random() & 0x7) == 0) { // 1 in 8 chance
- time += 100 + (random() % 0xf); // 100 + [1...15]
- }
- return time;
+ int time = 1;
+ time += random() & 0x3; // [0...3]
+ if ((random() & 0x7) == 0) { // 1 in 8 chance
+ time += 100 + (random() % 0xf); // 100 + [1...15]
+ }
+ return time;
}
-void MessageBuffer::enqueue(const MsgPtr& message, Time delta)
+void
+MessageBuffer::enqueue(const MsgPtr& message, Time delta)
{
- DEBUG_NEWLINE(QUEUE_COMP,HighPrio);
- DEBUG_MSG(QUEUE_COMP,HighPrio,"enqueue " + m_name + " time: "
- + int_to_string(g_eventQueue_ptr->getTime()) + ".");
- DEBUG_EXPR(QUEUE_COMP,MedPrio,message);
- DEBUG_NEWLINE(QUEUE_COMP,HighPrio);
-
- m_msg_counter++;
- m_size++;
-
- // record current time incase we have a pop that also adjusts my size
- if (m_time_last_time_enqueue < g_eventQueue_ptr->getTime()) {
- m_msgs_this_cycle = 0; // first msg this cycle
- m_time_last_time_enqueue = g_eventQueue_ptr->getTime();
- }
- m_msgs_this_cycle++;
-
- // ASSERT(m_max_size == -1 || m_size <= m_max_size + 1);
- // the plus one is a kluge because of a SLICC issue
-
- if (!m_ordering_set) {
- // WARN_EXPR(*this);
- WARN_EXPR(m_name);
- ERROR_MSG("Ordering property of this queue has not been set");
- }
-
- // Calculate the arrival time of the message, that is, the first
- // cycle the message can be dequeued.
-// printf ("delta %i \n", delta);
- assert(delta>0);
- Time current_time = g_eventQueue_ptr->getTime();
- Time arrival_time = 0;
- if (!RubySystem::getRandomization() || (m_randomization == false)) {
- // No randomization
- arrival_time = current_time + delta;
-
- } else {
- // Randomization - ignore delta
- if (m_strict_fifo) {
- if (m_last_arrival_time < current_time) {
- m_last_arrival_time = current_time;
- }
- arrival_time = m_last_arrival_time + random_time();
- } else {
- arrival_time = current_time + random_time();
+ DEBUG_NEWLINE(QUEUE_COMP, HighPrio);
+ DEBUG_MSG(QUEUE_COMP, HighPrio, "enqueue " + m_name + " time: "
+ + int_to_string(g_eventQueue_ptr->getTime()) + ".");
+ DEBUG_EXPR(QUEUE_COMP, MedPrio, message);
+ DEBUG_NEWLINE(QUEUE_COMP, HighPrio);
+
+ m_msg_counter++;
+ m_size++;
+
+ // record current time incase we have a pop that also adjusts my size
+ if (m_time_last_time_enqueue < g_eventQueue_ptr->getTime()) {
+ m_msgs_this_cycle = 0; // first msg this cycle
+ m_time_last_time_enqueue = g_eventQueue_ptr->getTime();
}
- }
+ m_msgs_this_cycle++;
+
+ // ASSERT(m_max_size == -1 || m_size <= m_max_size + 1);
+ // the plus one is a kluge because of a SLICC issue
- // Check the arrival time
- assert(arrival_time > current_time);
- if (m_strict_fifo) {
- if (arrival_time >= m_last_arrival_time) {
+ if (!m_ordering_set) {
+ // WARN_EXPR(*this);
+ WARN_EXPR(m_name);
+ ERROR_MSG("Ordering property of this queue has not been set");
+ }
+ // Calculate the arrival time of the message, that is, the first
+ // cycle the message can be dequeued.
+ //printf ("delta %i \n", delta);
+ assert(delta>0);
+ Time current_time = g_eventQueue_ptr->getTime();
+ Time arrival_time = 0;
+ if (!RubySystem::getRandomization() || (m_randomization == false)) {
+ // No randomization
+ arrival_time = current_time + delta;
+ } else {
+ // Randomization - ignore delta
+ if (m_strict_fifo) {
+ if (m_last_arrival_time < current_time) {
+ m_last_arrival_time = current_time;
+ }
+ arrival_time = m_last_arrival_time + random_time();
+ } else {
+ arrival_time = current_time + random_time();
+ }
+ }
+
+ // Check the arrival time
+ assert(arrival_time > current_time);
+ if (m_strict_fifo) {
+ if (arrival_time < m_last_arrival_time) {
+ WARN_EXPR(*this);
+ WARN_EXPR(m_name);
+ WARN_EXPR(current_time);
+ WARN_EXPR(delta);
+ WARN_EXPR(arrival_time);
+ WARN_EXPR(m_last_arrival_time);
+ ERROR_MSG("FIFO ordering violated");
+ }
+ }
+ m_last_arrival_time = arrival_time;
+
+ // compute the delay cycles and set enqueue time
+ Message* msg_ptr = message.mod_ref();
+ assert(msg_ptr != NULL);
+
+ assert(g_eventQueue_ptr->getTime() >= msg_ptr->getLastEnqueueTime() &&
+ "ensure we aren't dequeued early");
+
+ msg_ptr->setDelayedCycles(g_eventQueue_ptr->getTime() -
+ msg_ptr->getLastEnqueueTime() +
+ msg_ptr->getDelayedCycles());
+ msg_ptr->setLastEnqueueTime(arrival_time);
+
+ // Insert the message into the priority heap
+ MessageBufferNode thisNode(arrival_time, m_msg_counter, message);
+ m_prio_heap.insert(thisNode);
+
+ DEBUG_NEWLINE(QUEUE_COMP, HighPrio);
+ DEBUG_MSG(QUEUE_COMP, HighPrio, "enqueue " + m_name
+ + " with arrival_time " + int_to_string(arrival_time)
+ + " cur_time: " + int_to_string(g_eventQueue_ptr->getTime())
+ + ".");
+ DEBUG_EXPR(QUEUE_COMP, MedPrio, message);
+ DEBUG_NEWLINE(QUEUE_COMP, HighPrio);
+
+ // Schedule the wakeup
+ if (m_consumer_ptr != NULL) {
+ g_eventQueue_ptr->scheduleEventAbsolute(m_consumer_ptr, arrival_time);
} else {
- WARN_EXPR(*this);
- WARN_EXPR(m_name);
- WARN_EXPR(current_time);
- WARN_EXPR(delta);
- WARN_EXPR(arrival_time);
- WARN_EXPR(m_last_arrival_time);
- ERROR_MSG("FIFO ordering violated");
+ WARN_EXPR(*this);
+ WARN_EXPR(m_name);
+ ERROR_MSG("No consumer");
}
- }
- m_last_arrival_time = arrival_time;
-
- // compute the delay cycles and set enqueue time
- Message* msg_ptr = NULL;
- msg_ptr = message.mod_ref();
- assert(msg_ptr != NULL);
- assert(g_eventQueue_ptr->getTime() >= msg_ptr->getLastEnqueueTime()); // ensure we aren't dequeued early
- msg_ptr->setDelayedCycles((g_eventQueue_ptr->getTime() - msg_ptr->getLastEnqueueTime())+msg_ptr->getDelayedCycles());
- msg_ptr->setLastEnqueueTime(arrival_time);
-
- // Insert the message into the priority heap
- MessageBufferNode thisNode(arrival_time, m_msg_counter, message);
- m_prio_heap.insert(thisNode);
-
- DEBUG_NEWLINE(QUEUE_COMP,HighPrio);
- DEBUG_MSG(QUEUE_COMP,HighPrio,"enqueue " + m_name
- + " with arrival_time " + int_to_string(arrival_time)
- + " cur_time: " + int_to_string(g_eventQueue_ptr->getTime()) + ".");
- DEBUG_EXPR(QUEUE_COMP,MedPrio,message);
- DEBUG_NEWLINE(QUEUE_COMP,HighPrio);
-
- // Schedule the wakeup
- if (m_consumer_ptr != NULL) {
- g_eventQueue_ptr->scheduleEventAbsolute(m_consumer_ptr, arrival_time);
- } else {
- WARN_EXPR(*this);
- WARN_EXPR(m_name);
- ERROR_MSG("No consumer");
- }
}
-int MessageBuffer::dequeue_getDelayCycles(MsgPtr& message)
+int
+MessageBuffer::dequeue_getDelayCycles(MsgPtr& message)
{
- int delay_cycles = -1; // null value
+ int delay_cycles = -1; // null value
- dequeue(message);
+ dequeue(message);
- // get the delay cycles
- delay_cycles = setAndReturnDelayCycles(message);
+ // get the delay cycles
+ delay_cycles = setAndReturnDelayCycles(message);
- assert(delay_cycles >= 0);
- return delay_cycles;
+ assert(delay_cycles >= 0);
+ return delay_cycles;
}
-void MessageBuffer::dequeue(MsgPtr& message)
+void
+MessageBuffer::dequeue(MsgPtr& message)
{
- DEBUG_MSG(QUEUE_COMP,MedPrio,"dequeue from " + m_name);
- message = m_prio_heap.peekMin().m_msgptr;
+ DEBUG_MSG(QUEUE_COMP, MedPrio, "dequeue from " + m_name);
+ message = m_prio_heap.peekMin().m_msgptr;
- pop();
- DEBUG_EXPR(QUEUE_COMP,MedPrio,message);
+ pop();
+ DEBUG_EXPR(QUEUE_COMP, MedPrio, message);
}
-int MessageBuffer::dequeue_getDelayCycles()
+int
+MessageBuffer::dequeue_getDelayCycles()
{
- int delay_cycles = -1; // null value
+ int delay_cycles = -1; // null value
- // get MsgPtr of the message about to be dequeued
- MsgPtr message = m_prio_heap.peekMin().m_msgptr;
+ // get MsgPtr of the message about to be dequeued
+ MsgPtr message = m_prio_heap.peekMin().m_msgptr;
- // get the delay cycles
- delay_cycles = setAndReturnDelayCycles(message);
+ // get the delay cycles
+ delay_cycles = setAndReturnDelayCycles(message);
- dequeue();
+ dequeue();
- assert(delay_cycles >= 0);
- return delay_cycles;
+ assert(delay_cycles >= 0);
+ return delay_cycles;
}
-void MessageBuffer::pop()
+void
+MessageBuffer::pop()
{
- DEBUG_MSG(QUEUE_COMP,MedPrio,"pop from " + m_name);
- assert(isReady());
- m_prio_heap.extractMin();
- // record previous size and time so the current buffer size isn't adjusted until next cycle
- if (m_time_last_time_pop < g_eventQueue_ptr->getTime()) {
- m_size_at_cycle_start = m_size;
- m_time_last_time_pop = g_eventQueue_ptr->getTime();
- }
- m_size--;
+ DEBUG_MSG(QUEUE_COMP, MedPrio, "pop from " + m_name);
+ assert(isReady());
+ m_prio_heap.extractMin();
+ // record previous size and time so the current buffer size isn't
+ // adjusted until next cycle
+ if (m_time_last_time_pop < g_eventQueue_ptr->getTime()) {
+ m_size_at_cycle_start = m_size;
+ m_time_last_time_pop = g_eventQueue_ptr->getTime();
+ }
+ m_size--;
}
-void MessageBuffer::clear()
+void
+MessageBuffer::clear()
{
- while(m_prio_heap.size() > 0){
- m_prio_heap.extractMin();
- }
+ while(m_prio_heap.size() > 0){
+ m_prio_heap.extractMin();
+ }
- ASSERT(m_prio_heap.size() == 0);
+ ASSERT(m_prio_heap.size() == 0);
- m_msg_counter = 0;
- m_size = 0;
- m_time_last_time_enqueue = 0;
- m_time_last_time_pop = 0;
- m_size_at_cycle_start = 0;
- m_msgs_this_cycle = 0;
+ m_msg_counter = 0;
+ m_size = 0;
+ m_time_last_time_enqueue = 0;
+ m_time_last_time_pop = 0;
+ m_size_at_cycle_start = 0;
+ m_msgs_this_cycle = 0;
}
-void MessageBuffer::recycle()
+void
+MessageBuffer::recycle()
{
- DEBUG_MSG(QUEUE_COMP,MedPrio,"recycling " + m_name);
- assert(isReady());
- MessageBufferNode node = m_prio_heap.extractMin();
- node.m_time = g_eventQueue_ptr->getTime() + m_recycle_latency;
- m_prio_heap.insert(node);
- g_eventQueue_ptr->scheduleEventAbsolute(m_consumer_ptr, g_eventQueue_ptr->getTime() + m_recycle_latency);
+ DEBUG_MSG(QUEUE_COMP, MedPrio, "recycling " + m_name);
+ assert(isReady());
+ MessageBufferNode node = m_prio_heap.extractMin();
+ node.m_time = g_eventQueue_ptr->getTime() + m_recycle_latency;
+ m_prio_heap.insert(node);
+ g_eventQueue_ptr->scheduleEventAbsolute(m_consumer_ptr,
+ g_eventQueue_ptr->getTime() + m_recycle_latency);
}
-int MessageBuffer::setAndReturnDelayCycles(MsgPtr& message)
+int
+MessageBuffer::setAndReturnDelayCycles(MsgPtr& message)
{
- int delay_cycles = -1; // null value
+ int delay_cycles = -1; // null value
- // get the delay cycles of the message at the top of the queue
- Message* msg_ptr = message.ref();
+ // 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
- assert(msg_ptr->getLastEnqueueTime() <= g_eventQueue_ptr->getTime());
- msg_ptr->setDelayedCycles((g_eventQueue_ptr->getTime() - msg_ptr->getLastEnqueueTime())+msg_ptr->getDelayedCycles());
- delay_cycles = msg_ptr->getDelayedCycles();
+ // this function should only be called on dequeue
+ // ensure the msg hasn't been enqueued
+ assert(msg_ptr->getLastEnqueueTime() <= g_eventQueue_ptr->getTime());
+ msg_ptr->setDelayedCycles(g_eventQueue_ptr->getTime() -
+ msg_ptr->getLastEnqueueTime() +
+ msg_ptr->getDelayedCycles());
+ delay_cycles = msg_ptr->getDelayedCycles();
- assert(delay_cycles >= 0);
- return delay_cycles;
+ assert(delay_cycles >= 0);
+ return delay_cycles;
}
-void MessageBuffer::print(ostream& out) const
+void
+MessageBuffer::print(ostream& out) const
{
- out << "[MessageBuffer: ";
- if (m_consumer_ptr != NULL) {
- out << " consumer-yes ";
- }
- out << m_prio_heap << "] " << m_name << endl;
+ out << "[MessageBuffer: ";
+ if (m_consumer_ptr != NULL) {
+ out << " consumer-yes ";
+ }
+ out << m_prio_heap << "] " << m_name << endl;
}
-void MessageBuffer::printStats(ostream& out)
+void
+MessageBuffer::printStats(ostream& out)
{
- out << "MessageBuffer: " << m_name << " stats - msgs:" << m_msg_counter << " full:" << m_not_avail_count << endl;
+ out << "MessageBuffer: " << m_name << " stats - msgs:" << m_msg_counter
+ << " full:" << m_not_avail_count << endl;
}
-
diff --git a/src/mem/ruby/buffers/MessageBuffer.hh b/src/mem/ruby/buffers/MessageBuffer.hh
index 8d5a8de25..8fc86af97 100644
--- a/src/mem/ruby/buffers/MessageBuffer.hh
+++ b/src/mem/ruby/buffers/MessageBuffer.hh
@@ -1,4 +1,3 @@
-
/*
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* All rights reserved.
@@ -28,137 +27,156 @@
*/
/*
- * $Id$
- *
- * Description: Unordered buffer of messages that can be inserted such
+ * Unordered buffer of messages that can be inserted such
* that they can be dequeued after a given delta time has expired.
- *
*/
-#ifndef MESSAGEBUFFER_H
-#define MESSAGEBUFFER_H
+#ifndef __MEM_RUBY_BUFFERS_MESSAGEBUFFER_HH__
+#define __MEM_RUBY_BUFFERS_MESSAGEBUFFER_HH__
#include <iostream>
#include <string>
-#include "mem/ruby/common/Global.hh"
+#include "mem/gems_common/PrioHeap.hh"
+#include "mem/gems_common/util.hh"
#include "mem/ruby/buffers/MessageBufferNode.hh"
#include "mem/ruby/common/Consumer.hh"
+#include "mem/ruby/common/Global.hh"
#include "mem/ruby/eventqueue/RubyEventQueue.hh"
#include "mem/ruby/slicc_interface/Message.hh"
-#include "mem/gems_common/PrioHeap.hh"
-#include "mem/gems_common/util.hh"
-class MessageBuffer {
-public:
- // Constructors
- MessageBuffer(const std::string &name = "");
-
- // ~MessageBuffer()
-
- // Public Methods
-
- static void printConfig(std::ostream& out) {}
- void setRecycleLatency(int recycle_latency) { m_recycle_latency = recycle_latency; }
-
- // TRUE if head of queue timestamp <= SystemTime
- bool isReady() const {
- return ((m_prio_heap.size() > 0) &&
- (m_prio_heap.peekMin().m_time <= g_eventQueue_ptr->getTime()));
- }
-
- void delayHead() {
- MessageBufferNode node = m_prio_heap.extractMin();
- enqueue(node.m_msgptr, 1);
- }
-
- bool areNSlotsAvailable(int n);
- int getPriority() { return m_priority_rank; }
- void setPriority(int rank) { m_priority_rank = rank; }
- void setConsumer(Consumer* consumer_ptr) { ASSERT(m_consumer_ptr==NULL); m_consumer_ptr = consumer_ptr; }
- void setDescription(const std::string& name) { m_name = name; }
- std::string getDescription() { return m_name;}
-
- Consumer* getConsumer() { return m_consumer_ptr; }
-
- const Message* peekAtHeadOfQueue() const;
- const Message* peek() const { return peekAtHeadOfQueue(); }
- const MsgPtr getMsgPtrCopy() const;
- const MsgPtr& peekMsgPtr() const { assert(isReady()); return m_prio_heap.peekMin().m_msgptr; }
- const MsgPtr& peekMsgPtrEvenIfNotReady() const {return m_prio_heap.peekMin().m_msgptr; }
-
- void enqueue(const MsgPtr& message) { enqueue(message, 1); }
- void enqueue(const MsgPtr& message, Time delta);
- // void enqueueAbsolute(const MsgPtr& message, Time absolute_time);
- int dequeue_getDelayCycles(MsgPtr& message); // returns delay cycles of the message
- void dequeue(MsgPtr& message);
- int dequeue_getDelayCycles(); // returns delay cycles of the message
- void dequeue() { pop(); }
- void pop();
- void recycle();
- bool isEmpty() const { return m_prio_heap.size() == 0; }
-
- void setOrdering(bool order) { m_strict_fifo = order; m_ordering_set = true; }
- void setSize(int size) {m_max_size = size;}
- int getSize();
- void setRandomization(bool random_flag) { m_randomization = random_flag; }
-
- void clear();
-
- void print(std::ostream& out) const;
- void printStats(std::ostream& out);
- void clearStats() { m_not_avail_count = 0; m_msg_counter = 0; }
-
-private:
- //added by SS
- int m_recycle_latency;
-
- // Private Methods
- int setAndReturnDelayCycles(MsgPtr& message);
-
- // Private copy constructor and assignment operator
- MessageBuffer(const MessageBuffer& obj);
- MessageBuffer& operator=(const MessageBuffer& obj);
-
- // Data Members (m_ prefix)
- Consumer* m_consumer_ptr; // Consumer to signal a wakeup(), can be NULL
- PrioHeap<MessageBufferNode> m_prio_heap;
- std::string m_name;
-
- int m_max_size;
- int m_size;
-
- Time m_time_last_time_size_checked;
- int m_size_last_time_size_checked;
-
- // variables used so enqueues appear to happen imediately, while pop happen the next cycle
- Time m_time_last_time_enqueue;
- Time m_time_last_time_pop;
- int m_size_at_cycle_start;
- int m_msgs_this_cycle;
-
- int m_not_avail_count; // count the # of times I didn't have N slots available
- int m_msg_counter;
- int m_priority_rank;
- bool m_strict_fifo;
- bool m_ordering_set;
- bool m_randomization;
- Time m_last_arrival_time;
+class MessageBuffer
+{
+ public:
+ MessageBuffer(const std::string &name = "");
+
+ static void printConfig(std::ostream& out) {}
+ void
+ setRecycleLatency(int recycle_latency)
+ {
+ m_recycle_latency = recycle_latency;
+ }
+
+ // TRUE if head of queue timestamp <= SystemTime
+ bool
+ isReady() const
+ {
+ return ((m_prio_heap.size() > 0) &&
+ (m_prio_heap.peekMin().m_time <= g_eventQueue_ptr->getTime()));
+ }
+
+ void
+ delayHead()
+ {
+ MessageBufferNode node = m_prio_heap.extractMin();
+ enqueue(node.m_msgptr, 1);
+ }
+
+ bool areNSlotsAvailable(int n);
+ int getPriority() { return m_priority_rank; }
+ void setPriority(int rank) { m_priority_rank = rank; }
+ void setConsumer(Consumer* consumer_ptr)
+ {
+ ASSERT(m_consumer_ptr == NULL);
+ m_consumer_ptr = consumer_ptr;
+ }
+
+ void setDescription(const std::string& name) { m_name = name; }
+ std::string getDescription() { return m_name;}
+
+ Consumer* getConsumer() { return m_consumer_ptr; }
+
+ const Message* peekAtHeadOfQueue() const;
+ const Message* peek() const { return peekAtHeadOfQueue(); }
+ const MsgPtr getMsgPtrCopy() const;
+
+ const MsgPtr&
+ peekMsgPtr() const
+ {
+ assert(isReady());
+ return m_prio_heap.peekMin().m_msgptr;
+ }
+
+ const MsgPtr&
+ peekMsgPtrEvenIfNotReady() const
+ {
+ return m_prio_heap.peekMin().m_msgptr;
+ }
+
+ void enqueue(const MsgPtr& message) { enqueue(message, 1); }
+ void enqueue(const MsgPtr& message, Time delta);
+ // void enqueueAbsolute(const MsgPtr& message, Time absolute_time);
+ int dequeue_getDelayCycles(MsgPtr& message); // returns delay
+ // cycles of the
+ // message
+ void dequeue(MsgPtr& message);
+ int dequeue_getDelayCycles(); // returns delay cycles of the message
+ void dequeue() { pop(); }
+ void pop();
+ void recycle();
+ bool isEmpty() const { return m_prio_heap.size() == 0; }
+
+ void
+ setOrdering(bool order)
+ {
+ m_strict_fifo = order;
+ m_ordering_set = true;
+ }
+ void setSize(int size) { m_max_size = size; }
+ int getSize();
+ void setRandomization(bool random_flag) { m_randomization = random_flag; }
+
+ void clear();
+
+ void print(std::ostream& out) const;
+ void printStats(std::ostream& out);
+ void clearStats() { m_not_avail_count = 0; m_msg_counter = 0; }
+
+ private:
+ //added by SS
+ int m_recycle_latency;
+
+ // Private Methods
+ int setAndReturnDelayCycles(MsgPtr& message);
+
+ // Private copy constructor and assignment operator
+ MessageBuffer(const MessageBuffer& obj);
+ MessageBuffer& operator=(const MessageBuffer& obj);
+
+ // Data Members (m_ prefix)
+ Consumer* m_consumer_ptr; // Consumer to signal a wakeup(), can be NULL
+ PrioHeap<MessageBufferNode> m_prio_heap;
+ std::string m_name;
+
+ int m_max_size;
+ int m_size;
+
+ Time m_time_last_time_size_checked;
+ int m_size_last_time_size_checked;
+
+ // variables used so enqueues appear to happen imediately, while
+ // pop happen the next cycle
+ Time m_time_last_time_enqueue;
+ Time m_time_last_time_pop;
+ int m_size_at_cycle_start;
+ int m_msgs_this_cycle;
+
+ int m_not_avail_count; // count the # of times I didn't have N
+ // slots available
+ int m_msg_counter;
+ int m_priority_rank;
+ bool m_strict_fifo;
+ bool m_ordering_set;
+ bool m_randomization;
+ Time m_last_arrival_time;
};
-// Output operator declaration
-//template <class TYPE>
-std::ostream& operator<<(std::ostream& out, const MessageBuffer& obj);
-
-// ******************* Definitions *******************
-
-// Output operator definition
-extern inline
-std::ostream& operator<<(std::ostream& out, const MessageBuffer& obj)
+inline std::ostream&
+operator<<(std::ostream& out, const MessageBuffer& obj)
{
- obj.print(out);
- out << std::flush;
- return out;
+ obj.print(out);
+ out << std::flush;
+ return out;
}
-#endif //MESSAGEBUFFER_H
+#endif // __MEM_RUBY_BUFFERS_MESSAGEBUFFER_HH__
diff --git a/src/mem/ruby/buffers/MessageBufferNode.cc b/src/mem/ruby/buffers/MessageBufferNode.cc
index aec977acd..698eeab25 100644
--- a/src/mem/ruby/buffers/MessageBufferNode.cc
+++ b/src/mem/ruby/buffers/MessageBufferNode.cc
@@ -1,4 +1,3 @@
-
/*
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* All rights reserved.
@@ -32,9 +31,9 @@
void
MessageBufferNode::print(std::ostream& out) const
{
- out << "[";
- out << m_time << ", ";
- out << m_msg_counter << ", ";
- out << m_msgptr << "; ";
- out << "]";
+ out << "[";
+ out << m_time << ", ";
+ out << m_msg_counter << ", ";
+ out << m_msgptr << "; ";
+ out << "]";
}
diff --git a/src/mem/ruby/buffers/MessageBufferNode.hh b/src/mem/ruby/buffers/MessageBufferNode.hh
index 747c1d889..9ead9b9aa 100644
--- a/src/mem/ruby/buffers/MessageBufferNode.hh
+++ b/src/mem/ruby/buffers/MessageBufferNode.hh
@@ -1,4 +1,3 @@
-
/*
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* All rights reserved.
@@ -27,64 +26,55 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef MESSAGEBUFFERNODE_H
-#define MESSAGEBUFFERNODE_H
+#ifndef __MEM_RUBY_BUFFERS_MESSAGEBUFFERNODE_HH__
+#define __MEM_RUBY_BUFFERS_MESSAGEBUFFERNODE_HH__
#include <iostream>
#include "mem/ruby/common/Global.hh"
#include "mem/ruby/slicc_interface/Message.hh"
-class MessageBufferNode {
-public:
- // Constructors
- MessageBufferNode() { m_time = 0; m_msg_counter = 0; }
- MessageBufferNode(const Time& time, int counter, const MsgPtr& msgptr)
- { m_time = time; m_msgptr = msgptr; m_msg_counter = counter; }
- // Destructor
- //~MessageBufferNode();
+class MessageBufferNode
+{
+ public:
+ MessageBufferNode()
+ {
+ m_time = 0;
+ m_msg_counter = 0;
+ }
- // Public Methods
- void print(std::ostream& out) const;
-private:
- // Private Methods
+ MessageBufferNode(const Time& time, int counter, const MsgPtr& msgptr)
+ {
+ m_time = time;
+ m_msgptr = msgptr;
+ m_msg_counter = counter;
+ }
- // Default copy constructor and assignment operator
- // MessageBufferNode(const MessageBufferNode& obj);
- // MessageBufferNode& operator=(const MessageBufferNode& obj);
+ void print(std::ostream& out) const;
- // Data Members (m_ prefix)
-public:
- Time m_time;
- int m_msg_counter; // FIXME, should this be a 64-bit value?
- MsgPtr m_msgptr;
+ public:
+ Time m_time;
+ int m_msg_counter; // FIXME, should this be a 64-bit value?
+ MsgPtr m_msgptr;
};
-// Output operator declaration
-std::ostream& operator<<(std::ostream& out, const MessageBufferNode& obj);
-
-// ******************* Definitions *******************
-
-inline extern bool node_less_then_eq(const MessageBufferNode& n1, const MessageBufferNode& n2);
-
-inline extern
-bool node_less_then_eq(const MessageBufferNode& n1, const MessageBufferNode& n2)
+inline bool
+node_less_then_eq(const MessageBufferNode& n1, const MessageBufferNode& n2)
{
- if (n1.m_time == n2.m_time) {
- assert(n1.m_msg_counter != n2.m_msg_counter);
- return (n1.m_msg_counter <= n2.m_msg_counter);
- } else {
- return (n1.m_time <= n2.m_time);
- }
+ if (n1.m_time == n2.m_time) {
+ assert(n1.m_msg_counter != n2.m_msg_counter);
+ return (n1.m_msg_counter <= n2.m_msg_counter);
+ } else {
+ return (n1.m_time <= n2.m_time);
+ }
}
-// Output operator definition
-extern inline
-std::ostream& operator<<(std::ostream& out, const MessageBufferNode& obj)
+inline std::ostream&
+operator<<(std::ostream& out, const MessageBufferNode& obj)
{
- obj.print(out);
- out << std::flush;
- return out;
+ obj.print(out);
+ out << std::flush;
+ return out;
}
-#endif //MESSAGEBUFFERNODE_H
+#endif // __MEM_RUBY_BUFFERS_MESSAGEBUFFERNODE_HH__