diff options
Diffstat (limited to 'src/mem')
92 files changed, 6854 insertions, 8056 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__ diff --git a/src/mem/ruby/common/Address.cc b/src/mem/ruby/common/Address.cc index b4ad39294..e74bdb47b 100644 --- a/src/mem/ruby/common/Address.cc +++ b/src/mem/ruby/common/Address.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,42 +26,41 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - */ - #include "mem/ruby/common/Address.hh" -void Address::output(ostream& out) const +void +Address::output(ostream& out) const { - // Note: this outputs addresses in the form "ffff", not "0xffff". - // This code should always be able to write out addresses in a - // format that can be read in by the below input() method. Please - // don't change this without talking to Milo first. - out << hex << m_address << dec; + // Note: this outputs addresses in the form "ffff", not "0xffff". + // This code should always be able to write out addresses in a + // format that can be read in by the below input() method. Please + // don't change this without talking to Milo first. + out << hex << m_address << dec; } -void Address::input(istream& in) +void +Address::input(istream& in) { - // Note: this only works with addresses in the form "ffff", not - // "0xffff". This code should always be able to read in addresses - // written out by the above output() method. Please don't change - // this without talking to Milo first. - in >> hex >> m_address >> dec; + // Note: this only works with addresses in the form "ffff", not + // "0xffff". This code should always be able to read in addresses + // written out by the above output() method. Please don't change + // this without talking to Milo first. + in >> hex >> m_address >> dec; } Address::Address(const Address& obj) { - m_address = obj.m_address; + m_address = obj.m_address; } -Address& Address::operator=(const Address& obj) +Address& +Address::operator=(const Address& obj) { - if (this == &obj) { - // assert(false); - } else { - m_address = obj.m_address; - } - return *this; + if (this == &obj) { + // assert(false); + } else { + m_address = obj.m_address; + } + return *this; } diff --git a/src/mem/ruby/common/Address.hh b/src/mem/ruby/common/Address.hh index 7da5ed0fe..73327e617 100644 --- a/src/mem/ruby/common/Address.hh +++ b/src/mem/ruby/common/Address.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,20 +26,16 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - */ - -#ifndef ADDRESS_H -#define ADDRESS_H +#ifndef __MEM_RUBY_COMMON_ADDRESS_HH__ +#define __MEM_RUBY_COMMON_ADDRESS_HH__ #include <iomanip> #include "base/hashmap.hh" #include "mem/ruby/common/Global.hh" -#include "mem/ruby/system/System.hh" -#include "mem/ruby/system/NodeID.hh" #include "mem/ruby/system/MachineID.hh" +#include "mem/ruby/system/NodeID.hh" +#include "mem/ruby/system/System.hh" const int ADDRESS_WIDTH = 64; // address width in bytes @@ -48,124 +43,131 @@ class Address; typedef Address PhysAddress; typedef Address VirtAddress; -class Address { -public: - // Constructors - Address() { m_address = 0; } - explicit Address(physical_address_t address) { m_address = address; } - - Address(const Address& obj); - Address& operator=(const Address& obj); - - // Destructor - // ~Address(); - - // Public Methods - - void setAddress(physical_address_t address) { m_address = address; } - physical_address_t getAddress() const {return m_address;} - // selects bits inclusive - physical_address_t bitSelect(int small, int big) const; - physical_address_t bitRemove(int small, int big) const; - physical_address_t maskLowOrderBits(int number) const; - physical_address_t maskHighOrderBits(int number) const; - physical_address_t shiftLowOrderBits(int number) const; - physical_address_t getLineAddress() const - { return bitSelect(RubySystem::getBlockSizeBits(), ADDRESS_WIDTH); } - physical_address_t getOffset() const - { return bitSelect(0, RubySystem::getBlockSizeBits()-1); } - - void makeLineAddress() { m_address = maskLowOrderBits(RubySystem::getBlockSizeBits()); } - // returns the next stride address based on line address - void makeNextStrideAddress( int stride) { - m_address = maskLowOrderBits(RubySystem::getBlockSizeBits()) - + RubySystem::getBlockSizeBytes()*stride; - } - int getBankSetNum() const; - int getBankSetDist() const; +class Address +{ + public: + Address() + : m_address(0) + { } + + explicit + Address(physical_address_t address) + : m_address(address) + { } + + Address(const Address& obj); + Address& operator=(const Address& obj); + + void setAddress(physical_address_t address) { m_address = address; } + physical_address_t getAddress() const {return m_address;} + // selects bits inclusive + physical_address_t bitSelect(int small, int big) const; + physical_address_t bitRemove(int small, int big) const; + physical_address_t maskLowOrderBits(int number) const; + physical_address_t maskHighOrderBits(int number) const; + physical_address_t shiftLowOrderBits(int number) const; + + physical_address_t + getLineAddress() const + { + return bitSelect(RubySystem::getBlockSizeBits(), ADDRESS_WIDTH); + } - Index memoryModuleIndex() const; + physical_address_t + getOffset() const + { + return bitSelect(0, RubySystem::getBlockSizeBits() - 1); + } - void print(ostream& out) const; - void output(ostream& out) const; - void input(istream& in); + void + makeLineAddress() + { + m_address = maskLowOrderBits(RubySystem::getBlockSizeBits()); + } - void setOffset( int offset ){ - // first, zero out the offset bits - makeLineAddress(); - m_address |= (physical_address_t) offset; - } + // returns the next stride address based on line address + void + makeNextStrideAddress(int stride) + { + m_address = maskLowOrderBits(RubySystem::getBlockSizeBits()) + + RubySystem::getBlockSizeBytes()*stride; + } -private: - // Private Methods + int getBankSetNum() const; + int getBankSetDist() const; - // Private copy constructor and assignment operator - // Address(const Address& obj); - // Address& operator=(const Address& obj); + Index memoryModuleIndex() const; - // Data Members (m_ prefix) - physical_address_t m_address; -}; + void print(ostream& out) const; + void output(ostream& out) const; + void input(istream& in); -inline -Address line_address(const Address& addr) { Address temp(addr); temp.makeLineAddress(); return temp; } + void + setOffset(int offset) + { + // first, zero out the offset bits + makeLineAddress(); + m_address |= (physical_address_t) offset; + } -// Output operator declaration -ostream& operator<<(ostream& out, const Address& obj); -// comparison operator declaration -bool operator==(const Address& obj1, const Address& obj2); -bool operator!=(const Address& obj1, const Address& obj2); -bool operator<(const Address& obj1, const Address& obj2); -/* Address& operator=(const physical_address_t address); */ + private: + physical_address_t m_address; +}; -inline -bool operator<(const Address& obj1, const Address& obj2) +inline Address +line_address(const Address& addr) { - return obj1.getAddress() < obj2.getAddress(); + Address temp(addr); + temp.makeLineAddress(); + return temp; } -// ******************* Definitions ******************* +inline bool +operator<(const Address& obj1, const Address& obj2) +{ + return obj1.getAddress() < obj2.getAddress(); +} -// Output operator definition -inline -ostream& operator<<(ostream& out, const Address& obj) +inline ostream& +operator<<(ostream& out, const Address& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } -inline -bool operator==(const Address& obj1, const Address& obj2) +inline bool +operator==(const Address& obj1, const Address& obj2) { - return (obj1.getAddress() == obj2.getAddress()); + return (obj1.getAddress() == obj2.getAddress()); } -inline -bool operator!=(const Address& obj1, const Address& obj2) +inline bool +operator!=(const Address& obj1, const Address& obj2) { - return (obj1.getAddress() != obj2.getAddress()); + return (obj1.getAddress() != obj2.getAddress()); } -inline -physical_address_t Address::bitSelect(int small, int big) const // rips bits inclusive +// rips bits inclusive +inline physical_address_t +Address::bitSelect(int small, int big) const { - physical_address_t mask; - assert((unsigned)big >= (unsigned)small); + physical_address_t mask; + assert((unsigned)big >= (unsigned)small); - if (big >= ADDRESS_WIDTH - 1) { - return (m_address >> small); - } else { - mask = ~((physical_address_t)~0 << (big + 1)); - // FIXME - this is slow to manipulate a 64-bit number using 32-bits - physical_address_t partial = (m_address & mask); - return (partial >> small); - } + if (big >= ADDRESS_WIDTH - 1) { + return (m_address >> small); + } else { + mask = ~((physical_address_t)~0 << (big + 1)); + // FIXME - this is slow to manipulate a 64-bit number using 32-bits + physical_address_t partial = (m_address & mask); + return (partial >> small); + } } // removes bits inclusive -inline -physical_address_t Address::bitRemove(int small, int big) const +inline physical_address_t +Address::bitRemove(int small, int big) const { physical_address_t mask; assert((unsigned)big >= (unsigned)small); @@ -184,60 +186,64 @@ physical_address_t Address::bitRemove(int small, int big) const mask = (physical_address_t)~0 << (big + 1); physical_address_t higher_bits = m_address & mask; - // // Shift the valid high bits over the removed section - // higher_bits = higher_bits >> (big - small); return (higher_bits | lower_bits); } } -inline -physical_address_t Address::maskLowOrderBits(int number) const +inline physical_address_t +Address::maskLowOrderBits(int number) const { physical_address_t mask; if (number >= ADDRESS_WIDTH - 1) { - mask = ~0; + mask = ~0; } else { - mask = (physical_address_t)~0 << number; + mask = (physical_address_t)~0 << number; } return (m_address & mask); } -inline -physical_address_t Address::maskHighOrderBits(int number) const +inline physical_address_t +Address::maskHighOrderBits(int number) const { - physical_address_t mask; + physical_address_t mask; - if (number >= ADDRESS_WIDTH - 1) { - mask = ~0; - } else { - mask = (physical_address_t)~0 >> number; - } - return (m_address & mask); + if (number >= ADDRESS_WIDTH - 1) { + mask = ~0; + } else { + mask = (physical_address_t)~0 >> number; + } + return (m_address & mask); } -inline -physical_address_t Address::shiftLowOrderBits(int number) const +inline physical_address_t +Address::shiftLowOrderBits(int number) const { - return (m_address >> number); + return (m_address >> number); } -inline -integer_t Address::memoryModuleIndex() const +inline integer_t +Address::memoryModuleIndex() const { - integer_t index = bitSelect(RubySystem::getBlockSizeBits()+RubySystem::getMemorySizeBits(), ADDRESS_WIDTH); - assert (index >= 0); - return index; - - // Index indexHighPortion = address.bitSelect(MEMORY_SIZE_BITS-1, PAGE_SIZE_BITS+NUMBER_OF_MEMORY_MODULE_BITS); - // Index indexLowPortion = address.bitSelect(DATA_BLOCK_BITS, PAGE_SIZE_BITS-1); - - //Index index = indexLowPortion | (indexHighPortion << (PAGE_SIZE_BITS - DATA_BLOCK_BITS)); - - /* - Round-robin mapping of addresses, at page size granularity + integer_t index = + bitSelect(RubySystem::getBlockSizeBits() + + RubySystem::getMemorySizeBits(), ADDRESS_WIDTH); + assert (index >= 0); + return index; + + // Index indexHighPortion = + // address.bitSelect(MEMORY_SIZE_BITS - 1, + // PAGE_SIZE_BITS + NUMBER_OF_MEMORY_MODULE_BITS); + // Index indexLowPortion = + // address.bitSelect(DATA_BLOCK_BITS, PAGE_SIZE_BITS - 1); + // + // Index index = indexLowPortion | + // (indexHighPortion << (PAGE_SIZE_BITS - DATA_BLOCK_BITS)); + + /* + Round-robin mapping of addresses, at page size granularity ADDRESS_WIDTH MEMORY_SIZE_BITS PAGE_SIZE_BITS DATA_BLOCK_BITS | | | | @@ -249,29 +255,39 @@ ADDRESS_WIDTH MEMORY_SIZE_BITS PAGE_SIZE_BITS DATA_BLOCK_BITS indexHighPortion indexLowPortion <-------> NUMBER_OF_MEMORY_MODULE_BITS - */ + */ } -inline -void Address::print(ostream& out) const +inline void +Address::print(ostream& out) const { using namespace std; - out << "[" << hex << "0x" << m_address << "," << " line 0x" << maskLowOrderBits(RubySystem::getBlockSizeBits()) << dec << "]" << flush; + out << "[" << hex << "0x" << m_address << "," << " line 0x" + << maskLowOrderBits(RubySystem::getBlockSizeBits()) << dec << "]" + << flush; } class Address; namespace __hash_namespace { - template <> struct hash<Address> - { - size_t operator()(const Address &s) const { return (size_t) s.getAddress(); } - }; -} -namespace std { - template <> struct equal_to<Address> - { - bool operator()(const Address& s1, const Address& s2) const { return s1 == s2; } - }; -} +template <> struct hash<Address> +{ + size_t + operator()(const Address &s) const + { + return (size_t)s.getAddress(); + } +}; +/* namespace __hash_namespace */ } -#endif //ADDRESS_H +namespace std { +template <> struct equal_to<Address> +{ + bool + operator()(const Address& s1, const Address& s2) const + { + return s1 == s2; + } +}; +/* namespace std */ } +#endif // __MEM_RUBY_COMMON_ADDRESS_HH__ diff --git a/src/mem/ruby/common/Consumer.hh b/src/mem/ruby/common/Consumer.hh index e541ef615..c1f8bc42e 100644 --- a/src/mem/ruby/common/Consumer.hh +++ b/src/mem/ruby/common/Consumer.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -28,16 +27,13 @@ */ /* - * $Id$ - * - * Description: This is the virtual base class of all classes that can - * be the targets of wakeup events. There is only two methods, - * wakeup() and print() and no data members. - * + * This is the virtual base class of all classes that can be the + * targets of wakeup events. There is only two methods, wakeup() and + * print() and no data members. */ -#ifndef CONSUMER_H -#define CONSUMER_H +#ifndef __MEM_RUBY_COMMON_CONSUMER_HH__ +#define __MEM_RUBY_COMMON_CONSUMER_HH__ #include <iostream> #include <set> @@ -47,68 +43,74 @@ class MessageBuffer; -class Consumer { -public: - // Constructors - Consumer() { m_last_scheduled_wakeup = 0; m_last_wakeup = 0; } - - // Destructor - virtual ~Consumer() { } - - // Public Methods - pure virtual methods - void triggerWakeup(RubyEventQueue * eventQueue) - { - Time time = eventQueue->getTime(); - if (m_last_wakeup != time) { - wakeup(); m_last_wakeup = time; - } - } - virtual void wakeup() = 0; - virtual void print(std::ostream& out) const = 0; - const Time& getLastScheduledWakeup() const - { - return m_last_scheduled_wakeup; - } - void setLastScheduledWakeup(const Time& time) - { - m_last_scheduled_wakeup = time; - } - bool alreadyScheduled(Time time) - { - return (m_scheduled_wakeups.find(time) != m_scheduled_wakeups.end()); - } - void insertScheduledWakeupTime(Time time) - { - m_scheduled_wakeups.insert(time); - } - void removeScheduledWakeupTime(Time time) - { - assert(alreadyScheduled(time)); - m_scheduled_wakeups.erase(time); - } - -private: - // Private Methods - - // Data Members (m_ prefix) - Time m_last_scheduled_wakeup; - std::set<Time> m_scheduled_wakeups; - Time m_last_wakeup; -}; +class Consumer +{ + public: + Consumer() + : m_last_scheduled_wakeup(0), m_last_wakeup(0) + { + } + + virtual + ~Consumer() + { } + + void + triggerWakeup(RubyEventQueue *eventQueue) + { + Time time = eventQueue->getTime(); + if (m_last_wakeup != time) { + wakeup(); + m_last_wakeup = time; + } + } -// Output operator declaration -inline extern -std::ostream& operator<<(std::ostream& out, const Consumer& obj); + virtual void wakeup() = 0; + virtual void print(std::ostream& out) const = 0; -// ******************* Definitions ******************* + const Time& + getLastScheduledWakeup() const + { + return m_last_scheduled_wakeup; + } + + void + setLastScheduledWakeup(const Time& time) + { + m_last_scheduled_wakeup = time; + } + + bool + alreadyScheduled(Time time) + { + return m_scheduled_wakeups.find(time) != m_scheduled_wakeups.end(); + } + + void + insertScheduledWakeupTime(Time time) + { + m_scheduled_wakeups.insert(time); + } + + void + removeScheduledWakeupTime(Time time) + { + assert(alreadyScheduled(time)); + m_scheduled_wakeups.erase(time); + } + + private: + Time m_last_scheduled_wakeup; + std::set<Time> m_scheduled_wakeups; + Time m_last_wakeup; +}; -// Output operator definition -inline extern -std::ostream& operator<<(std::ostream& out, const Consumer& obj) +inline std::ostream& +operator<<(std::ostream& out, const Consumer& obj) { - obj.print(out); - out << std::flush; - return out; + obj.print(out); + out << std::flush; + return out; } -#endif //CONSUMER_H +#endif // __MEM_RUBY_COMMON_CONSUMER_HH__ diff --git a/src/mem/ruby/common/DataBlock.cc b/src/mem/ruby/common/DataBlock.cc index 75ede7f4f..8d3c81242 100644 --- a/src/mem/ruby/common/DataBlock.cc +++ b/src/mem/ruby/common/DataBlock.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -32,13 +31,14 @@ DataBlock & DataBlock::operator=(const DataBlock & obj) { - if (this == &obj) { - // assert(false); - } else { - if (!m_alloc) - m_data = new uint8[RubySystem::getBlockSizeBytes()]; - memcpy(m_data, obj.m_data, RubySystem::getBlockSizeBytes()); - m_alloc = true; - } - return *this; + if (this == &obj) { + // assert(false); + } else { + if (!m_alloc) + m_data = new uint8[RubySystem::getBlockSizeBytes()]; + memcpy(m_data, obj.m_data, RubySystem::getBlockSizeBytes()); + m_alloc = true; + } + + return *this; } diff --git a/src/mem/ruby/common/DataBlock.hh b/src/mem/ruby/common/DataBlock.hh index 5407033bf..edf774166 100644 --- a/src/mem/ruby/common/DataBlock.hh +++ b/src/mem/ruby/common/DataBlock.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,152 +26,144 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef DATABLOCK_H -#define DATABLOCK_H +#ifndef __MEM_RUBY_COMMON_DATABLOCK_HH__ +#define __MEM_RUBY_COMMON_DATABLOCK_HH__ #include <iomanip> #include <iostream> +#include "mem/gems_common/Vector.hh" #include "mem/ruby/common/Global.hh" #include "mem/ruby/system/System.hh" -#include "mem/gems_common/Vector.hh" -class DataBlock { - public: - // Constructors - DataBlock() {alloc();} - DataBlock(const DataBlock & cp) { - m_data = new uint8[RubySystem::getBlockSizeBytes()]; - memcpy(m_data, cp.m_data, RubySystem::getBlockSizeBytes()); - m_alloc = true; - } +class DataBlock +{ + public: + DataBlock() + { + alloc(); + } - // Destructor - ~DataBlock() { - if(m_alloc) { - delete [] m_data; + DataBlock(const DataBlock &cp) + { + m_data = new uint8[RubySystem::getBlockSizeBytes()]; + memcpy(m_data, cp.m_data, RubySystem::getBlockSizeBytes()); + m_alloc = true; } - } - - DataBlock& operator=(const DataBlock& obj); - - // Public Methods - void assign(uint8* data); - - void clear(); - uint8 getByte(int whichByte) const; - const uint8* getData(int offset, int len) const; - void setByte(int whichByte, uint8 data); - void setData(uint8* data, int offset, int len); - void copyPartial(const DataBlock & dblk, int offset, int len); - bool equal(const DataBlock& obj) const; - void print(std::ostream& out) const; - -private: - void alloc(); - // Data Members (m_ prefix) - uint8* m_data; - bool m_alloc; -}; -// Output operator declaration -std::ostream& operator<<(std::ostream& out, const DataBlock& obj); + ~DataBlock() + { + if (m_alloc) + delete [] m_data; + } + + DataBlock& operator=(const DataBlock& obj); + + void assign(uint8* data); -bool operator==(const DataBlock& obj1, const DataBlock& obj2); + void clear(); + uint8 getByte(int whichByte) const; + const uint8* getData(int offset, int len) const; + void setByte(int whichByte, uint8 data); + void setData(uint8* data, int offset, int len); + void copyPartial(const DataBlock & dblk, int offset, int len); + bool equal(const DataBlock& obj) const; + void print(std::ostream& out) const; -// inline functions for speed + private: + void alloc(); + uint8* m_data; + bool m_alloc; +}; -inline -void DataBlock::assign(uint8* data) +inline void +DataBlock::assign(uint8* data) { - if (m_alloc) { - delete [] m_data; - } - m_data = data; - m_alloc = false; + if (m_alloc) { + delete [] m_data; + } + m_data = data; + m_alloc = false; } -inline -void DataBlock::alloc() +inline void +DataBlock::alloc() { - m_data = new uint8[RubySystem::getBlockSizeBytes()]; - m_alloc = true; - clear(); + m_data = new uint8[RubySystem::getBlockSizeBytes()]; + m_alloc = true; + clear(); } -inline -void DataBlock::clear() +inline void +DataBlock::clear() { - memset(m_data, 0, RubySystem::getBlockSizeBytes()); + memset(m_data, 0, RubySystem::getBlockSizeBytes()); } -inline -bool DataBlock::equal(const DataBlock& obj) const +inline bool +DataBlock::equal(const DataBlock& obj) const { - return !memcmp(m_data, obj.m_data, RubySystem::getBlockSizeBytes()); + return !memcmp(m_data, obj.m_data, RubySystem::getBlockSizeBytes()); } -inline -void DataBlock::print(std::ostream& out) const +inline void +DataBlock::print(std::ostream& out) const { - using namespace std; - - int size = RubySystem::getBlockSizeBytes(); - out << "[ "; - for (int i = 0; i < size; i++) { - out << setw(2) << setfill('0') << hex << "0x" << (int)m_data[i] << " "; - out << setfill(' '); - } - out << dec << "]" << flush; + using namespace std; + + int size = RubySystem::getBlockSizeBytes(); + out << "[ "; + for (int i = 0; i < size; i++) { + out << setw(2) << setfill('0') << hex << "0x" << (int)m_data[i] << " "; + out << setfill(' '); + } + out << dec << "]" << flush; } -inline -uint8 DataBlock::getByte(int whichByte) const +inline uint8 +DataBlock::getByte(int whichByte) const { - return m_data[whichByte]; + return m_data[whichByte]; } -inline -const uint8* DataBlock::getData(int offset, int len) const +inline const uint8* +DataBlock::getData(int offset, int len) const { - assert(offset + len <= RubySystem::getBlockSizeBytes()); - return &m_data[offset]; + assert(offset + len <= RubySystem::getBlockSizeBytes()); + return &m_data[offset]; } -inline -void DataBlock::setByte(int whichByte, uint8 data) +inline void +DataBlock::setByte(int whichByte, uint8 data) { m_data[whichByte] = data; } -inline -void DataBlock::setData(uint8* data, int offset, int len) +inline void +DataBlock::setData(uint8* data, int offset, int len) { - assert(offset + len <= RubySystem::getBlockSizeBytes()); - memcpy(&m_data[offset], data, len); + assert(offset + len <= RubySystem::getBlockSizeBytes()); + memcpy(&m_data[offset], data, len); } -inline -void DataBlock::copyPartial(const DataBlock & dblk, int offset, int len) +inline void +DataBlock::copyPartial(const DataBlock & dblk, int offset, int len) { - setData(&dblk.m_data[offset], offset, len); + setData(&dblk.m_data[offset], offset, len); } -// ******************* Definitions ******************* - -// Output operator definition -extern inline -std::ostream& operator<<(std::ostream& out, const DataBlock& obj) +inline std::ostream& +operator<<(std::ostream& out, const DataBlock& obj) { - obj.print(out); - out << std::flush; - return out; + obj.print(out); + out << std::flush; + return out; } -extern inline -bool operator==(const DataBlock& obj1,const DataBlock& obj2) +inline bool +operator==(const DataBlock& obj1,const DataBlock& obj2) { - return (obj1.equal(obj2)); + return obj1.equal(obj2); } -#endif //DATABLOCK_H +#endif // __MEM_RUBY_COMMON_DATABLOCK_HH__ diff --git a/src/mem/ruby/common/Debug.cc b/src/mem/ruby/common/Debug.cc index e67dc68ba..2c1acc4ff 100644 --- a/src/mem/ruby/common/Debug.cc +++ b/src/mem/ruby/common/Debug.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,19 +26,14 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - * - */ - #include <fstream> #include <stdarg.h> -#include "mem/ruby/common/Global.hh" +#include "base/misc.hh" +#include "mem/gems_common/util.hh" #include "mem/ruby/common/Debug.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/eventqueue/RubyEventQueue.hh" -#include "mem/gems_common/util.hh" -#include "base/misc.hh" using namespace std; @@ -79,313 +73,272 @@ DebugComponentData debugComponents[] = extern "C" void changeDebugVerbosity(VerbosityLevel vb); extern "C" void changeDebugFilter(int filter); -void changeDebugVerbosity(VerbosityLevel vb) +void +changeDebugVerbosity(VerbosityLevel vb) { - g_debug_ptr->setVerbosity(vb); + g_debug_ptr->setVerbosity(vb); } -void changeDebugFilter(int filter) +void +changeDebugFilter(int filter) { - g_debug_ptr->setFilter(filter); + g_debug_ptr->setFilter(filter); } Debug::Debug(const Params *p) : SimObject(p) { - clearFilter(); - debug_cout_ptr = &cout; - - setFilterString(p->filter_string.c_str()); - setVerbosityString(p->verbosity_string.c_str()); - setDebugOutputFile(p->output_filename.c_str()); - m_starting_cycle = p->start_time; - m_protocol_trace = p->protocol_trace; - g_debug_ptr = this; -} - + clearFilter(); + debug_cout_ptr = &cout; -Debug::~Debug() -{ + setFilterString(p->filter_string.c_str()); + setVerbosityString(p->verbosity_string.c_str()); + setDebugOutputFile(p->output_filename.c_str()); + m_starting_cycle = p->start_time; + m_protocol_trace = p->protocol_trace; + g_debug_ptr = this; } -void Debug::printVerbosity(ostream& out) const +Debug::~Debug() { - switch (getVerbosity()) { - case No_Verb: - out << "verbosity = No_Verb" << endl; - break; - case Low_Verb: - out << "verbosity = Low_Verb" << endl; - break; - case Med_Verb: - out << "verbosity = Med_Verb" << endl; - break; - case High_Verb: - out << "verbosity = High_Verb" << endl; - break; - default: - out << "verbosity = unknown" << endl; - } } -bool Debug::validDebug(int module, PriorityLevel priority) +void +Debug::printVerbosity(ostream& out) const { - int local_module = (1 << module); - if(m_filter & local_module) { - if (g_eventQueue_ptr == NULL || - g_eventQueue_ptr->getTime() >= m_starting_cycle) { - switch(m_verbosityLevel) { + switch (getVerbosity()) { case No_Verb: - return false; + out << "verbosity = No_Verb" << endl; break; case Low_Verb: - if(priority == HighPrio) { - return true; - }else{ - return false; - } + out << "verbosity = Low_Verb" << endl; break; case Med_Verb: - if(priority == HighPrio || priority == MedPrio ) { - return true; - }else{ - return false; - } + out << "verbosity = Med_Verb" << endl; break; case High_Verb: - return true; + out << "verbosity = High_Verb" << endl; break; - } + default: + out << "verbosity = unknown" << endl; } - } - return false; } -void Debug::setDebugTime(Time t) +bool +Debug::validDebug(int module, PriorityLevel priority) { - m_starting_cycle = t; + int local_module = (1 << module); + if (m_filter & local_module) { + if (g_eventQueue_ptr == NULL || + g_eventQueue_ptr->getTime() >= m_starting_cycle) { + switch (m_verbosityLevel) { + case No_Verb: + return false; + case Low_Verb: + return (priority == HighPrio); + case Med_Verb: + return (priority == HighPrio || priority == MedPrio); + case High_Verb: + return true; + } + } + } + return false; } -void Debug::setVerbosity(VerbosityLevel vb) +void +Debug::setDebugTime(Time t) { - m_verbosityLevel = vb; + m_starting_cycle = t; } -void Debug::setFilter(int filter) +void +Debug::setVerbosity(VerbosityLevel vb) { - m_filter = filter; + m_verbosityLevel = vb; } -bool Debug::checkVerbosityString(const char *verb_str) +void +Debug::setFilter(int filter) { - if (verb_str == NULL) { - cerr << "Error: unrecognized verbosity (use none, low, med, high): NULL" << endl; - return true; // error - } else if ( (string(verb_str) == "none") || - (string(verb_str) == "low") || - (string(verb_str) == "med") || - (string(verb_str) == "high") ) { - return false; - } - cerr << "Error: unrecognized verbosity (use none, low, med, high): NULL" << endl; - return true; // error + m_filter = filter; } -bool Debug::setVerbosityString(const char *verb_str) +bool +Debug::setVerbosityString(const char *verb_str) { - bool check_fails = checkVerbosityString(verb_str); - if (check_fails) { - return true; // error - } - if (string(verb_str) == "none") { - setVerbosity(No_Verb); - } else if (string(verb_str) == "low") { - setVerbosity(Low_Verb); - } else if (string(verb_str) == "med") { - setVerbosity(Med_Verb); - } else if (string(verb_str) == "high") { - setVerbosity(High_Verb); - } else { - cerr << "Error: unrecognized verbosity (use none, low, med, high): " << verb_str << endl; - return true; // error - } - return false; // no error + string verb = verb_str ? verb_str : ""; + if (verb == "none") { + setVerbosity(No_Verb); + } else if (verb == "low") { + setVerbosity(Low_Verb); + } else if (verb == "med") { + setVerbosity(Med_Verb); + } else if (verb == "high") { + setVerbosity(High_Verb); + } else { + cerr << "Error: unrecognized verbosity (use none, low, med, high): " + << verb << endl; + return true; // error + } + return false; // no error } -bool Debug::checkFilter(char ch) +bool +Debug::checkFilter(char ch) { - for (int i=0; i<NUMBER_OF_COMPS; i++) { - // Look at all components to find a character match - if (debugComponents[i].ch == ch) { - // We found a match - return no error - return false; // no error + for (int i = 0; i < NUMBER_OF_COMPS; i++) { + // Look at all components to find a character match + if (debugComponents[i].ch == ch) { + // We found a match - return no error + return false; // no error + } } - } - return true; // error + return true; // error } -bool Debug::checkFilterString(const char *filter_str) +bool +Debug::checkFilterString(const char *filter_str) { - if (filter_str == NULL) { - cerr << "Error: unrecognized component filter: NULL" << endl; - return true; // error - } + if (filter_str == NULL) { + cerr << "Error: unrecognized component filter: NULL" << endl; + return true; // error + } - // check for default filter ("none") before reporting RUBY_DEBUG error - if ( (string(filter_str) == "none") ) { - return false; // no error - } + // check for default filter ("none") before reporting RUBY_DEBUG error + if (string(filter_str) == "none") { + return false; // no error + } - if (RUBY_DEBUG == false) { - cerr << "Error: User specified set of debug components, but the RUBY_DEBUG compile-time flag is false." << endl; - cerr << "Solution: Re-compile with RUBY_DEBUG set to true." << endl; - return true; // error - } + if (RUBY_DEBUG == false) { + cerr << "Error: User specified set of debug components, but the " + << "RUBY_DEBUG compile-time flag is false." << endl + << "Solution: Re-compile with RUBY_DEBUG set to true." << endl; + return true; // error + } - if ( (string(filter_str) == "all") ) { - return false; // no error - } + if (string(filter_str) == "all") { + return false; // no error + } - // scan string checking each character - for (unsigned int i = 0; i < strlen(filter_str); i++) { - bool unrecognized = checkFilter( filter_str[i] ); - if (unrecognized == true) { - return true; // error + // scan string checking each character + for (unsigned int i = 0; i < strlen(filter_str); i++) { + bool unrecognized = checkFilter(filter_str[i]); + if (unrecognized == true) { + return true; // error + } } - } - return false; // no error + return false; // no error } -bool Debug::setFilterString(const char *filter_str) +bool +Debug::setFilterString(const char *filter_str) { - if (checkFilterString(filter_str)) { - return true; // error - } - - if (string(filter_str) == "all" ) { - allFilter(); - } else if (string(filter_str) == "none") { - clearFilter(); - } else { - // scan string adding to bit mask for each component which is present - for (unsigned int i = 0; i < strlen(filter_str); i++) { - bool error = addFilter( filter_str[i] ); - if (error) { + if (checkFilterString(filter_str)) { return true; // error - } } - } - return false; // no error + + if (string(filter_str) == "all" ) { + allFilter(); + } else if (string(filter_str) == "none") { + clearFilter(); + } else { + // scan string adding to bit mask for each component which is present + for (unsigned int i = 0; i < strlen(filter_str); i++) { + bool error = addFilter( filter_str[i] ); + if (error) { + return true; // error + } + } + } + return false; // no error } -bool Debug::addFilter(char ch) +bool +Debug::addFilter(char ch) { - for (int i=0; i<NUMBER_OF_COMPS; i++) { - // Look at all components to find a character match - if (debugComponents[i].ch == ch) { - // We found a match - update the filter bit mask - cout << " Debug: Adding to filter: '" << ch << "' (" << debugComponents[i].desc << ")" << endl; - m_filter |= (1 << i); - return false; // no error + for (int i = 0; i < NUMBER_OF_COMPS; i++) { + // Look at all components to find a character match + if (debugComponents[i].ch == ch) { + // We found a match - update the filter bit mask + cout << " Debug: Adding to filter: '" << ch << "' (" + << debugComponents[i].desc << ")" << endl; + m_filter |= (1 << i); + return false; // no error + } } - } - // We didn't find the character - cerr << "Error: unrecognized component filter: " << ch << endl; - usageInstructions(); - return true; // error + // We didn't find the character + cerr << "Error: unrecognized component filter: " << ch << endl; + usageInstructions(); + return true; // error } -void Debug::clearFilter() +void +Debug::clearFilter() { - m_filter = 0; + m_filter = 0; } void Debug::allFilter() { - m_filter = ~0; + m_filter = ~0; } -void Debug::usageInstructions(void) +void +Debug::usageInstructions(void) { - cerr << "Debug components: " << endl; - for (int i=0; i<NUMBER_OF_COMPS; i++) { - cerr << " " << debugComponents[i].ch << ": " << debugComponents[i].desc << endl; - } + cerr << "Debug components: " << endl; + for (int i = 0; i < NUMBER_OF_COMPS; i++) { + cerr << " " << debugComponents[i].ch << ": " + << debugComponents[i].desc << endl; + } } -void Debug::print(ostream& out) const +void +Debug::print(ostream& out) const { - out << "[Debug]" << endl; + out << "[Debug]" << endl; } -void Debug::setDebugOutputFile (const char * filename) +void +Debug::setDebugOutputFile (const char *filename) { - if ( (filename == NULL) || - (!strcmp(filename, "none")) ) { - debug_cout_ptr = &cout; - return; - } - - if (m_fout.is_open() ) { - m_fout.close (); - } - m_fout.open (filename, ios::out); - if (! m_fout.is_open() ) { - cerr << "setDebugOutputFile: can't open file " << filename << endl; - } - else { - debug_cout_ptr = &m_fout; - } -} + if (filename == NULL || !strcmp(filename, "none")) { + debug_cout_ptr = &cout; + return; + } -void Debug::closeDebugOutputFile () -{ - if (m_fout.is_open() ) { - m_fout.close (); - debug_cout_ptr = &cout; - } + if (m_fout.is_open()) { + m_fout.close(); + } + m_fout.open(filename, ios::out); + if (!m_fout.is_open()) { + cerr << "setDebugOutputFile: can't open file " << filename << endl; + } else { + debug_cout_ptr = &m_fout; + } } -void Debug::debugMsg( const char *fmt, ... ) +void +Debug::closeDebugOutputFile () { - va_list args; - - // you could check validDebug() here before printing the message - va_start(args, fmt); - vfprintf(stdout, fmt, args); - va_end(args); + if (m_fout.is_open()) { + m_fout.close (); + debug_cout_ptr = &cout; + } } -/* -void DEBUG_OUT( const char* fmt, ...) { - if (RUBY_DEBUG) { - cout << "Debug: in fn " - << __PRETTY_FUNCTION__ - << " in " << __FILE__ << ":" - << __LINE__ << ": "; +void +Debug::debugMsg( const char *fmt, ...) +{ va_list args; - va_start(args, fmt); - vfprintf(stdout, fmt, args); - va_end(args); - } -} -void ERROR_OUT( const char* fmt, ... ) { - if (ERROR_MESSAGE_FLAG) { - cout << "error: in fn " - << __PRETTY_FUNCTION__ << " in " - << __FILE__ << ":" - << __LINE__ << ": "; - va_list args; + // you could check validDebug() here before printing the message va_start(args, fmt); vfprintf(stdout, fmt, args); va_end(args); - } - assert(0); } -*/ - Debug * RubyDebugParams::create() diff --git a/src/mem/ruby/common/Debug.hh b/src/mem/ruby/common/Debug.hh index a7b1a15d1..a2344e82d 100644 --- a/src/mem/ruby/common/Debug.hh +++ b/src/mem/ruby/common/Debug.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,12 +26,8 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - */ - -#ifndef __MEM_RUBY_DEBUG_HH__ -#define __MEM_RUBY_DEBUG_HH__ +#ifndef __MEM_RUBY_COMMON_DEBUG_HH__ +#define __MEM_RUBY_COMMON_DEBUG_HH__ #include <unistd.h> @@ -75,68 +70,55 @@ enum DebugComponents enum PriorityLevel {HighPrio, MedPrio, LowPrio}; enum VerbosityLevel {No_Verb, Low_Verb, Med_Verb, High_Verb}; -class Debug : public SimObject { -public: - // Constructors +class Debug : public SimObject +{ + public: typedef RubyDebugParams Params; - Debug(const Params *p); - - // Destructor - ~Debug(); - - // Public Methods - static bool getProtocolTrace() { return m_protocol_trace; } - bool validDebug(int module, PriorityLevel priority); - void printVerbosity(std::ostream& out) const; - void setVerbosity(VerbosityLevel vb); - static bool checkVerbosityString(const char *verb_str); - bool setVerbosityString(const char *); - VerbosityLevel getVerbosity() const { return m_verbosityLevel; } - void setFilter(int); - static bool checkFilter( char); - static bool checkFilterString(const char *); - bool setFilterString(const char *); - void setDebugTime(Time); - Time getDebugTime() const { return m_starting_cycle; } - bool addFilter(char); - void clearFilter(); - void allFilter(); - void print(std::ostream& out) const; - /* old school debugging "vararg": sends messages to screen and log */ - void debugMsg( const char *fmt, ... ); - - void setDebugOutputFile (const char * filename); - void closeDebugOutputFile (); - static void usageInstructions(void); - -private: - // Private Methods - - // Private copy constructor and assignment operator - Debug(const Debug& obj); - Debug& operator=(const Debug& obj); - - // Data Members (m_ prefix) - static bool m_protocol_trace; - VerbosityLevel m_verbosityLevel; - int m_filter; - Time m_starting_cycle; - - std::fstream m_fout; + Debug(const Params *p); + ~Debug(); + + static bool getProtocolTrace() { return m_protocol_trace; } + bool validDebug(int module, PriorityLevel priority); + void printVerbosity(std::ostream& out) const; + void setVerbosity(VerbosityLevel vb); + bool setVerbosityString(const char *); + VerbosityLevel getVerbosity() const { return m_verbosityLevel; } + void setFilter(int); + static bool checkFilter( char); + static bool checkFilterString(const char *); + bool setFilterString(const char *); + void setDebugTime(Time); + Time getDebugTime() const { return m_starting_cycle; } + bool addFilter(char); + void clearFilter(); + void allFilter(); + void print(std::ostream& out) const; + /* old school debugging "vararg": sends messages to screen and log */ + void debugMsg(const char *fmt, ...); + + void setDebugOutputFile (const char * filename); + void closeDebugOutputFile (); + static void usageInstructions(void); + + private: + // Private copy constructor and assignment operator + Debug(const Debug& obj); + Debug& operator=(const Debug& obj); + + static bool m_protocol_trace; + VerbosityLevel m_verbosityLevel; + int m_filter; + Time m_starting_cycle; + + std::fstream m_fout; }; -// Output operator declaration -std::ostream& operator<<(std::ostream& out, const Debug& obj); - -// ******************* Definitions ******************* - -// Output operator definition -extern inline -std::ostream& operator<<(std::ostream& out, const Debug& obj) +inline std::ostream& +operator<<(std::ostream& out, const Debug& obj) { - obj.print(out); - out << std::flush; - return out; + obj.print(out); + out << std::flush; + return out; } const bool ERROR_MESSAGE_FLAG = true; @@ -151,178 +133,168 @@ const bool ASSERT_FLAG = true; #undef assert #define assert(EXPR) ASSERT(EXPR) #undef ASSERT -#define ASSERT(EXPR)\ -{\ - using namespace std;\ - if (ASSERT_FLAG) {\ - if (!(EXPR)) {\ - cerr << "failed assertion '"\ - << #EXPR << "' at fn "\ - << __PRETTY_FUNCTION__ << " in "\ - << __FILE__ << ":"\ - << __LINE__ << endl << flush;\ - (* debug_cout_ptr) << "failed assertion '"\ - << #EXPR << "' at fn "\ - << __PRETTY_FUNCTION__ << " in "\ - << __FILE__ << ":"\ - << __LINE__ << endl << flush;\ - if(isatty(STDIN_FILENO)) {\ - cerr << "At this point you might want to attach a debug to ";\ - cerr << "the running and get to the" << endl;\ - cerr << "crash site; otherwise press enter to continue" << endl;\ - cerr << "PID: " << getpid();\ - cerr << endl << flush; \ - char c; \ - cin.get(c); \ - }\ - abort();\ - }\ - }\ -} - -#define BREAK(X)\ -{\ - using namespace std;\ - cerr << "breakpoint '"\ - << #X << "' reached at fn "\ - << __PRETTY_FUNCTION__ << " in "\ - << __FILE__ << ":"\ - << __LINE__ << endl << flush;\ - if(isatty(STDIN_FILENO)) {\ - cerr << "press enter to continue" << endl;\ - cerr << "PID: " << getpid();\ - cerr << endl << flush; \ - char c; \ - cin.get(c); \ - }\ -} - -#define ERROR_MSG(MESSAGE)\ -{\ - using namespace std;\ - if (ERROR_MESSAGE_FLAG) {\ - cerr << "Fatal Error: in fn "\ - << __PRETTY_FUNCTION__ << " in "\ - << __FILE__ << ":"\ - << __LINE__ << ": "\ - << (MESSAGE) << endl << flush;\ - (* debug_cout_ptr) << "Fatal Error: in fn "\ - << __PRETTY_FUNCTION__ << " in "\ - << __FILE__ << ":"\ - << __LINE__ << ": "\ - << (MESSAGE) << endl << flush;\ - abort();\ - }\ -} - -#define WARN_MSG(MESSAGE)\ -{\ - using namespace std;\ - if (WARNING_MESSAGE_FLAG) {\ - cerr << "Warning: in fn "\ - << __PRETTY_FUNCTION__ << " in "\ - << __FILE__ << ":"\ - << __LINE__ << ": "\ - << (MESSAGE) << endl << flush;\ - (* debug_cout_ptr) << "Warning: in fn "\ - << __PRETTY_FUNCTION__ << " in "\ - << __FILE__ << ":"\ - << __LINE__ << ": "\ - << (MESSAGE) << endl << flush;\ - }\ -} - -#define WARN_EXPR(EXPR)\ -{\ - using namespace std;\ - if (WARNING_MESSAGE_FLAG) {\ - cerr << "Warning: in fn "\ - << __PRETTY_FUNCTION__ << " in "\ - << __FILE__ << ":"\ - << __LINE__ << ": "\ - << #EXPR << " is "\ - << (EXPR) << endl << flush;\ - (* debug_cout_ptr) << "Warning: in fn "\ - << __PRETTY_FUNCTION__ << " in "\ - << __FILE__ << ":"\ - << __LINE__ << ": "\ - << #EXPR << " is "\ - << (EXPR) << endl << flush;\ - }\ -} - -#define DEBUG_MSG(module, priority, MESSAGE)\ -{\ - using namespace std;\ - if (RUBY_DEBUG) {\ - if (g_debug_ptr->validDebug(module, priority)) {\ - (* debug_cout_ptr) << "Debug: in fn "\ - << __PRETTY_FUNCTION__\ - << " in " << __FILE__ << ":"\ - << __LINE__ << ": "\ - << (MESSAGE) << endl << flush;\ - }\ - }\ -} - -#define DEBUG_EXPR(module, priority, EXPR)\ -{\ - using namespace std;\ - if (RUBY_DEBUG) {\ - if (g_debug_ptr->validDebug(module, priority)) {\ - (* debug_cout_ptr) << "Debug: in fn "\ - << __PRETTY_FUNCTION__\ - << " in " << __FILE__ << ":"\ - << __LINE__ << ": "\ - << #EXPR << " is "\ - << (EXPR) << endl << flush;\ - }\ - }\ -} - -#define DEBUG_NEWLINE(module, priority)\ -{\ - using namespace std;\ - if (RUBY_DEBUG) {\ - if (g_debug_ptr->validDebug(module, priority)) {\ - (* debug_cout_ptr) << endl << flush;\ - }\ - }\ -} - -#define DEBUG_SLICC(priority, LINE, MESSAGE)\ -{\ - using namespace std;\ - if (RUBY_DEBUG) {\ - if (g_debug_ptr->validDebug(SLICC_COMP, priority)) {\ - (* debug_cout_ptr) << (LINE) << (MESSAGE) << endl << flush;\ - }\ - }\ -} - -#define DEBUG_OUT( rest... ) \ -{\ - using namespace std;\ - if (RUBY_DEBUG) {\ - cout << "Debug: in fn "\ - << __PRETTY_FUNCTION__\ - << " in " << __FILE__ << ":"\ - << __LINE__ << ": "; \ - g_debug_ptr->debugMsg(rest); \ - }\ -} - -#define ERROR_OUT( rest... ) \ -{\ - using namespace std;\ - if (ERROR_MESSAGE_FLAG) {\ - cout << "error: in fn "\ - << __PRETTY_FUNCTION__ << " in "\ - << __FILE__ << ":"\ - << __LINE__ << ": ";\ - g_debug_ptr->debugMsg(rest); \ - }\ -} - -#endif //DEBUG_H +#define ASSERT(EXPR) do { \ + using namespace std; \ + if (ASSERT_FLAG) { \ + if (!(EXPR)) { \ + cerr << "failed assertion '" \ + << #EXPR << "' at fn " \ + << __PRETTY_FUNCTION__ << " in " \ + << __FILE__ << ":" \ + << __LINE__ << endl << flush; \ + (*debug_cout_ptr) << "failed assertion '" \ + << #EXPR << "' at fn " \ + << __PRETTY_FUNCTION__ << " in " \ + << __FILE__ << ":" \ + << __LINE__ << endl << flush; \ + if (isatty(STDIN_FILENO)) { \ + cerr << "At this point you might want to attach a debug to " \ + << "the running and get to the" << endl \ + << "crash site; otherwise press enter to continue" \ + << endl \ + << "PID: " << getpid() \ + << endl << flush; \ + char c; \ + cin.get(c); \ + } \ + abort(); \ + } \ + } \ +} while (0) + +#define BREAK(X) do { \ + using namespace std; \ + cerr << "breakpoint '" \ + << #X << "' reached at fn " \ + << __PRETTY_FUNCTION__ << " in " \ + << __FILE__ << ":" \ + << __LINE__ << endl << flush; \ + if(isatty(STDIN_FILENO)) { \ + cerr << "press enter to continue" << endl; \ + cerr << "PID: " << getpid(); \ + cerr << endl << flush; \ + char c; \ + cin.get(c); \ + } \ +} while (0) + +#define ERROR_MSG(MESSAGE) do { \ + using namespace std; \ + if (ERROR_MESSAGE_FLAG) { \ + cerr << "Fatal Error: in fn " \ + << __PRETTY_FUNCTION__ << " in " \ + << __FILE__ << ":" \ + << __LINE__ << ": " \ + << (MESSAGE) << endl << flush; \ + (* debug_cout_ptr) << "Fatal Error: in fn " \ + << __PRETTY_FUNCTION__ << " in " \ + << __FILE__ << ":" \ + << __LINE__ << ": " \ + << (MESSAGE) << endl << flush; \ + abort(); \ + } \ +} while(0) + +#define WARN_MSG(MESSAGE) do { \ + using namespace std; \ + if (WARNING_MESSAGE_FLAG) { \ + cerr << "Warning: in fn " \ + << __PRETTY_FUNCTION__ << " in " \ + << __FILE__ << ":" \ + << __LINE__ << ": " \ + << (MESSAGE) << endl << flush; \ + (* debug_cout_ptr) << "Warning: in fn " \ + << __PRETTY_FUNCTION__ << " in " \ + << __FILE__ << ":" \ + << __LINE__ << ": " \ + << (MESSAGE) << endl << flush; \ + } \ +} while (0) + +#define WARN_EXPR(EXPR) do { \ + using namespace std; \ + if (WARNING_MESSAGE_FLAG) { \ + cerr << "Warning: in fn " \ + << __PRETTY_FUNCTION__ << " in " \ + << __FILE__ << ":" \ + << __LINE__ << ": " \ + << #EXPR << " is " \ + << (EXPR) << endl << flush; \ + (* debug_cout_ptr) << "Warning: in fn " \ + << __PRETTY_FUNCTION__ << " in " \ + << __FILE__ << ":" \ + << __LINE__ << ": " \ + << #EXPR << " is " \ + << (EXPR) << endl << flush; \ + } \ +} while (0) + +#define DEBUG_MSG(module, priority, MESSAGE) do { \ + using namespace std; \ + if (RUBY_DEBUG) { \ + if (g_debug_ptr->validDebug(module, priority)) { \ + (* debug_cout_ptr) << "Debug: in fn " \ + << __PRETTY_FUNCTION__ \ + << " in " << __FILE__ << ":" \ + << __LINE__ << ": " \ + << (MESSAGE) << endl << flush; \ + } \ + } \ +} while (0) + +#define DEBUG_EXPR(module, priority, EXPR) do { \ + using namespace std; \ + if (RUBY_DEBUG) { \ + if (g_debug_ptr->validDebug(module, priority)) { \ + (* debug_cout_ptr) << "Debug: in fn " \ + << __PRETTY_FUNCTION__ \ + << " in " << __FILE__ << ":" \ + << __LINE__ << ": " \ + << #EXPR << " is " \ + << (EXPR) << endl << flush; \ + } \ + } \ +} while (0) + +#define DEBUG_NEWLINE(module, priority) do { \ + using namespace std; \ + if (RUBY_DEBUG) { \ + if (g_debug_ptr->validDebug(module, priority)) { \ + (* debug_cout_ptr) << endl << flush; \ + } \ + } \ +} while (0) + +#define DEBUG_SLICC(priority, LINE, MESSAGE) do { \ + using namespace std; \ + if (RUBY_DEBUG) { \ + if (g_debug_ptr->validDebug(SLICC_COMP, priority)) { \ + (* debug_cout_ptr) << (LINE) << (MESSAGE) << endl << flush; \ + } \ + } \ +} while (0) + +#define DEBUG_OUT(rest... ) do { \ + using namespace std; \ + if (RUBY_DEBUG) { \ + cout << "Debug: in fn " \ + << __PRETTY_FUNCTION__ \ + << " in " << __FILE__ << ":" \ + << __LINE__ << ": "; \ + g_debug_ptr->debugMsg(rest); \ + } \ +} while (0) + +#define ERROR_OUT( rest... ) do { \ + using namespace std; \ + if (ERROR_MESSAGE_FLAG) { \ + cout << "error: in fn " \ + << __PRETTY_FUNCTION__ << " in " \ + << __FILE__ << ":" \ + << __LINE__ << ": "; \ + g_debug_ptr->debugMsg(rest); \ + } \ +} while (0) + +#endif // __MEM_RUBY_COMMON_DEBUG_HH__ diff --git a/src/mem/ruby/common/Driver.cc b/src/mem/ruby/common/Driver.cc index 2d6034b02..085044c7d 100644 --- a/src/mem/ruby/common/Driver.cc +++ b/src/mem/ruby/common/Driver.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,6 +26,8 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#include <cassert> + #include "mem/ruby/common/Driver.hh" Driver::Driver() @@ -37,3 +38,40 @@ Driver::Driver() Driver::~Driver() { } + +integer_t +Driver::getInstructionCount(int procID) const +{ + return 1; +} + +integer_t +Driver::getCycleCount(int procID) const +{ + return 1; +} + +void +Driver::addThreadDependency(int procID, int requestor_thread, + int conflict_thread) const +{ + assert(0); +} + +void +Driver::printDebug() +{} + +integer_t +Driver::readPhysicalMemory(int procID, physical_address_t address, int len) +{ + assert(0); + return 0; +} + +void +Driver::writePhysicalMemory(int procID, physical_address_t address, + integer_t value, int len) +{ + assert(0); +} diff --git a/src/mem/ruby/common/Driver.hh b/src/mem/ruby/common/Driver.hh index 9d17fcadb..f5f2f9c58 100644 --- a/src/mem/ruby/common/Driver.hh +++ b/src/mem/ruby/common/Driver.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,58 +26,40 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - * - * Description: - * - */ - -#ifndef DRIVER_H -#define DRIVER_H +#ifndef __MEM_RUBY_COMMON_DRIVER_HH__ +#define __MEM_RUBY_COMMON_DRIVER_HH__ -#include "mem/ruby/common/Global.hh" +#include "mem/ruby/common/Address.hh" #include "mem/ruby/common/Consumer.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/system/NodeID.hh" -#include "mem/ruby/common/Address.hh" - - -class Driver { -public: - // Constructors - Driver(); - - // Destructor - virtual ~Driver() = 0; - - // Public Methods - virtual void get_network_config() {} - virtual void dmaHitCallback() {}; - virtual void hitCallback(int64_t id) = 0; // Called by sequencer - virtual void go() = 0; - virtual integer_t getInstructionCount(int procID) const { return 1; } - virtual integer_t getCycleCount(int procID) const { return 1; } - virtual void addThreadDependency(int procID, int requestor_thread, int conflict_thread) const { assert(0);} - virtual void printDebug(){} //called by Sequencer - - virtual void printStats(ostream& out) const = 0; - virtual void clearStats() = 0; - - virtual void printConfig(ostream& out) const = 0; - - - virtual integer_t readPhysicalMemory(int procID, physical_address_t address, - int len ){ ASSERT(0); return 0; } - - virtual void writePhysicalMemory( int procID, physical_address_t address, - integer_t value, int len ){ ASSERT(0); } - -protected: - // accessible by subclasses - -private: - // inaccessible by subclasses +class Driver +{ + public: + Driver(); + virtual ~Driver() = 0; + + // Public Methods + virtual void get_network_config() {} + virtual void dmaHitCallback() {}; + virtual void hitCallback(int64_t id) = 0; // Called by sequencer + virtual void go() = 0; + virtual integer_t getInstructionCount(int procID) const; + virtual integer_t getCycleCount(int procID) const; + virtual void addThreadDependency(int procID, int requestor_thread, + int conflict_thread) const; + virtual void printDebug(); //called by Sequencer + + virtual void printStats(ostream& out) const = 0; + virtual void clearStats() = 0; + + virtual void printConfig(ostream& out) const = 0; + + virtual integer_t readPhysicalMemory(int procID, physical_address_t addr, + int len); + virtual void writePhysicalMemory(int procID, physical_address_t addr, + integer_t value, int len); }; -#endif //DRIVER_H +#endif //__MEM_RUBY_COMMON_DRIVER_HH__ diff --git a/src/mem/ruby/common/Global.cc b/src/mem/ruby/common/Global.cc index 7c7cab1e8..f780707e2 100644 --- a/src/mem/ruby/common/Global.cc +++ b/src/mem/ruby/common/Global.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. diff --git a/src/mem/ruby/common/Global.hh b/src/mem/ruby/common/Global.hh index 16465656d..de96c5a6b 100644 --- a/src/mem/ruby/common/Global.hh +++ b/src/mem/ruby/common/Global.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,42 +26,8 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - * - * */ - -#ifndef GLOBAL_H -#define GLOBAL_H - -/* -#ifdef SINGLE_LEVEL_CACHE -const bool TWO_LEVEL_CACHE = false; -#define L1I_CACHE_MEMBER_VARIABLE m_L1Cache_cacheMemory_vec[m_version] // currently all protocols require L1s == nodes -#define L1D_CACHE_MEMBER_VARIABLE m_L1Cache_cacheMemory_vec[m_version] // " -#define L2_CACHE_MEMBER_VARIABLE m_L1Cache_cacheMemory_vec[m_version] // " -#define L2_CACHE_VARIABLE m_L1Cache_cacheMemory_vec -#else -const bool TWO_LEVEL_CACHE = true; -#ifdef IS_CMP -#define L1I_CACHE_MEMBER_VARIABLE m_L1Cache_L1IcacheMemory_vec[m_version] -#define L1D_CACHE_MEMBER_VARIABLE m_L1Cache_L1DcacheMemory_vec[m_version] -#define L2_CACHE_MEMBER_VARIABLE m_L2Cache_L2cacheMemory_vec[m_version] -#define L2_CACHE_VARIABLE m_L2Cache_L2cacheMemory_vec -#else // not IS_CMP -#define L1I_CACHE_MEMBER_VARIABLE m_L1Cache_L1IcacheMemory_vec[m_version] // currently all protocols require L1s == nodes -#define L1D_CACHE_MEMBER_VARIABLE m_L1Cache_L1DcacheMemory_vec[m_version] // " -// #define L2_CACHE_MEMBER_VARIABLE m_L1Cache_L2cacheMemory_vec[m_version] // old exclusive caches don't support L2s != nodes -#define L2_CACHE_MEMBER_VARIABLE m_L1Cache_cacheMemory_vec[m_version] // old exclusive caches don't support L2s != nodes -#define L2_CACHE_VARIABLE m_L1Cache_L2cacheMemory_vec -#endif // IS_CMP -#endif //SINGLE_LEVEL_CACHE - -#define DIRECTORY_MEMBER_VARIABLE m_Directory_directory_vec[m_version] -#define TBE_TABLE_MEMBER_VARIABLE m_L1Cache_TBEs_vec[m_version] - -*/ - +#ifndef __MEM_RUBY_COMMON_GLOBAL_HH__ +#define __MEM_RUBY_COMMON_GLOBAL_HH__ // external includes for all classes #include "mem/ruby/common/TypeDefines.hh" @@ -85,13 +50,12 @@ extern RubySystem* g_system_ptr; class Debug; extern Debug* g_debug_ptr; -// FIXME: this is required by the contructor of Directory_Entry.hh. It can't go -// into slicc_util.hh because it opens a can of ugly worms +// FIXME: this is required by the contructor of Directory_Entry.hh. +// It can't go into slicc_util.hh because it opens a can of ugly worms extern inline int max_tokens() { return 1024; } - -#endif //GLOBAL_H +#endif // __MEM_RUBY_COMMON_GLOBAL_HH__ diff --git a/src/mem/ruby/common/Histogram.cc b/src/mem/ruby/common/Histogram.cc index 2a25cfeb1..c57b55997 100644 --- a/src/mem/ruby/common/Histogram.cc +++ b/src/mem/ruby/common/Histogram.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,164 +26,169 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - * - */ - #include <cmath> #include <iomanip> +#include "base/intmath.hh" #include "mem/ruby/common/Histogram.hh" using namespace std; Histogram::Histogram(int binsize, int bins) { - m_binsize = binsize; - m_bins = bins; - clear(); + m_binsize = binsize; + m_bins = bins; + clear(); } Histogram::~Histogram() { } -void Histogram::clear(int binsize, int bins) +void +Histogram::clear(int binsize, int bins) { - m_binsize = binsize; - clear(bins); + m_binsize = binsize; + clear(bins); } -void Histogram::clear(int bins) +void +Histogram::clear(int bins) { - m_bins = bins; - m_largest_bin = 0; - m_max = 0; - m_data.setSize(m_bins); - for (int i = 0; i < m_bins; i++) { - m_data[i] = 0; - } - m_count = 0; - m_max = 0; - - m_sumSamples = 0; - m_sumSquaredSamples = 0; + m_bins = bins; + m_largest_bin = 0; + m_max = 0; + m_data.setSize(m_bins); + for (int i = 0; i < m_bins; i++) { + m_data[i] = 0; + } + m_count = 0; + m_max = 0; + + m_sumSamples = 0; + m_sumSquaredSamples = 0; } -void Histogram::add(int64 value) +void +Histogram::add(int64 value) { - assert(value >= 0); - m_max = max(m_max, value); - m_count++; - - m_sumSamples += value; - m_sumSquaredSamples += (value*value); - - int index; - if (m_binsize == -1) { - // This is a log base 2 histogram - if (value == 0) { - index = 0; + assert(value >= 0); + m_max = max(m_max, value); + m_count++; + + m_sumSamples += value; + m_sumSquaredSamples += (value*value); + + int index; + if (m_binsize == -1) { + // This is a log base 2 histogram + if (value == 0) { + index = 0; + } else { + index = floorLog2(value) + 1; + if (index >= m_data.size()) { + index = m_data.size() - 1; + } + } } else { - index = int(log(double(value))/log(2.0))+1; - if (index >= m_data.size()) { - index = m_data.size()-1; - } - } - } else { - // This is a linear histogram - while (m_max >= (m_bins * m_binsize)) { - for (int i = 0; i < m_bins/2; i++) { - m_data[i] = m_data[i*2] + m_data[i*2 + 1]; - } - for (int i = m_bins/2; i < m_bins; i++) { - m_data[i] = 0; - } - m_binsize *= 2; + // This is a linear histogram + while (m_max >= (m_bins * m_binsize)) { + for (int i = 0; i < m_bins/2; i++) { + m_data[i] = m_data[i*2] + m_data[i*2 + 1]; + } + for (int i = m_bins/2; i < m_bins; i++) { + m_data[i] = 0; + } + m_binsize *= 2; + } + index = value/m_binsize; } - index = value/m_binsize; - } - assert(index >= 0); - m_data[index]++; - m_largest_bin = max(m_largest_bin, index); + assert(index >= 0); + m_data[index]++; + m_largest_bin = max(m_largest_bin, index); } -void Histogram::add(const Histogram& hist) +void +Histogram::add(const Histogram& hist) { - assert(hist.getBins() == m_bins); - assert(hist.getBinSize() == -1); // assume log histogram - assert(m_binsize == -1); - - for (int j = 0; j < hist.getData(0); j++) { - add(0); - } + assert(hist.getBins() == m_bins); + assert(hist.getBinSize() == -1); // assume log histogram + assert(m_binsize == -1); - for (int i = 1; i < m_bins; i++) { - for (int j = 0; j < hist.getData(i); j++) { - add(1<<(i-1)); // account for the + 1 index + for (int j = 0; j < hist.getData(0); j++) { + add(0); } - } + for (int i = 1; i < m_bins; i++) { + for (int j = 0; j < hist.getData(i); j++) { + add(1<<(i-1)); // account for the + 1 index + } + } } // Computation of standard deviation of samples a1, a2, ... aN // variance = [SUM {ai^2} - (SUM {ai})^2/N]/(N-1) // std deviation equals square root of variance -double Histogram::getStandardDeviation() const +double +Histogram::getStandardDeviation() const { - double variance; - if(m_count > 1){ - variance = (double)(m_sumSquaredSamples - m_sumSamples*m_sumSamples/m_count)/(m_count - 1); - } else { - return 0; - } - return sqrt(variance); + if (m_count <= 1) + return 0.0; + + double variance = + (double)(m_sumSquaredSamples - m_sumSamples * m_sumSamples / m_count) + / (m_count - 1); + return sqrt(variance); } -void Histogram::print(ostream& out) const +void +Histogram::print(ostream& out) const { - printWithMultiplier(out, 1.0); + printWithMultiplier(out, 1.0); } -void Histogram::printPercent(ostream& out) const +void +Histogram::printPercent(ostream& out) const { - if (m_count == 0) { - printWithMultiplier(out, 0.0); - } else { - printWithMultiplier(out, 100.0/double(m_count)); - } + if (m_count == 0) { + printWithMultiplier(out, 0.0); + } else { + printWithMultiplier(out, 100.0 / double(m_count)); + } } -void Histogram::printWithMultiplier(ostream& out, double multiplier) const +void +Histogram::printWithMultiplier(ostream& out, double multiplier) const { - if (m_binsize == -1) { - out << "[binsize: log2 "; - } else { - out << "[binsize: " << m_binsize << " "; - } - out << "max: " << m_max << " "; - out << "count: " << m_count << " "; - // out << "total: " << m_sumSamples << " "; - if (m_count == 0) { - out << "average: NaN |"; - out << "standard deviation: NaN |"; - } else { - out << "average: " << setw(5) << ((double) m_sumSamples)/m_count << " | "; - out << "standard deviation: " << getStandardDeviation() << " |"; - } - for (int i = 0; i < m_bins && i <= m_largest_bin; i++) { - if (multiplier == 1.0) { - out << " " << m_data[i]; + if (m_binsize == -1) { + out << "[binsize: log2 "; + } else { + out << "[binsize: " << m_binsize << " "; + } + out << "max: " << m_max << " "; + out << "count: " << m_count << " "; + // out << "total: " << m_sumSamples << " "; + if (m_count == 0) { + out << "average: NaN |"; + out << "standard deviation: NaN |"; } else { - out << " " << double(m_data[i]) * multiplier; + out << "average: " << setw(5) << ((double) m_sumSamples)/m_count + << " | "; + out << "standard deviation: " << getStandardDeviation() << " |"; + } + for (int i = 0; i < m_bins && i <= m_largest_bin; i++) { + if (multiplier == 1.0) { + out << " " << m_data[i]; + } else { + out << " " << double(m_data[i]) * multiplier; + } } - } - out << " ]"; + out << " ]"; } -bool node_less_then_eq(const Histogram* n1, const Histogram* n2) +bool +node_less_then_eq(const Histogram* n1, const Histogram* n2) { - return (n1->size() > n2->size()); + return (n1->size() > n2->size()); } diff --git a/src/mem/ruby/common/Histogram.hh b/src/mem/ruby/common/Histogram.hh index 64247d64a..e5cd211d6 100644 --- a/src/mem/ruby/common/Histogram.hh +++ b/src/mem/ruby/common/Histogram.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,80 +26,57 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - * - * Description: The histogram class implements a simple histogram - * - */ - -#ifndef HISTOGRAM_H -#define HISTOGRAM_H +#ifndef __MEM_RUBY_COMMON_HISTOGRAM_HH__ +#define __MEM_RUBY_COMMON_HISTOGRAM_HH__ #include <iostream> #include "mem/ruby/common/Global.hh" #include "mem/gems_common/Vector.hh" -class Histogram { -public: - // Constructors - Histogram(int binsize = 1, int bins = 50); - - // Destructor - ~Histogram(); - - // Public Methods - - void add(int64 value); - void add(const Histogram& hist); - void clear() { clear(m_bins); } - void clear(int bins); - void clear(int binsize, int bins); - int64 size() const { return m_count; } - int getBins() const { return m_bins; } - int getBinSize() const { return m_binsize; } - int64 getTotal() const { return m_sumSamples; } - int64 getData(int index) const { return m_data[index]; } +class Histogram +{ + public: + Histogram(int binsize = 1, int bins = 50); + ~Histogram(); + + void add(int64 value); + void add(const Histogram& hist); + void clear() { clear(m_bins); } + void clear(int bins); + void clear(int binsize, int bins); + int64 size() const { return m_count; } + int getBins() const { return m_bins; } + int getBinSize() const { return m_binsize; } + int64 getTotal() const { return m_sumSamples; } + int64 getData(int index) const { return m_data[index]; } + + void printWithMultiplier(std::ostream& out, double multiplier) const; + void printPercent(std::ostream& out) const; + void print(std::ostream& out) const; - void printWithMultiplier(std::ostream& out, double multiplier) const; - void printPercent(std::ostream& out) const; - void print(std::ostream& out) const; private: - // Private Methods - - // Private copy constructor and assignment operator - // Histogram(const Histogram& obj); - // Histogram& operator=(const Histogram& obj); + Vector<int64> m_data; + int64 m_max; // the maximum value seen so far + int64 m_count; // the number of elements added + int m_binsize; // the size of each bucket + int m_bins; // the number of buckets + int m_largest_bin; // the largest bin used - // Data Members (m_ prefix) - Vector<int64> m_data; - int64 m_max; // the maximum value seen so far - int64 m_count; // the number of elements added - int m_binsize; // the size of each bucket - int m_bins; // the number of buckets - int m_largest_bin; // the largest bin used + int64 m_sumSamples; // the sum of all samples + int64 m_sumSquaredSamples; // the sum of the square of all samples - int64 m_sumSamples; // the sum of all samples - int64 m_sumSquaredSamples; // the sum of the square of all samples - - double getStandardDeviation() const; + double getStandardDeviation() const; }; bool node_less_then_eq(const Histogram* n1, const Histogram* n2); -// Output operator declaration -std::ostream& operator<<(std::ostream& out, const Histogram& obj); - -// ******************* Definitions ******************* - -// Output operator definition -extern inline -std::ostream& operator<<(std::ostream& out, const Histogram& obj) +inline std::ostream& +operator<<(std::ostream& out, const Histogram& obj) { - obj.print(out); - out << std::flush; - return out; + obj.print(out); + out << std::flush; + return out; } -#endif //HISTOGRAM_H +#endif // __MEM_RUBY_COMMON_HISTOGRAM_HH__ diff --git a/src/mem/ruby/common/Message.cc b/src/mem/ruby/common/Message.cc deleted file mode 100644 index bf3307687..000000000 --- a/src/mem/ruby/common/Message.cc +++ /dev/null @@ -1,34 +0,0 @@ - -/* - * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer; - * redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution; - * neither the name of the copyright holders nor the names of its - * contributors may be used to endorse or promote products derived from - * this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/* - * $Id$ - */ - -#include "mem/ruby/slicc_interface/Message.hh" diff --git a/src/mem/ruby/common/NetDest.cc b/src/mem/ruby/common/NetDest.cc index 35bb4ec43..1edf6d1a6 100644 --- a/src/mem/ruby/common/NetDest.cc +++ b/src/mem/ruby/common/NetDest.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,15 +26,6 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * NetDest.C - * - * Description: See NetDest.hh - * - * $Id$ - * - */ - #include "mem/ruby/common/NetDest.hh" #include "mem/protocol/Protocol.hh" @@ -44,216 +34,242 @@ NetDest::NetDest() setSize(); } -void NetDest::add(MachineID newElement) +void +NetDest::add(MachineID newElement) { - m_bits[vecIndex(newElement)].add(bitIndex(newElement.num)); + m_bits[vecIndex(newElement)].add(bitIndex(newElement.num)); } -void NetDest::addNetDest(const NetDest& netDest) +void +NetDest::addNetDest(const NetDest& netDest) { - assert(m_bits.size() == netDest.getSize()); - for (int i = 0; i < m_bits.size(); i++) { - m_bits[i].addSet(netDest.m_bits[i]); - } + assert(m_bits.size() == netDest.getSize()); + for (int i = 0; i < m_bits.size(); i++) { + m_bits[i].addSet(netDest.m_bits[i]); + } } -void NetDest::addRandom() +void +NetDest::addRandom() { - int i = random()%m_bits.size(); - m_bits[i].addRandom(); + int i = random()%m_bits.size(); + m_bits[i].addRandom(); } -void NetDest::setNetDest(MachineType machine, const Set& set) +void +NetDest::setNetDest(MachineType machine, const Set& set) { - // assure that there is only one set of destinations for this machine - assert(MachineType_base_level((MachineType)(machine+1)) - MachineType_base_level(machine) == 1); - m_bits[MachineType_base_level(machine)] = set; + // assure that there is only one set of destinations for this machine + assert(MachineType_base_level((MachineType)(machine + 1)) - + MachineType_base_level(machine) == 1); + m_bits[MachineType_base_level(machine)] = set; } -void NetDest::remove(MachineID oldElement) +void +NetDest::remove(MachineID oldElement) { - m_bits[vecIndex(oldElement)].remove(bitIndex(oldElement.num)); + m_bits[vecIndex(oldElement)].remove(bitIndex(oldElement.num)); } -void NetDest::removeNetDest(const NetDest& netDest) +void +NetDest::removeNetDest(const NetDest& netDest) { - assert(m_bits.size() == netDest.getSize()); - for (int i = 0; i < m_bits.size(); i++) { - m_bits[i].removeSet(netDest.m_bits[i]); - - } + assert(m_bits.size() == netDest.getSize()); + for (int i = 0; i < m_bits.size(); i++) { + m_bits[i].removeSet(netDest.m_bits[i]); + } } -void NetDest::clear() +void +NetDest::clear() { - for (int i = 0; i < m_bits.size(); i++) { - m_bits[i].clear(); - } + for (int i = 0; i < m_bits.size(); i++) { + m_bits[i].clear(); + } } -void NetDest::broadcast() +void +NetDest::broadcast() { - for (MachineType machine = MachineType_FIRST; machine < MachineType_NUM; ++machine) { - broadcast(machine); - } + for (MachineType machine = MachineType_FIRST; + machine < MachineType_NUM; ++machine) { + broadcast(machine); + } } -void NetDest::broadcast(MachineType machineType) { - - for (int i = 0; i < MachineType_base_count(machineType); i++) { - MachineID mach = {machineType, i}; - add(mach); - } +void +NetDest::broadcast(MachineType machineType) +{ + for (int i = 0; i < MachineType_base_count(machineType); i++) { + MachineID mach = {machineType, i}; + add(mach); + } } //For Princeton Network -Vector<NodeID> NetDest::getAllDest() { - Vector<NodeID> dest; - dest.clear(); - for (int i=0; i<m_bits.size(); i++) { - for (int j=0; j<m_bits[i].getSize(); j++) { - if (m_bits[i].isElement(j)) { - dest.insertAtBottom((NodeID) (MachineType_base_number((MachineType) i) + j)); - } - } +Vector<NodeID> +NetDest::getAllDest() +{ + Vector<NodeID> dest; + dest.clear(); + for (int i = 0; i < m_bits.size(); i++) { + for (int j = 0; j < m_bits[i].getSize(); j++) { + if (m_bits[i].isElement(j)) { + int id = MachineType_base_number((MachineType)i) + j; + dest.insertAtBottom((NodeID)id); + } } - return dest; + } + return dest; } -int NetDest::count() const +int +NetDest::count() const { - int counter = 0; - for (int i=0; i<m_bits.size(); i++) { - counter += m_bits[i].count(); - } - return counter; + int counter = 0; + for (int i = 0; i < m_bits.size(); i++) { + counter += m_bits[i].count(); + } + return counter; } -NodeID NetDest::elementAt(MachineID index) { - return m_bits[vecIndex(index)].elementAt(bitIndex(index.num)); +NodeID +NetDest::elementAt(MachineID index) +{ + return m_bits[vecIndex(index)].elementAt(bitIndex(index.num)); } -MachineID NetDest::smallestElement() const +MachineID +NetDest::smallestElement() const { - assert(count() > 0); - for (int i=0; i<m_bits.size(); i++) { - for (int j=0; j<m_bits[i].getSize(); j++) { - if (m_bits[i].isElement(j)) { - MachineID mach = {MachineType_from_base_level(i), j}; - return mach; - } + assert(count() > 0); + for (int i = 0; i < m_bits.size(); i++) { + for (int j = 0; j < m_bits[i].getSize(); j++) { + if (m_bits[i].isElement(j)) { + MachineID mach = {MachineType_from_base_level(i), j}; + return mach; + } + } } - } - ERROR_MSG("No smallest element of an empty set."); + ERROR_MSG("No smallest element of an empty set."); } -MachineID NetDest::smallestElement(MachineType machine) const +MachineID +NetDest::smallestElement(MachineType machine) const { - for (int j = 0; j < m_bits[MachineType_base_level(machine)].getSize(); j++) { - if (m_bits[MachineType_base_level(machine)].isElement(j)) { - MachineID mach = {machine, j}; - return mach; + int size = m_bits[MachineType_base_level(machine)].getSize(); + for (int j = 0; j < size; j++) { + if (m_bits[MachineType_base_level(machine)].isElement(j)) { + MachineID mach = {machine, j}; + return mach; + } } - } - ERROR_MSG("No smallest element of given MachineType."); + ERROR_MSG("No smallest element of given MachineType."); } - // Returns true iff all bits are set -bool NetDest::isBroadcast() const +bool +NetDest::isBroadcast() const { - for (int i=0; i<m_bits.size(); i++) { - if (!m_bits[i].isBroadcast()) { - return false; + for (int i = 0; i < m_bits.size(); i++) { + if (!m_bits[i].isBroadcast()) { + return false; + } } - } - return true; + return true; } // Returns true iff no bits are set -bool NetDest::isEmpty() const +bool +NetDest::isEmpty() const { - for (int i=0; i<m_bits.size(); i++) { - if (!m_bits[i].isEmpty()) { - return false; + for (int i = 0; i < m_bits.size(); i++) { + if (!m_bits[i].isEmpty()) { + return false; + } } - } - return true; + return true; } // returns the logical OR of "this" set and orNetDest -NetDest NetDest::OR(const NetDest& orNetDest) const +NetDest +NetDest::OR(const NetDest& orNetDest) const { - assert(m_bits.size() == orNetDest.getSize()); - NetDest result; - for (int i=0; i<m_bits.size(); i++) { - result.m_bits[i] = m_bits[i].OR(orNetDest.m_bits[i]); - } - return result; + assert(m_bits.size() == orNetDest.getSize()); + NetDest result; + for (int i = 0; i < m_bits.size(); i++) { + result.m_bits[i] = m_bits[i].OR(orNetDest.m_bits[i]); + } + return result; } - // returns the logical AND of "this" set and andNetDest -NetDest NetDest::AND(const NetDest& andNetDest) const +NetDest +NetDest::AND(const NetDest& andNetDest) const { - assert(m_bits.size() == andNetDest.getSize()); - NetDest result; - for (int i=0; i<m_bits.size(); i++) { - result.m_bits[i] = m_bits[i].AND(andNetDest.m_bits[i]); - } - return result; + assert(m_bits.size() == andNetDest.getSize()); + NetDest result; + for (int i = 0; i < m_bits.size(); i++) { + result.m_bits[i] = m_bits[i].AND(andNetDest.m_bits[i]); + } + return result; } // Returns true if the intersection of the two sets is non-empty -bool NetDest::intersectionIsNotEmpty(const NetDest& other_netDest) const +bool +NetDest::intersectionIsNotEmpty(const NetDest& other_netDest) const { - assert(m_bits.size() == other_netDest.getSize()); - for (int i=0; i<m_bits.size(); i++) { - if (m_bits[i].intersectionIsNotEmpty(other_netDest.m_bits[i])) { - return true; + assert(m_bits.size() == other_netDest.getSize()); + for (int i = 0; i < m_bits.size(); i++) { + if (m_bits[i].intersectionIsNotEmpty(other_netDest.m_bits[i])) { + return true; + } } - } - return false; + return false; } -bool NetDest::isSuperset(const NetDest& test) const +bool +NetDest::isSuperset(const NetDest& test) const { - assert(m_bits.size() == test.getSize()); + assert(m_bits.size() == test.getSize()); - for (int i=0; i<m_bits.size(); i++) { - if (!m_bits[i].isSuperset(test.m_bits[i])) { - return false; + for (int i = 0; i < m_bits.size(); i++) { + if (!m_bits[i].isSuperset(test.m_bits[i])) { + return false; + } } - } - return true; + return true; } -bool NetDest::isElement(MachineID element) const +bool +NetDest::isElement(MachineID element) const { - return ((m_bits[vecIndex(element)])).isElement(bitIndex(element.num)); + return ((m_bits[vecIndex(element)])).isElement(bitIndex(element.num)); } -void NetDest::setSize() +void +NetDest::setSize() { - m_bits.setSize(MachineType_base_level(MachineType_NUM)); - assert(m_bits.size() == MachineType_NUM); + m_bits.setSize(MachineType_base_level(MachineType_NUM)); + assert(m_bits.size() == MachineType_NUM); - for (int i = 0; i < m_bits.size(); i++) { - m_bits[i].setSize(MachineType_base_count((MachineType)i)); - } + for (int i = 0; i < m_bits.size(); i++) { + m_bits[i].setSize(MachineType_base_count((MachineType)i)); + } } -void NetDest::print(ostream& out) const +void +NetDest::print(ostream& out) const { - out << "[NetDest (" << m_bits.size() << ") "; + out << "[NetDest (" << m_bits.size() << ") "; - for (int i=0; i<m_bits.size(); i++) { - for (int j=0; j<m_bits[i].getSize(); j++) { - out << (bool) m_bits[i].isElement(j) << " "; + for (int i = 0; i < m_bits.size(); i++) { + for (int j = 0; j < m_bits[i].getSize(); j++) { + out << (bool) m_bits[i].isElement(j) << " "; + } + out << " - "; } - out << " - "; - } - out << "]"; + out << "]"; } diff --git a/src/mem/ruby/common/NetDest.hh b/src/mem/ruby/common/NetDest.hh index 071106623..7592ad9b5 100644 --- a/src/mem/ruby/common/NetDest.hh +++ b/src/mem/ruby/common/NetDest.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,22 +26,13 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * Set.hh - * - * Description: - * - * $Id$ - * - */ - // NetDest specifies the network destination of a NetworkMessage // This is backward compatible with the Set class that was previously // used to specify network destinations. // NetDest supports both node networks and component networks -#ifndef NETDEST_H -#define NETDEST_H +#ifndef __MEM_RUBY_COMMON_NETDEST_HH__ +#define __MEM_RUBY_COMMON_NETDEST_HH__ #include "mem/ruby/common/Global.hh" #include "mem/gems_common/Vector.hh" @@ -51,94 +41,92 @@ #include "mem/ruby/common/Set.hh" #include "mem/protocol/MachineType.hh" -class Set; - -class NetDest { -public: - // Constructors - // creates and empty set - NetDest(); - explicit NetDest(int bit_size); - - NetDest& operator=(const Set& obj); - - // Destructor - ~NetDest() { DEBUG_MSG(MEMORY_COMP, LowPrio, "NetDest Destructor"); } - - // Public Methods - void add(MachineID newElement); - void addNetDest(const NetDest& netDest); - void addRandom(); - void setNetDest(MachineType machine, const Set& set); - void remove(MachineID oldElement); - void removeNetDest(const NetDest& netDest); - void clear(); - void broadcast(); - void broadcast(MachineType machine); - int count() const; - bool isEqual(const NetDest& netDest); - - NetDest OR(const NetDest& orNetDest) const; // return the logical OR of this netDest and orNetDest - NetDest AND(const NetDest& andNetDest) const; // return the logical AND of this netDest and andNetDest - - // Returns true if the intersection of the two netDests is non-empty - bool intersectionIsNotEmpty(const NetDest& other_netDest) const; - - // Returns true if the intersection of the two netDests is empty - bool intersectionIsEmpty(const NetDest& other_netDest) const; - - bool isSuperset(const NetDest& test) const; - bool isSubset(const NetDest& test) const { return test.isSuperset(*this); } - bool isElement(MachineID element) const; - bool isBroadcast() const; - bool isEmpty() const; - - //For Princeton Network - Vector<NodeID> getAllDest(); - - MachineID smallestElement() const; - MachineID smallestElement(MachineType machine) const; - - void setSize(); - int getSize() const { return m_bits.size(); } - - // get element for a index - NodeID elementAt(MachineID index); - - void print(ostream& out) const; - -private: - - // Private Methods - // returns a value >= MachineType_base_level("this machine") and < MachineType_base_level("next highest machine") - int vecIndex(MachineID m) const { - int vec_index = MachineType_base_level(m.type); - assert(vec_index < m_bits.size()); - return vec_index; - } - - NodeID bitIndex(NodeID index) const { - return index; - } - - // Data Members (m_ prefix) - Vector < Set > m_bits; // a Vector of bit vectors - i.e. Sets - +class NetDest +{ + public: + // Constructors + // creates and empty set + NetDest(); + explicit NetDest(int bit_size); + + NetDest& operator=(const Set& obj); + + ~NetDest() + { + DEBUG_MSG(MEMORY_COMP, LowPrio, "NetDest Destructor"); + } + + void add(MachineID newElement); + void addNetDest(const NetDest& netDest); + void addRandom(); + void setNetDest(MachineType machine, const Set& set); + void remove(MachineID oldElement); + void removeNetDest(const NetDest& netDest); + void clear(); + void broadcast(); + void broadcast(MachineType machine); + int count() const; + bool isEqual(const NetDest& netDest); + + // return the logical OR of this netDest and orNetDest + NetDest OR(const NetDest& orNetDest) const; + + // return the logical AND of this netDest and andNetDest + NetDest AND(const NetDest& andNetDest) const; + + // Returns true if the intersection of the two netDests is non-empty + bool intersectionIsNotEmpty(const NetDest& other_netDest) const; + + // Returns true if the intersection of the two netDests is empty + bool intersectionIsEmpty(const NetDest& other_netDest) const; + + bool isSuperset(const NetDest& test) const; + bool isSubset(const NetDest& test) const { return test.isSuperset(*this); } + bool isElement(MachineID element) const; + bool isBroadcast() const; + bool isEmpty() const; + + // For Princeton Network + Vector<NodeID> getAllDest(); + + MachineID smallestElement() const; + MachineID smallestElement(MachineType machine) const; + + void setSize(); + int getSize() const { return m_bits.size(); } + + // get element for a index + NodeID elementAt(MachineID index); + + void print(ostream& out) const; + + private: + // returns a value >= MachineType_base_level("this machine") + // and < MachineType_base_level("next highest machine") + int + vecIndex(MachineID m) const + { + int vec_index = MachineType_base_level(m.type); + assert(vec_index < m_bits.size()); + return vec_index; + } + + NodeID + bitIndex(NodeID index) const + { + return index; + } + + Vector <Set> m_bits; // a Vector of bit vectors - i.e. Sets }; -// Output operator declaration -ostream& operator<<(ostream& out, const NetDest& obj); - -// ******************* Definitions ******************* - -// Output operator definition -extern inline -ostream& operator<<(ostream& out, const NetDest& obj) +inline ostream& +operator<<(ostream& out, const NetDest& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } -#endif //NETDEST_H +#endif // __MEM_RUBY_COMMON_NETDEST_HH__ diff --git a/src/mem/ruby/common/SConscript b/src/mem/ruby/common/SConscript index 56f5d7556..2197faae8 100644 --- a/src/mem/ruby/common/SConscript +++ b/src/mem/ruby/common/SConscript @@ -41,7 +41,6 @@ Source('Debug.cc') Source('Driver.cc') Source('Global.cc') Source('Histogram.cc') -Source('Message.cc') Source('NetDest.cc') Source('Set.cc', Werror=False) Source('SubBlock.cc') diff --git a/src/mem/ruby/common/SubBlock.cc b/src/mem/ruby/common/SubBlock.cc index de40e3f7d..533aefbe7 100644 --- a/src/mem/ruby/common/SubBlock.cc +++ b/src/mem/ruby/common/SubBlock.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,44 +26,44 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - */ - #include "mem/ruby/common/SubBlock.hh" SubBlock::SubBlock(const Address& addr, int size) { - m_address = addr; - setSize(size); - for(int i=0; i<size; i++) { - setByte(i, 0); - } + m_address = addr; + setSize(size); + for (int i = 0; i < size; i++) { + setByte(i, 0); + } } -void SubBlock::internalMergeFrom(const DataBlock& data) +void +SubBlock::internalMergeFrom(const DataBlock& data) { - int size = getSize(); - assert(size > 0); - int offset = m_address.getOffset(); - for(int i=0; i<size; i++) { - this->setByte(i, data.getByte(offset+i)); - } + int size = getSize(); + assert(size > 0); + int offset = m_address.getOffset(); + for (int i = 0; i < size; i++) { + this->setByte(i, data.getByte(offset + i)); + } } -void SubBlock::internalMergeTo(DataBlock& data) const +void +SubBlock::internalMergeTo(DataBlock& data) const { - int size = getSize(); - assert(size > 0); - int offset = m_address.getOffset(); - for(int i=0; i<size; i++) { - data.setByte(offset+i, this->getByte(i)); // This will detect crossing a cache line boundary - } + int size = getSize(); + assert(size > 0); + int offset = m_address.getOffset(); + for (int i = 0; i < size; i++) { + // This will detect crossing a cache line boundary + data.setByte(offset + i, this->getByte(i)); + } } -void SubBlock::print(ostream& out) const +void +SubBlock::print(ostream& out) const { - out << "[" << m_address << ", " << getSize() << ", " << m_data << "]"; + out << "[" << m_address << ", " << getSize() << ", " << m_data << "]"; } diff --git a/src/mem/ruby/common/SubBlock.hh b/src/mem/ruby/common/SubBlock.hh index 8acdd9f4d..ab286dd0e 100644 --- a/src/mem/ruby/common/SubBlock.hh +++ b/src/mem/ruby/common/SubBlock.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,69 +26,55 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - * - */ +#ifndef __MEM_RUBY_COMMON_SUBBLOCK_HH__ +#define __MEM_RUBY_COMMON_SUBBLOCK_HH__ -#ifndef SubBlock_H -#define SubBlock_H - -#include "mem/ruby/common/Global.hh" +#include "mem/gems_common/Vector.hh" #include "mem/ruby/common/Address.hh" #include "mem/ruby/common/DataBlock.hh" -#include "mem/gems_common/Vector.hh" - -class SubBlock { -public: - // Constructors - SubBlock() { } - SubBlock(const Address& addr, int size); +#include "mem/ruby/common/Global.hh" - // Destructor - ~SubBlock() { } +class SubBlock +{ + public: + SubBlock() { } + SubBlock(const Address& addr, int size); + ~SubBlock() { } - // Public Methods - const Address& getAddress() const { return m_address; } - void setAddress(const Address& addr) { m_address = addr; } + const Address& getAddress() const { return m_address; } + void setAddress(const Address& addr) { m_address = addr; } - int getSize() const { return m_data.size(); } - void setSize(int size) { m_data.setSize(size); } - uint8 getByte(int offset) const { return m_data[offset]; } - void setByte(int offset, uint8 data) { m_data[offset] = data; } + int getSize() const { return m_data.size(); } + void setSize(int size) { m_data.setSize(size); } + uint8 getByte(int offset) const { return m_data[offset]; } + void setByte(int offset, uint8 data) { m_data[offset] = data; } - // Shorthands - uint8 readByte() const { return getByte(0); } - void writeByte(uint8 data) { setByte(0, data); } + // Shorthands + uint8 readByte() const { return getByte(0); } + void writeByte(uint8 data) { setByte(0, data); } - // Merging to and from DataBlocks - We only need to worry about - // updates when we are using DataBlocks - void mergeTo(DataBlock& data) const { internalMergeTo(data); } - void mergeFrom(const DataBlock& data) { internalMergeFrom(data); } + // Merging to and from DataBlocks - We only need to worry about + // updates when we are using DataBlocks + void mergeTo(DataBlock& data) const { internalMergeTo(data); } + void mergeFrom(const DataBlock& data) { internalMergeFrom(data); } - void print(ostream& out) const; -private: + void print(ostream& out) const; - void internalMergeTo(DataBlock& data) const; - void internalMergeFrom(const DataBlock& data); + private: + void internalMergeTo(DataBlock& data) const; + void internalMergeFrom(const DataBlock& data); - // Data Members (m_ prefix) - Address m_address; - Vector<uint8_t> m_data; + // Data Members (m_ prefix) + Address m_address; + Vector<uint8_t> m_data; }; -// Output operator declaration -ostream& operator<<(ostream& out, const SubBlock& obj); - -// ******************* Definitions ******************* - -// Output operator definition -extern inline -ostream& operator<<(ostream& out, const SubBlock& obj) +inline ostream& +operator<<(ostream& out, const SubBlock& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } -#endif //SubBlock_H +#endif // __MEM_RUBY_COMMON_SUBBLOCK_HH__ diff --git a/src/mem/ruby/eventqueue/RubyEventQueue.cc b/src/mem/ruby/eventqueue/RubyEventQueue.cc index 3cfb52ff1..eaa22ff1e 100644 --- a/src/mem/ruby/eventqueue/RubyEventQueue.cc +++ b/src/mem/ruby/eventqueue/RubyEventQueue.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,16 +26,10 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - */ - -#include "mem/ruby/eventqueue/RubyEventQueue.hh" #include "mem/ruby/common/Consumer.hh" -#include "mem/ruby/system/System.hh" +#include "mem/ruby/eventqueue/RubyEventQueue.hh" #include "mem/ruby/eventqueue/RubyEventQueueNode.hh" - -// Class public method definitions +#include "mem/ruby/system/System.hh" RubyEventQueue::RubyEventQueue(EventQueue* eventq, Tick _clock) : EventManager(eventq), m_clock(_clock) @@ -47,28 +40,28 @@ RubyEventQueue::~RubyEventQueue() { } -void RubyEventQueue::scheduleEvent(Consumer* consumer, Time timeDelta) -{ - scheduleEventAbsolute(consumer, timeDelta + getTime()); +void +RubyEventQueue::scheduleEvent(Consumer* consumer, Time timeDelta) +{ + scheduleEventAbsolute(consumer, timeDelta + getTime()); } -void RubyEventQueue::scheduleEventAbsolute(Consumer* consumer, Time timeAbs) +void +RubyEventQueue::scheduleEventAbsolute(Consumer* consumer, Time timeAbs) { - // Check to see if this is a redundant wakeup - ASSERT(consumer != NULL); - if (!consumer->alreadyScheduled(timeAbs)) { - // This wakeup is not redundant - RubyEventQueueNode *thisNode = new RubyEventQueueNode(consumer, this); - assert(timeAbs > getTime()); - schedule(thisNode, (timeAbs * m_clock)); - consumer->insertScheduledWakeupTime(timeAbs); - } + // Check to see if this is a redundant wakeup + ASSERT(consumer != NULL); + if (!consumer->alreadyScheduled(timeAbs)) { + // This wakeup is not redundant + RubyEventQueueNode *thisNode = new RubyEventQueueNode(consumer, this); + assert(timeAbs > getTime()); + schedule(thisNode, (timeAbs * m_clock)); + consumer->insertScheduledWakeupTime(timeAbs); + } } -// Class private method definitions - void RubyEventQueue::print(ostream& out) const { - out << "[Event Queue:]"; + out << "[Event Queue:]"; } diff --git a/src/mem/ruby/eventqueue/RubyEventQueue.hh b/src/mem/ruby/eventqueue/RubyEventQueue.hh index 468b21edb..d2ebc42c2 100644 --- a/src/mem/ruby/eventqueue/RubyEventQueue.hh +++ b/src/mem/ruby/eventqueue/RubyEventQueue.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -28,9 +27,7 @@ */ /* - * $Id$ - * - * Description: The RubyEventQueue class implements an event queue which + * The RubyEventQueue class implements an event queue which * can be trigger events, allowing our simulation to be event driven. * * Currently, the only event we support is a Consumer being signaled @@ -56,8 +53,8 @@ * */ -#ifndef RUBYEVENTQUEUE_H -#define RUBYEVENTQUEUE_H +#ifndef __MEM_RUBY_EVENTQUEUE_RUBYEVENTQUEUE_HH__ +#define __MEM_RUBY_EVENTQUEUE_RUBYEVENTQUEUE_HH__ #include <iostream> @@ -70,48 +67,36 @@ class Consumer; template <class TYPE> class PrioHeap; class RubyEventQueueNode; -class RubyEventQueue : public EventManager { -public: - // Constructors - RubyEventQueue(EventQueue* eventq, Tick _clock); - - // Destructor - ~RubyEventQueue(); - - // Public Methods - - Time getTime() const { return curTick/m_clock; } - Tick getClock() const { return m_clock; } - void scheduleEvent(Consumer* consumer, Time timeDelta); - void scheduleEventAbsolute(Consumer* consumer, Time timeAbs); - void print(std::ostream& out) const; - - void triggerEvents(Time t) { assert(0); } - void triggerAllEvents() { assert(0); } - - // Private Methods -private: - // Private copy constructor and assignment operator - RubyEventQueue(const RubyEventQueue& obj); - RubyEventQueue& operator=(const RubyEventQueue& obj); - - // Data Members (m_ prefix) - Tick m_clock; +class RubyEventQueue : public EventManager +{ + public: + RubyEventQueue(EventQueue* eventq, Tick _clock); + ~RubyEventQueue(); + + Time getTime() const { return curTick/m_clock; } + Tick getClock() const { return m_clock; } + void scheduleEvent(Consumer* consumer, Time timeDelta); + void scheduleEventAbsolute(Consumer* consumer, Time timeAbs); + void print(std::ostream& out) const; + + void triggerEvents(Time t) { assert(0); } + void triggerAllEvents() { assert(0); } + + private: + // Private copy constructor and assignment operator + RubyEventQueue(const RubyEventQueue& obj); + RubyEventQueue& operator=(const RubyEventQueue& obj); + + // Data Members (m_ prefix) + Tick m_clock; }; -// Output operator declaration -inline extern -std::ostream& operator<<(std::ostream& out, const RubyEventQueue& obj); - -// ******************* Definitions ******************* - -// Output operator definition -inline extern -std::ostream& operator<<(std::ostream& out, const RubyEventQueue& obj) +inline std::ostream& +operator<<(std::ostream& out, const RubyEventQueue& obj) { - obj.print(out); - out << std::flush; - return out; + obj.print(out); + out << std::flush; + return out; } -#endif //EVENTQUEUE_H +#endif // __MEM_RUBY_EVENTQUEUE_RUBYEVENTQUEUE_HH__ diff --git a/src/mem/ruby/eventqueue/RubyEventQueueNode.cc b/src/mem/ruby/eventqueue/RubyEventQueueNode.cc index 31aa2088a..c15452dd9 100644 --- a/src/mem/ruby/eventqueue/RubyEventQueueNode.cc +++ b/src/mem/ruby/eventqueue/RubyEventQueueNode.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,20 +26,16 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - * - */ - #include "mem/ruby/eventqueue/RubyEventQueueNode.hh" -void RubyEventQueueNode::print(std::ostream& out) const +void +RubyEventQueueNode::print(std::ostream& out) const { - out << "["; - if (m_consumer_ptr != NULL) { - out << " Consumer=" << m_consumer_ptr; - } else { - out << " Consumer=NULL"; - } - out << "]"; + out << "["; + if (m_consumer_ptr != NULL) { + out << " Consumer=" << m_consumer_ptr; + } else { + out << " Consumer=NULL"; + } + out << "]"; } diff --git a/src/mem/ruby/eventqueue/RubyEventQueueNode.hh b/src/mem/ruby/eventqueue/RubyEventQueueNode.hh index 46d8b317c..c759e7f57 100644 --- a/src/mem/ruby/eventqueue/RubyEventQueueNode.hh +++ b/src/mem/ruby/eventqueue/RubyEventQueueNode.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,65 +26,44 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - * - */ - -#ifndef RUBYEVENTQUEUENODE_H -#define RUBYEVENTQUEUENODE_H +#ifndef __MEM_RUBY_EVENTQUEUE_RUBYEVENTQUEUENODE_HH__ +#define __MEM_RUBY_EVENTQUEUE_RUBYEVENTQUEUENODE_HH__ #include <iostream> +#include "mem/ruby/common/Consumer.hh" #include "mem/ruby/common/Global.hh" #include "sim/eventq.hh" -#include "mem/ruby/common/Consumer.hh" -//class Consumer; -class RubyEventQueueNode : public Event { -public: - // Constructors - RubyEventQueueNode(Consumer* _consumer, RubyEventQueue* _eventq) - : m_consumer_ptr(_consumer), m_eventq_ptr(_eventq) - { - setFlags(AutoDelete); - } - - // Destructor - //~RubyEventQueueNode(); - - // Public Methods - void print(std::ostream& out) const; - virtual void process() - { - m_consumer_ptr->wakeup(); - m_consumer_ptr->removeScheduledWakeupTime(m_eventq_ptr->getTime()); - } - virtual const char *description() const { return "Ruby Event"; } - -private: - // Private Methods +class RubyEventQueueNode : public Event +{ + public: + RubyEventQueueNode(Consumer* _consumer, RubyEventQueue* _eventq) + : m_consumer_ptr(_consumer), m_eventq_ptr(_eventq) + { + setFlags(AutoDelete); + } - // Default copy constructor and assignment operator - // RubyEventQueueNode(const RubyEventQueueNode& obj); + void print(std::ostream& out) const; + virtual void + process() + { + m_consumer_ptr->wakeup(); + m_consumer_ptr->removeScheduledWakeupTime(m_eventq_ptr->getTime()); + } + virtual const char *description() const { return "Ruby Event"; } - // Data Members (m_ prefix) - Consumer* m_consumer_ptr; - RubyEventQueue* m_eventq_ptr; + private: + Consumer* m_consumer_ptr; + RubyEventQueue* m_eventq_ptr; }; -// Output operator declaration -std::ostream& operator<<(std::ostream& out, const RubyEventQueueNode& obj); - -// ******************* Definitions ******************* - -// Output operator definition -extern inline -std::ostream& operator<<(std::ostream& out, const RubyEventQueueNode& obj) +inline std::ostream& +operator<<(std::ostream& out, const RubyEventQueueNode& obj) { - obj.print(out); - out << std::flush; - return out; + obj.print(out); + out << std::flush; + return out; } -#endif //EVENTQUEUENODE_H +#endif // __MEM_RUBY_EVENTQUEUE_EVENTQUEUENODE_HH__ diff --git a/src/mem/ruby/filters/AbstractBloomFilter.hh b/src/mem/ruby/filters/AbstractBloomFilter.hh index 89aeb25a6..de11b4499 100644 --- a/src/mem/ruby/filters/AbstractBloomFilter.hh +++ b/src/mem/ruby/filters/AbstractBloomFilter.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,44 +26,32 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * AbstractBloomFilter.hh - * - * Description: - * - * - */ - -#ifndef ABSTRACT_BLOOM_FILTER_H -#define ABSTRACT_BLOOM_FILTER_H +#ifndef __MEM_RUBY_FILTERS_ABSTRACTBLOOMFILTER_HH__ +#define __MEM_RUBY_FILTERS_ABSTRACTBLOOMFILTER_HH__ -#include "mem/ruby/common/Global.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" -class AbstractBloomFilter { -public: - - virtual ~AbstractBloomFilter() {}; - virtual void clear() = 0; - virtual void increment(const Address& addr) = 0; - virtual void decrement(const Address& addr) = 0; - virtual void merge(AbstractBloomFilter * other_filter) = 0; - virtual void set(const Address& addr) = 0; - virtual void unset(const Address& addr) = 0; - - virtual bool isSet(const Address& addr) = 0; - virtual int getCount(const Address& addr) = 0; - virtual int getTotalCount() = 0; - - virtual void print(ostream& out) const = 0; - - virtual int getIndex(const Address& addr) = 0; - virtual int readBit(const int index) = 0; - virtual void writeBit(const int index, const int value) = 0; - -private: - +class AbstractBloomFilter +{ + public: + virtual ~AbstractBloomFilter() {}; + virtual void clear() = 0; + virtual void increment(const Address& addr) = 0; + virtual void decrement(const Address& addr) = 0; + virtual void merge(AbstractBloomFilter * other_filter) = 0; + virtual void set(const Address& addr) = 0; + virtual void unset(const Address& addr) = 0; + + virtual bool isSet(const Address& addr) = 0; + virtual int getCount(const Address& addr) = 0; + virtual int getTotalCount() = 0; + + virtual void print(ostream& out) const = 0; + + virtual int getIndex(const Address& addr) = 0; + virtual int readBit(const int index) = 0; + virtual void writeBit(const int index, const int value) = 0; }; - -#endif +#endif // __MEM_RUBY_FILTERS_ABSTRACTBLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/BlockBloomFilter.cc b/src/mem/ruby/filters/BlockBloomFilter.cc index 9bf5b41c5..74b14593e 100644 --- a/src/mem/ruby/filters/BlockBloomFilter.cc +++ b/src/mem/ruby/filters/BlockBloomFilter.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,121 +26,133 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * BlockBloomFilter.cc - * - * Description: - * - * - */ - -#include "mem/ruby/filters/BlockBloomFilter.hh" #include "mem/gems_common/Map.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/filters/BlockBloomFilter.hh" BlockBloomFilter::BlockBloomFilter(string str) { - string tail(str); - string head = string_split(tail, '_'); + string tail(str); + string head = string_split(tail, '_'); - m_filter_size = atoi(head.c_str()); - m_filter_size_bits = log_int(m_filter_size); + m_filter_size = atoi(head.c_str()); + m_filter_size_bits = log_int(m_filter_size); - m_filter.setSize(m_filter_size); + m_filter.setSize(m_filter_size); - clear(); + clear(); } -BlockBloomFilter::~BlockBloomFilter(){ +BlockBloomFilter::~BlockBloomFilter() +{ } -void BlockBloomFilter::clear() +void +BlockBloomFilter::clear() { - for (int i = 0; i < m_filter_size; i++) { - m_filter[i] = 0; - } + for (int i = 0; i < m_filter_size; i++) { + m_filter[i] = 0; + } } -void BlockBloomFilter::increment(const Address& addr) +void +BlockBloomFilter::increment(const Address& addr) { - // Not used + // Not used } - -void BlockBloomFilter::decrement(const Address& addr) +void +BlockBloomFilter::decrement(const Address& addr) { - // Not used + // Not used } -void BlockBloomFilter::merge(AbstractBloomFilter * other_filter) +void +BlockBloomFilter::merge(AbstractBloomFilter * other_filter) { - // TODO + // TODO } -void BlockBloomFilter::set(const Address& addr) +void +BlockBloomFilter::set(const Address& addr) { - int i = get_index(addr); - m_filter[i] = 1; + int i = get_index(addr); + m_filter[i] = 1; } -void BlockBloomFilter::unset(const Address& addr) +void +BlockBloomFilter::unset(const Address& addr) { - int i = get_index(addr); - m_filter[i] = 0; + int i = get_index(addr); + m_filter[i] = 0; } -bool BlockBloomFilter::isSet(const Address& addr) +bool +BlockBloomFilter::isSet(const Address& addr) { - int i = get_index(addr); - return (m_filter[i]); + int i = get_index(addr); + return (m_filter[i]); } - -int BlockBloomFilter::getCount(const Address& addr) +int +BlockBloomFilter::getCount(const Address& addr) { - return m_filter[get_index(addr)]; + return m_filter[get_index(addr)]; } -int BlockBloomFilter::getTotalCount() +int +BlockBloomFilter::getTotalCount() { - int count = 0; + int count = 0; - for (int i = 0; i < m_filter_size; i++) { - if (m_filter[i]) { - count++; + for (int i = 0; i < m_filter_size; i++) { + if (m_filter[i]) { + count++; + } } - } - return count; + return count; } -int BlockBloomFilter::getIndex(const Address& addr) +int +BlockBloomFilter::getIndex(const Address& addr) { - return get_index(addr); + return get_index(addr); } -void BlockBloomFilter::print(ostream& out) const +void +BlockBloomFilter::print(ostream& out) const { } -int BlockBloomFilter::readBit(const int index) { - return m_filter[index]; +int +BlockBloomFilter::readBit(const int index) +{ + return m_filter[index]; } -void BlockBloomFilter::writeBit(const int index, const int value) { - m_filter[index] = value; +void +BlockBloomFilter::writeBit(const int index, const int value) +{ + m_filter[index] = value; } -int BlockBloomFilter::get_index(const Address& addr) +int +BlockBloomFilter::get_index(const Address& addr) { - // Pull out some bit field ==> B1 - // Pull out additional bits, not the same as B1 ==> B2 - // XOR B1 and B2 to get hash index - physical_address_t block_bits = addr.bitSelect( RubySystem::getBlockSizeBits(), 2*RubySystem::getBlockSizeBits() - 1); - int offset = 5; - physical_address_t other_bits = addr.bitSelect( 2*RubySystem::getBlockSizeBits() + offset, 2*RubySystem::getBlockSizeBits() + offset + m_filter_size_bits - 1); - int index = block_bits ^ other_bits; - assert(index < m_filter_size); - return index; + // Pull out some bit field ==> B1 + // Pull out additional bits, not the same as B1 ==> B2 + // XOR B1 and B2 to get hash index + physical_address_t block_bits = + addr.bitSelect(RubySystem::getBlockSizeBits(), + 2 * RubySystem::getBlockSizeBits() - 1); + int offset = 5; + physical_address_t other_bits = + addr.bitSelect(2 * RubySystem::getBlockSizeBits() + offset, + 2 * RubySystem::getBlockSizeBits() + offset + + m_filter_size_bits - 1); + int index = block_bits ^ other_bits; + assert(index < m_filter_size); + return index; } diff --git a/src/mem/ruby/filters/BlockBloomFilter.hh b/src/mem/ruby/filters/BlockBloomFilter.hh index be9faa443..14f064975 100644 --- a/src/mem/ruby/filters/BlockBloomFilter.hh +++ b/src/mem/ruby/filters/BlockBloomFilter.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,55 +26,45 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * BlockBloomFilter.hh - * - * Description: - * - * - */ - -#ifndef BLOCK_BLOOM_FILTER_H -#define BLOCK_BLOOM_FILTER_H +#ifndef __MEM_RUBY_FILTERS_BLOCKBLOOMFILTER_HH__ +#define __MEM_RUBY_FILTERS_BLOCKBLOOMFILTER_HH__ #include "mem/gems_common/Map.hh" -#include "mem/ruby/common/Global.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/filters/AbstractBloomFilter.hh" -class BlockBloomFilter : public AbstractBloomFilter { -public: +class BlockBloomFilter : public AbstractBloomFilter +{ + public: + BlockBloomFilter(string config); + ~BlockBloomFilter(); - ~BlockBloomFilter(); - BlockBloomFilter(string config); + void clear(); + void increment(const Address& addr); + void decrement(const Address& addr); + void merge(AbstractBloomFilter * other_filter); + void set(const Address& addr); + void unset(const Address& addr); - void clear(); - void increment(const Address& addr); - void decrement(const Address& addr); - void merge(AbstractBloomFilter * other_filter); - void set(const Address& addr); - void unset(const Address& addr); + bool isSet(const Address& addr); + int getCount(const Address& addr); + int getTotalCount(); + int getIndex(const Address& addr); + int readBit(const int index); + void writeBit(const int index, const int value); - bool isSet(const Address& addr); - int getCount(const Address& addr); - int getTotalCount(); - int getIndex(const Address& addr); - int readBit(const int index); - void writeBit(const int index, const int value); + void print(ostream& out) const; - void print(ostream& out) const; + private: + int get_index(const Address& addr); -private: + Vector<int> m_filter; + int m_filter_size; + int m_filter_size_bits; - int get_index(const Address& addr); - - Vector<int> m_filter; - int m_filter_size; - int m_filter_size_bits; - - int m_count_bits; - int m_count; + int m_count_bits; + int m_count; }; - -#endif +#endif // __MEM_RUBY_FILTERS_BLOCKBLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/BulkBloomFilter.cc b/src/mem/ruby/filters/BulkBloomFilter.cc index 264b4201c..1788c0391 100644 --- a/src/mem/ruby/filters/BulkBloomFilter.cc +++ b/src/mem/ruby/filters/BulkBloomFilter.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,206 +26,220 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * BulkBloomFilter.cc - * - * Description: - * - * - */ - -#include "mem/ruby/filters/BulkBloomFilter.hh" #include "mem/gems_common/Map.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/filters/BulkBloomFilter.hh" BulkBloomFilter::BulkBloomFilter(string str) { - string tail(str); - string head = string_split(tail, '_'); + string tail(str); + string head = string_split(tail, '_'); - m_filter_size = atoi(head.c_str()); - m_filter_size_bits = log_int(m_filter_size); - // split the filter bits in half, c0 and c1 - m_sector_bits = m_filter_size_bits - 1; + m_filter_size = atoi(head.c_str()); + m_filter_size_bits = log_int(m_filter_size); + // split the filter bits in half, c0 and c1 + m_sector_bits = m_filter_size_bits - 1; - m_temp_filter.setSize(m_filter_size); - m_filter.setSize(m_filter_size); - clear(); - - // clear temp filter - for(int i=0; i < m_filter_size; ++i){ - m_temp_filter[i] = 0; - } -} - -BulkBloomFilter::~BulkBloomFilter(){ + m_temp_filter.setSize(m_filter_size); + m_filter.setSize(m_filter_size); + clear(); + // clear temp filter + for (int i = 0; i < m_filter_size; ++i) { + m_temp_filter[i] = 0; + } } -void BulkBloomFilter::clear() +BulkBloomFilter::~BulkBloomFilter() { - for (int i = 0; i < m_filter_size; i++) { - m_filter[i] = 0; - } } -void BulkBloomFilter::increment(const Address& addr) +void +BulkBloomFilter::clear() { - // Not used + for (int i = 0; i < m_filter_size; i++) { + m_filter[i] = 0; + } } - -void BulkBloomFilter::decrement(const Address& addr) +void +BulkBloomFilter::increment(const Address& addr) { - // Not used + // Not used } -void BulkBloomFilter::merge(AbstractBloomFilter * other_filter) +void +BulkBloomFilter::decrement(const Address& addr) { - // TODO + // Not used } -void BulkBloomFilter::set(const Address& addr) +void +BulkBloomFilter::merge(AbstractBloomFilter * other_filter) { - // c0 contains the cache index bits - int set_bits = m_sector_bits; - int block_bits = RubySystem::getBlockSizeBits(); - int c0 = addr.bitSelect( block_bits, block_bits + set_bits - 1); - // c1 contains the lower m_sector_bits permuted bits - //Address permuted_bits = permute(addr); - //int c1 = permuted_bits.bitSelect(0, set_bits-1); - int c1 = addr.bitSelect( block_bits+set_bits, (block_bits+2*set_bits) - 1); - //ASSERT(c0 < (m_filter_size/2)); - //ASSERT(c0 + (m_filter_size/2) < m_filter_size); - //ASSERT(c1 < (m_filter_size/2)); - // set v0 bit - m_filter[c0 + (m_filter_size/2)] = 1; - // set v1 bit - m_filter[c1] = 1; + // TODO } -void BulkBloomFilter::unset(const Address& addr) +void +BulkBloomFilter::set(const Address& addr) +{ + // c0 contains the cache index bits + int set_bits = m_sector_bits; + int block_bits = RubySystem::getBlockSizeBits(); + int c0 = addr.bitSelect( block_bits, block_bits + set_bits - 1); + // c1 contains the lower m_sector_bits permuted bits + //Address permuted_bits = permute(addr); + //int c1 = permuted_bits.bitSelect(0, set_bits-1); + int c1 = addr.bitSelect( block_bits+set_bits, (block_bits+2*set_bits) - 1); + //ASSERT(c0 < (m_filter_size/2)); + //ASSERT(c0 + (m_filter_size/2) < m_filter_size); + //ASSERT(c1 < (m_filter_size/2)); + // set v0 bit + m_filter[c0 + (m_filter_size/2)] = 1; + // set v1 bit + m_filter[c1] = 1; +} + +void +BulkBloomFilter::unset(const Address& addr) { - // not used + // not used } -bool BulkBloomFilter::isSet(const Address& addr) +bool +BulkBloomFilter::isSet(const Address& addr) { - // c0 contains the cache index bits - int set_bits = m_sector_bits; - int block_bits = RubySystem::getBlockSizeBits(); - int c0 = addr.bitSelect( block_bits, block_bits + set_bits - 1); - // c1 contains the lower 10 permuted bits - //Address permuted_bits = permute(addr); - //int c1 = permuted_bits.bitSelect(0, set_bits-1); - int c1 = addr.bitSelect( block_bits+set_bits, (block_bits+2*set_bits) - 1); - //ASSERT(c0 < (m_filter_size/2)); - //ASSERT(c0 + (m_filter_size/2) < m_filter_size); - //ASSERT(c1 < (m_filter_size/2)); - // set v0 bit - m_temp_filter[c0 + (m_filter_size/2)] = 1; - // set v1 bit - m_temp_filter[c1] = 1; + // c0 contains the cache index bits + int set_bits = m_sector_bits; + int block_bits = RubySystem::getBlockSizeBits(); + int c0 = addr.bitSelect( block_bits, block_bits + set_bits - 1); + // c1 contains the lower 10 permuted bits + //Address permuted_bits = permute(addr); + //int c1 = permuted_bits.bitSelect(0, set_bits-1); + int c1 = addr.bitSelect( block_bits+set_bits, (block_bits+2*set_bits) - 1); + //ASSERT(c0 < (m_filter_size/2)); + //ASSERT(c0 + (m_filter_size/2) < m_filter_size); + //ASSERT(c1 < (m_filter_size/2)); + // set v0 bit + m_temp_filter[c0 + (m_filter_size/2)] = 1; + // set v1 bit + m_temp_filter[c1] = 1; + + // perform filter intersection. If any c part is 0, no possibility + // of address being in signature. get first c intersection part + bool zero = false; + for (int i = 0; i < m_filter_size/2; ++i){ + // get intersection of signatures + m_temp_filter[i] = m_temp_filter[i] && m_filter[i]; + zero = zero || m_temp_filter[i]; + } + zero = !zero; + if (zero) { + // one section is zero, no possiblility of address in signature + // reset bits we just set + m_temp_filter[c0 + (m_filter_size / 2)] = 0; + m_temp_filter[c1] = 0; + return false; + } - // perform filter intersection. If any c part is 0, no possibility of address being in signature. - // get first c intersection part - bool zero = false; - for(int i=0; i < m_filter_size/2; ++i){ - // get intersection of signatures - m_temp_filter[i] = m_temp_filter[i] && m_filter[i]; - zero = zero || m_temp_filter[i]; - } - zero = !zero; - if(zero){ - // one section is zero, no possiblility of address in signature - // reset bits we just set - m_temp_filter[c0 + (m_filter_size/2)] = 0; - m_temp_filter[c1] = 0; - return false; - } - - // check second section - zero = false; - for(int i=m_filter_size/2; i < m_filter_size; ++i){ - // get intersection of signatures - m_temp_filter[i] = m_temp_filter[i] && m_filter[i]; - zero = zero || m_temp_filter[i]; - } - zero = !zero; - if(zero){ - // one section is zero, no possiblility of address in signature - m_temp_filter[c0 + (m_filter_size/2)] = 0; + // check second section + zero = false; + for(int i = m_filter_size / 2; i < m_filter_size; ++i) { + // get intersection of signatures + m_temp_filter[i] = m_temp_filter[i] && m_filter[i]; + zero = zero || m_temp_filter[i]; + } + zero = !zero; + if (zero) { + // one section is zero, no possiblility of address in signature + m_temp_filter[c0 + (m_filter_size / 2)] = 0; + m_temp_filter[c1] = 0; + return false; + } + // one section has at least one bit set + m_temp_filter[c0 + (m_filter_size / 2)] = 0; m_temp_filter[c1] = 0; - return false; - } - // one section has at least one bit set - m_temp_filter[c0 + (m_filter_size/2)] = 0; - m_temp_filter[c1] = 0; - return true; + return true; } - -int BulkBloomFilter::getCount(const Address& addr) +int +BulkBloomFilter::getCount(const Address& addr) { - // not used - return 0; + // not used + return 0; } -int BulkBloomFilter::getTotalCount() +int +BulkBloomFilter::getTotalCount() { - int count = 0; - for (int i = 0; i < m_filter_size; i++) { - if (m_filter[i]) { - count++; + int count = 0; + for (int i = 0; i < m_filter_size; i++) { + if (m_filter[i]) { + count++; + } } - } - return count; + return count; } -int BulkBloomFilter::getIndex(const Address& addr) +int +BulkBloomFilter::getIndex(const Address& addr) { - return get_index(addr); + return get_index(addr); } -int BulkBloomFilter::readBit(const int index) { - return 0; - // TODO +int +BulkBloomFilter::readBit(const int index) +{ + return 0; + // TODO } -void BulkBloomFilter::writeBit(const int index, const int value) { - // TODO +void +BulkBloomFilter::writeBit(const int index, const int value) +{ + // TODO } -void BulkBloomFilter::print(ostream& out) const +void +BulkBloomFilter::print(ostream& out) const { } -int BulkBloomFilter::get_index(const Address& addr) +int +BulkBloomFilter::get_index(const Address& addr) { - return addr.bitSelect( RubySystem::getBlockSizeBits(), RubySystem::getBlockSizeBits() + m_filter_size_bits - 1); + return addr.bitSelect(RubySystem::getBlockSizeBits(), + RubySystem::getBlockSizeBits() + + m_filter_size_bits - 1); } -Address BulkBloomFilter::permute(const Address & addr){ - // permutes the original address bits according to Table 5 - int block_offset = RubySystem::getBlockSizeBits(); - physical_address_t part1 = addr.bitSelect( block_offset, block_offset + 6 ); - physical_address_t part2 = addr.bitSelect( block_offset + 9, block_offset + 9 ); - physical_address_t part3 = addr.bitSelect( block_offset + 11, block_offset + 11 ); - physical_address_t part4 = addr.bitSelect( block_offset + 17, block_offset + 17 ); - physical_address_t part5 = addr.bitSelect( block_offset + 7, block_offset + 8 ); - physical_address_t part6 = addr.bitSelect( block_offset + 10, block_offset + 10 ); - physical_address_t part7 = addr.bitSelect( block_offset + 12, block_offset + 12 ); - physical_address_t part8 = addr.bitSelect( block_offset + 13, block_offset + 13 ); - physical_address_t part9 = addr.bitSelect( block_offset + 15, block_offset + 16 ); - physical_address_t part10 = addr.bitSelect( block_offset + 18, block_offset + 20 ); - physical_address_t part11 = addr.bitSelect( block_offset + 14, block_offset + 14 ); - - physical_address_t result = (part1 << 14 ) | (part2 << 13 ) | (part3 << 12 ) | (part4 << 11 ) | (part5 << 9) | (part6 << 8) - | (part7 << 7) | (part8 << 6) | (part9 << 4) | (part10 << 1) | (part11); - // assume 32 bit addresses (both virtual and physical) - // select the remaining high-order 11 bits - physical_address_t remaining_bits = (addr.bitSelect( block_offset + 21, 31 )) << 21; - result = result | remaining_bits; - - return Address(result); +Address +BulkBloomFilter::permute(const Address & addr) +{ + // permutes the original address bits according to Table 5 + int block_offset = RubySystem::getBlockSizeBits(); + physical_address_t part1 = addr.bitSelect(block_offset, block_offset + 6), + part2 = addr.bitSelect(block_offset + 9, block_offset + 9), + part3 = addr.bitSelect(block_offset + 11, block_offset + 11), + part4 = addr.bitSelect(block_offset + 17, block_offset + 17), + part5 = addr.bitSelect(block_offset + 7, block_offset + 8), + part6 = addr.bitSelect(block_offset + 10, block_offset + 10), + part7 = addr.bitSelect(block_offset + 12, block_offset + 12), + part8 = addr.bitSelect(block_offset + 13, block_offset + 13), + part9 = addr.bitSelect(block_offset + 15, block_offset + 16), + part10 = addr.bitSelect(block_offset + 18, block_offset + 20), + part11 = addr.bitSelect(block_offset + 14, block_offset + 14); + + physical_address_t result = + (part1 << 14) | (part2 << 13) | (part3 << 12) | (part4 << 11) | + (part5 << 9) | (part6 << 8) | (part7 << 7) | (part8 << 6) | + (part9 << 4) | (part10 << 1) | (part11); + + // assume 32 bit addresses (both virtual and physical) + // select the remaining high-order 11 bits + physical_address_t remaining_bits = + addr.bitSelect(block_offset + 21, 31) << 21; + result = result | remaining_bits; + + return Address(result); } diff --git a/src/mem/ruby/filters/BulkBloomFilter.hh b/src/mem/ruby/filters/BulkBloomFilter.hh index 089531791..53a913dc3 100644 --- a/src/mem/ruby/filters/BulkBloomFilter.hh +++ b/src/mem/ruby/filters/BulkBloomFilter.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,60 +26,50 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * BulkBloomFilter.hh - * - * Description: - * - * - */ - -#ifndef BULK_BLOOM_FILTER_H -#define BULK_BLOOM_FILTER_H +#ifndef __MEM_RUBY_FILTERS_BULKBLOOMFILTER_HH__ +#define __MEM_RUBY_FILTERS_BULKBLOOMFILTER_HH__ #include "mem/gems_common/Map.hh" -#include "mem/ruby/common/Global.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/filters/AbstractBloomFilter.hh" -class BulkBloomFilter : public AbstractBloomFilter { -public: +class BulkBloomFilter : public AbstractBloomFilter +{ + public: + BulkBloomFilter(string config); + ~BulkBloomFilter(); - ~BulkBloomFilter(); - BulkBloomFilter(string config); + void clear(); + void increment(const Address& addr); + void decrement(const Address& addr); + void merge(AbstractBloomFilter * other_filter); + void set(const Address& addr); + void unset(const Address& addr); - void clear(); - void increment(const Address& addr); - void decrement(const Address& addr); - void merge(AbstractBloomFilter * other_filter); - void set(const Address& addr); - void unset(const Address& addr); + bool isSet(const Address& addr); + int getCount(const Address& addr); + int getTotalCount(); + int getIndex(const Address& addr); + int readBit(const int index); + void writeBit(const int index, const int value); - bool isSet(const Address& addr); - int getCount(const Address& addr); - int getTotalCount(); - int getIndex(const Address& addr); - int readBit(const int index); - void writeBit(const int index, const int value); + void print(ostream& out) const; - void print(ostream& out) const; + private: + int get_index(const Address& addr); + Address permute(const Address & addr); -private: + Vector<int> m_filter; + Vector<int> m_temp_filter; - int get_index(const Address& addr); - Address permute(const Address & addr); + int m_filter_size; + int m_filter_size_bits; - Vector<int> m_filter; - Vector<int> m_temp_filter; + int m_sector_bits; - int m_filter_size; - int m_filter_size_bits; - - int m_sector_bits; - - int m_count_bits; - int m_count; + int m_count_bits; + int m_count; }; - -#endif +#endif // __MEM_RUBY_FILTERS_BULKBLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/GenericBloomFilter.cc b/src/mem/ruby/filters/GenericBloomFilter.cc index 22c75d64c..a31e97f1f 100644 --- a/src/mem/ruby/filters/GenericBloomFilter.cc +++ b/src/mem/ruby/filters/GenericBloomFilter.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,123 +26,122 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * GenericBloomFilter.hh - * - * Description: - * - * - */ - -#include "mem/ruby/common/Global.hh" #include "mem/ruby/common/Address.hh" - +#include "mem/ruby/common/Global.hh" +#include "mem/ruby/filters/BlockBloomFilter.hh" +#include "mem/ruby/filters/BulkBloomFilter.hh" #include "mem/ruby/filters/GenericBloomFilter.hh" +#include "mem/ruby/filters/H3BloomFilter.hh" #include "mem/ruby/filters/LSB_CountingBloomFilter.hh" -#include "mem/ruby/filters/NonCountingBloomFilter.hh" -#include "mem/ruby/filters/BulkBloomFilter.hh" -#include "mem/ruby/filters/BlockBloomFilter.hh" -#include "mem/ruby/filters/MultiGrainBloomFilter.hh" #include "mem/ruby/filters/MultiBitSelBloomFilter.hh" -#include "mem/ruby/filters/H3BloomFilter.hh" +#include "mem/ruby/filters/MultiGrainBloomFilter.hh" +#include "mem/ruby/filters/NonCountingBloomFilter.hh" GenericBloomFilter::GenericBloomFilter(string config) { - string tail(config); - string head = string_split(tail,'_'); - - if (head == "LSB_Counting" ) { - m_filter = new LSB_CountingBloomFilter(tail); - } - else if(head == "NonCounting" ) { - m_filter = new NonCountingBloomFilter(tail); - } - else if(head == "Bulk" ) { - m_filter = new BulkBloomFilter(tail); - } - else if(head == "Block") { - m_filter = new BlockBloomFilter(tail); - } - else if(head == "Multigrain"){ - m_filter = new MultiGrainBloomFilter(tail); - } - else if(head == "MultiBitSel"){ - m_filter = new MultiBitSelBloomFilter(tail); - } - else if(head == "H3"){ - m_filter = new H3BloomFilter(tail); - } - else { - assert(0); - } + string tail(config); + string head = string_split(tail,'_'); + + if (head == "LSB_Counting" ) { + m_filter = new LSB_CountingBloomFilter(tail); + } else if(head == "NonCounting" ) { + m_filter = new NonCountingBloomFilter(tail); + } else if(head == "Bulk" ) { + m_filter = new BulkBloomFilter(tail); + } else if(head == "Block") { + m_filter = new BlockBloomFilter(tail); + } else if(head == "Multigrain"){ + m_filter = new MultiGrainBloomFilter(tail); + } else if(head == "MultiBitSel"){ + m_filter = new MultiBitSelBloomFilter(tail); + } else if(head == "H3"){ + m_filter = new H3BloomFilter(tail); + } else { + assert(0); + } } GenericBloomFilter::~GenericBloomFilter() { - delete m_filter; + delete m_filter; } -void GenericBloomFilter::clear() +void +GenericBloomFilter::clear() { - m_filter->clear(); + m_filter->clear(); } -void GenericBloomFilter::increment(const Address& addr) +void +GenericBloomFilter::increment(const Address& addr) { - m_filter->increment(addr); + m_filter->increment(addr); } -void GenericBloomFilter::decrement(const Address& addr) +void +GenericBloomFilter::decrement(const Address& addr) { - m_filter->decrement(addr); + m_filter->decrement(addr); } -void GenericBloomFilter::merge(GenericBloomFilter * other_filter) +void +GenericBloomFilter::merge(GenericBloomFilter * other_filter) { - m_filter->merge(other_filter->getFilter()); + m_filter->merge(other_filter->getFilter()); } -void GenericBloomFilter::set(const Address& addr) +void +GenericBloomFilter::set(const Address& addr) { - m_filter->set(addr); + m_filter->set(addr); } -void GenericBloomFilter::unset(const Address& addr) +void +GenericBloomFilter::unset(const Address& addr) { - m_filter->unset(addr); + m_filter->unset(addr); } -bool GenericBloomFilter::isSet(const Address& addr) +bool +GenericBloomFilter::isSet(const Address& addr) { - return m_filter->isSet(addr); + return m_filter->isSet(addr); } -int GenericBloomFilter::getCount(const Address& addr) +int +GenericBloomFilter::getCount(const Address& addr) { - return m_filter->getCount(addr); + return m_filter->getCount(addr); } -int GenericBloomFilter::getTotalCount() +int +GenericBloomFilter::getTotalCount() { - return m_filter->getTotalCount(); + return m_filter->getTotalCount(); } -int GenericBloomFilter::getIndex(const Address& addr) +int +GenericBloomFilter::getIndex(const Address& addr) { - return m_filter->getIndex(addr); + return m_filter->getIndex(addr); } -int GenericBloomFilter::readBit(const int index) { - return m_filter->readBit(index); +int +GenericBloomFilter::readBit(const int index) +{ + return m_filter->readBit(index); } -void GenericBloomFilter::writeBit(const int index, const int value) { - m_filter->writeBit(index, value); +void +GenericBloomFilter::writeBit(const int index, const int value) +{ + m_filter->writeBit(index, value); } -void GenericBloomFilter::print(ostream& out) const +void +GenericBloomFilter::print(ostream& out) const { - return m_filter->print(out); + return m_filter->print(out); } diff --git a/src/mem/ruby/filters/GenericBloomFilter.hh b/src/mem/ruby/filters/GenericBloomFilter.hh index edee22f84..b7bd56d04 100644 --- a/src/mem/ruby/filters/GenericBloomFilter.hh +++ b/src/mem/ruby/filters/GenericBloomFilter.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,67 +26,54 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * GenericBloomFilter.hh - * - * Description: - * - * - */ - -#ifndef GENERIC_BLOOM_FILTER_H -#define GENERIC_BLOOM_FILTER_H +#ifndef __MEM_RUBY_FILTERS_GENERICBLOOMFILTER_HH__ +#define __MEM_RUBY_FILTERS_GENERICBLOOMFILTER_HH__ #include "mem/ruby/common/Global.hh" #include "mem/ruby/common/Address.hh" #include "mem/ruby/filters/AbstractBloomFilter.hh" -class GenericBloomFilter { -public: - - // Constructors - GenericBloomFilter(string config); - - void clear(); - void increment(const Address& addr); - void decrement(const Address& addr); - void merge(GenericBloomFilter * other_filter); - void set(const Address& addr); - void unset(const Address& addr); - AbstractBloomFilter * getFilter(){ - return m_filter; - } - - bool isSet(const Address& addr); - - int getCount(const Address& addr); +class GenericBloomFilter +{ + public: + GenericBloomFilter(string config); + ~GenericBloomFilter(); - int getTotalCount(); + void clear(); + void increment(const Address& addr); + void decrement(const Address& addr); + void merge(GenericBloomFilter * other_filter); + void set(const Address& addr); + void unset(const Address& addr); + AbstractBloomFilter * + getFilter() + { + return m_filter; + } - int getIndex(const Address& addr); - int readBit(const int index); - void writeBit(const int index, const int value); + bool isSet(const Address& addr); - void print(ostream& out) const; - void printConfig(ostream& out) { out << "GenericBloomFilter" << endl; } + int getCount(const Address& addr); - // Destructor - ~GenericBloomFilter(); + int getTotalCount(); + int getIndex(const Address& addr); + int readBit(const int index); + void writeBit(const int index, const int value); -private: + void print(ostream& out) const; + void printConfig(ostream& out) { out << "GenericBloomFilter" << endl; } - AbstractBloomFilter* m_filter; + private: + AbstractBloomFilter* m_filter; }; -// Output operator definition -extern inline -ostream& operator<<(ostream& out, const GenericBloomFilter& obj) +inline ostream& +operator<<(ostream& out, const GenericBloomFilter& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } - -#endif +#endif // __MEM_RUBY_FILTERS_GENERICBLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/H3BloomFilter.cc b/src/mem/ruby/filters/H3BloomFilter.cc index 6fd8ae1a0..c73a29a84 100644 --- a/src/mem/ruby/filters/H3BloomFilter.cc +++ b/src/mem/ruby/filters/H3BloomFilter.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,1338 +26,510 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * NonCountingBloomFilter.cc - * - * Description: - * - * - */ - -#include "mem/ruby/filters/H3BloomFilter.hh" #include "mem/gems_common/Map.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/filters/H3BloomFilter.hh" static int H3[64][16] = { -{ -33268410, -395488709, -311024285, -456111753, -181495008, -119997521, -220697869, -433891432, -755927921, -515226970, -719448198, -349842774, -269183649, -463275672, -429800228, -521598937 -}, -{ -628677802, -820947732, -809435975, -1024657192, -887631270, -412050215, -391365090, -324227279, -318338329, -1038393087, -489807930, -387366128, -518096428, -324184340, -429376066, -447109279 -}, -{ -599747653, -404960623, -103933604, -946416030, -656460913, -925957005, -1047665689, -163552053, -88359290, -841315415, -899833584, -1067336680, -348549994, -464045876, -270252128, -829897652 -}, -{ -215495230, -966696438, -82589012, -750102795, -909780866, -920285789, -769759214, -331966823, -939936006, -439950703, -883794828, -1009277508, -61634610, -741444350, -98689608, -524144422 -}, -{ -93868534, -196958667, -774076619, -327921978, -122538783, -879785030, -690748527, -3498564, -83163077, -1027963025, -582088444, -466152216, -312424878, -550064499, -646612667, -561099434 -}, -{ -1002047931, -395477707, -821317480, -890482112, -697094476, -263813044, -840275189, -469664185, -795625845, -211504898, -99204277, -1004491153, -725930417, -1064479221, -893834767, -839719181 -}, -{ -278507126, -985111995, -706462983, -1042178726, -123281719, -963778122, -500881056, -726291104, -134293026, -568379664, -317050609, -533470307, -1022365922, -197645211, -315125721, -634827678 -}, -{ -219227366, -553960647, -870169525, -322232839, -508322497, -648672696, -249405795, -883596102, -476433133, -541372919, -646647793, -1042679515, -43242483, -600187508, -499866821, -135713210 -}, -{ -52837162, -96966684, -401840460, -1071661176, -733560065, -150035417, -341319946, -811582750, -636173904, -519054065, -196321433, -1028294565, -882204070, -522965093, -48884074, -117810166 -}, -{ -650860353, -789534698, -328813544, -473250022, -143128306, -173196006, -846958825, -174632187, -683273509, -405459497, -787235556, -773873501, -240110267, -426797736, -92043842, -711789240 -}, -{ -586637493, -5059646, -398035664, -6686087, -498300175, -948278148, -681227731, -592751744, -572019677, -558044722, -589368271, -695745538, -1073416749, -529192035, -550984939, -1070620580 -}, -{ -102904663, -647598516, -758863940, -313426443, -76504114, -1050747783, -708436441, -563815069, -224107668, -875925186, -167675944, -926209739, -279737287, -1040288182, -768184312, -371708956 -}, -{ -683968868, -1027427757, -180781926, -742898864, -624078545, -645659833, -577225838, -987150210, -723410002, -224013421, -993286634, -33188488, -247264323, -888018697, -38048664, -189037096 -}, -{ -475612146, -426739285, -873726278, -529192871, -607715202, -388486246, -987001312, -474493980, -259747270, -417465536, -217062395, -392858482, -563810075, -137852805, -1051814153, -72895217 -}, -{ -71277086, -785496675, -500608842, -89633426, -274085706, -248467935, -838061983, -48106147, -773662506, -49545328, -9071573, -100739031, -602018002, -904371654, -534132064, -332211304 -}, -{ -401893602, -735125342, -775548339, -210224843, -256081130, -482894412, -350801633, -1035713633, -429458128, -327281409, -739927752, -359327650, -886942880, -847691759, -752417993, -359445596 -}, -{ -267472014, -1050659620, -1068232362, -1049684368, -17130239, -690524969, -793224378, -14455158, -423092885, -873853424, -430535778, -7867877, -309731959, -370260786, -862353083, -403906850 -}, -{ -993077283, -218812656, -389234651, -393202875, -413116501, -263300295, -470013158, -592730725, -441847172, -732392823, -407574059, -875664777, -271347307, -792954404, -554774761, -1022424300 -}, -{ -675919719, -637054073, -784720745, -149714381, -813144874, -502525801, -635436670, -1003196587, -160786091, -947509775, -969788637, -26854073, -257964369, -63898568, -539767732, -772364518 -}, -{ -943076868, -1021732472, -697575075, -15843624, -617573396, -534113303, -122953324, -964873912, -942995378, -87830944, -1012914818, -455484661, -592160054, -599844284, -810394353, -836812568 -}, -{ -688992674, -279465370, -731582262, -687883235, -438178468, -80493001, -342701501, -663561405, -23360106, -531315007, -508931618, -36294623, -231216223, -840438413, -255665680, -663205938 -}, -{ -857265418, -552630887, -8173237, -792122963, -210140052, -823124938, -667709953, -751538219, -991957789, -462064153, -19070176, -726604748, -714567823, -151147895, -1012619677, -697114353 -}, -{ -467105652, -683256174, -702387467, -28730434, -549942998, -48712701, -960519696, -1008345587, -679267717, -370932249, -880419471, -352141567, -331640403, -598772468, -95160685, -812053015 -}, -{ -1053491323, -430526562, -1014938507, -109685515, -765949103, -177288303, -1034642653, -485421658, -71850281, -981034542, -61620389, -601367920, -504420930, -220599168, -583051998, -158735752 -}, -{ -103033901, -522494916, -658494760, -959206022, -931348143, -834510661, -21542994, -189699884, -679327018, -171983002, -96774168, -456133168, -543103352, -923945936, -970074188, -643658485 -}, -{ -566379913, -805798263, -840662512, -820206124, -796507494, -223712542, -118811519, -662246595, -809326534, -416471323, -748027186, -161169753, -739149488, -276330378, -924837051, -964873733 -}, -{ -585882743, -135502711, -3386031, -625631285, -1068193307, -270342640, -432739484, -556606453, -826419155, -1038540977, -158000202, -69109538, -207087256, -298111218, -678046259, -184611498 -}, -{ -305310710, -46237988, -855726974, -735975153, -930663798, -425764232, -104362407, -391371443, -867622101, -71645091, -61824734, -661902640, -293738633, -309416189, -281710675, -879317360 -}, -{ -398146324, -398293087, -689145387, -1038451703, -521637478, -516134620, -314658937, -830334981, -583400300, -340083705, -68029852, -675389876, -994635780, -788959180, -406967042, -74403607 -}, -{ -69463153, -744427484, -191639960, -590927798, -969916795, -546846769, -728756758, -889355646, -520855076, -136068426, -776132410, -189663815, -252051082, -533662856, -362198652, -1026161384 -}, -{ -584984279, -1004834381, -568439705, -834508761, -21812513, -670870173, -1052043300, -341868768, -473755574, -124339439, -36193947, -437997647, -137419489, -58705193, -337793711, -340738909 -}, -{ -898051466, -512792906, -234874060, -655358775, -683745319, -671676404, -428888546, -639928192, -672697722, -176477579, -747020991, -758211282, -443045009, -205395173, -1016944273, -5584717 -}, -{ -156038300, -138620174, -588466825, -1061494056, -1013672100, -1064257198, -881417791, -839470738, -83519030, -100875683, -237486447, -461483733, -681527127, -777996147, -574635362, -815974538 -}, -{ -184168473, -519509808, -62531892, -51821173, -43787358, -385711644, -141325169, -36069511, -584183031, -571372909, -671503175, -226486781, -194932686, -1045460970, -753718579, -331442433 -}, -{ -73065106, -1015327221, -630916840, -1058053470, -306737587, -296343219, -907194989, -920172546, -224516225, -818625553, -551143849, -634570650, -432966225, -756438259, -939564853, -767999933 -}, -{ -884775648, -394862257, -446787794, -219833788, -727195727, -728122304, -249888353, -732947974, -289908868, -448282580, -618161877, -898939716, -739554163, -860631799, -1058977530, -86916736 -}, -{ -143850006, -352708694, -200194048, -979764914, -629404175, -546279766, -72106714, -860980514, -313190585, -897143111, -308425797, -953791785, -349924906, -221457005, -950588925, -908254505 -}, -{ -950032043, -829868728, -68623614, -714624605, -69760597, -297275854, -355894016, -985369737, -882852618, -864071289, -958512902, -950910111, -991368991, -829645051, -434698210, -771350575 -}, -{ -552695074, -319195551, -80297396, -496413831, -944046531, -621525571, -617653363, -416729825, -441842808, -9847464, -99420657, -1033914550, -812966458, -937053011, -673390195, -934577365 -}, -{ -1034695843, -190969665, -332900185, -51897434, -523888639, -883512843, -146908572, -506785674, -565814307, -692255649, -314052926, -826386588, -430691325, -866927620, -413880214, -936474339 -}, -{ -129380164, -741739952, -1013703462, -494392795, -957214600, -1010879043, -931790677, -94551922, -988065869, -120637871, -882506912, -395075379, -210570485, -812422692, -910383687, -817722285 -}, -{ -51850866, -283408630, -1053047202, -858940389, -818507731, -477082181, -353546901, -993324368, -407093779, -231608253, -1067319867, -73159811, -429792535, -971320614, -565699344, -718823399 -}, -{ -408185106, -491493570, -596050720, -310776444, -703628192, -454438809, -523988035, -728512200, -686012353, -976339656, -72816924, -116926720, -165866591, -452043792, -866943072, -968545481 -}, -{ -443231195, -905907843, -1061421320, -746360489, -1043120338, -1069659155, -463359031, -688303227, -186550710, -155347339, -1044842421, -1005904570, -69332909, -706951903, -422513657, -882038450 -}, -{ -430990623, -946501980, -742556791, -278398643, -183759217, -659404315, -279754382, -1069347846, -843746517, -222777670, -990835599, -548741637, -129220580, -1392170, -1032654091, -894058935 -}, -{ -452042227, -751640705, -259481376, -765824585, -145991469, -1013683228, -1055491225, -536379588, -392593350, -913368594, -1029429776, -226857786, -31505342, -1054416381, -32341741, -687106649 -}, -{ -404750944, -811417027, -869530820, -773491060, -810901282, -979340397, -1036910290, -461764404, -834235095, -765695033, -604692390, -452158120, -928988098, -442719218, -1024059719, -167723114 -}, -{ -974245177, -1046377300, -1003424287, -787349855, -336314155, -875074696, -1018462718, -890313003, -367376809, -86355556, -1020618772, -890710345, -444741481, -373230261, -767064947, -840920177 -}, -{ -719581124, -431808156, -138301690, -668222575, -497413494, -740492013, -485033226, -125301442, -831265111, -879071459, -341690480, -152975256, -850330086, -717444507, -694225877, -785340566 -}, -{ -1032766252, -140959364, -737474726, -1062767538, -364464647, -331414723, -356152634, -642832379, -158733632, -374691640, -285504811, -345349905, -876599880, -476392727, -479589210, -606376325 -}, -{ -174997730, -778177086, -319164313, -163614456, -10331364, -599358958, -8331663, -237538058, -159173957, -174533880, -65588684, -878222844, -424467599, -901803515, -187504218, -776690353 -}, -{ -803856182, -965850321, -694948067, -218315960, -358416571, -683713254, -178069303, -428076035, -686176454, -579553217, -357306738, -315018080, -886852373, -568563910, -896839725, -257416821 -}, -{ -401650013, -183289141, -497957228, -879734476, -265024455, -825794561, -889237440, -323359863, -100258491, -991414783, -313986632, -85847250, -362520248, -276103512, -1041630342, -525981595 -}, -{ -487732740, -46201705, -990837834, -62744493, -1067364756, -58015363, -690846283, -680262648, -997278956, -469357861, -432164624, -996763915, -211907847, -167824295, -144928194, -454839915 -}, -{ -41404232, -514493300, -259546924, -578217256, -972345130, -123299213, -346040332, -1014668104, -520910639, -579955198, -36627803, -179072921, -547684341, -598950511, -269497394, -854352266 -}, -{ -603906768, -100863318, -708837659, -204175569, -375560904, -908375384, -28314106, -6303733, -175283124, -749851198, -308667367, -415293931, -225365403, -1032188331, -977112710, -819705229 -}, -{ -399767123, -697985692, -356790426, -643687584, -298624218, -185095167, -381653926, -876816342, -296720023, -2205879, -235816616, -521850105, -622753786, -1021421218, -726349744, -256504902 -}, -{ -851245024, -1022500222, -511909628, -313809625, -99776025, -39710175, -798739932, -741832408, -140631966, -898295927, -607660421, -870669312, -1051422478, -789055529, -669113756, -681943450 -}, -{ -853872755, -491465269, -503341472, -98019440, -258267420, -335602837, -320687824, -1053324395, -24932389, -955011453, -934255131, -435625663, -501568768, -238967025, -549987406, -248619780 -}, -{ -411151284, -576471205, -757985419, -544137226, -968135693, -877548443, -194586894, -74882373, -248353663, -21207540, -273789651, -853653916, -861267970, -533253322, -3739570, -661358586 -}, -{ -271430986, -71390029, -257643671, -949329860, -348156406, -251939238, -445808698, -48269799, -907589462, -105677619, -635451508, -20805932, -464874661, -7542147, -243619464, -288304568 -}, -{ -368215982, -530288964, -770090421, -660961164, -614935537, -630760399, -931299233, -794519275, -779918979, -401746493, -561237006, -1027202224, -258968003, -339508073, -1050610516, -1064307013 -}, -{ -1039172162, -448331205, -928997884, -49813151, -198712120, -992335354, -671024050, -879525220, -745915336, -1038822580, -138669665, -917958819, -681422342, -792868818, -924762727, -816386174 -}, -{ -515190336, -313808618, -441296783, -1022120897, -792325033, -354387581, -59273006, -280075434, -411357221, -665274694, -4054464, -1059046246, -394261773, -848616745, -15446017, -517723271 -}}; + { 33268410, 395488709, 311024285, 456111753, + 181495008, 119997521, 220697869, 433891432, + 755927921, 515226970, 719448198, 349842774, + 269183649, 463275672, 429800228, 521598937, }, + + { 628677802, 820947732, 809435975, 1024657192, + 887631270, 412050215, 391365090, 324227279, + 318338329, 1038393087, 489807930, 387366128, + 518096428, 324184340, 429376066, 447109279, }, + + { 599747653, 404960623, 103933604, 946416030, + 656460913, 925957005, 1047665689, 163552053, + 88359290, 841315415, 899833584, 1067336680, + 348549994, 464045876, 270252128, 829897652, }, + + { 215495230, 966696438, 82589012, 750102795, + 909780866, 920285789, 769759214, 331966823, + 939936006, 439950703, 883794828, 1009277508, + 61634610, 741444350, 98689608, 524144422, }, + + { 93868534, 196958667, 774076619, 327921978, + 122538783, 879785030, 690748527, 3498564, + 83163077, 1027963025, 582088444, 466152216, + 312424878, 550064499, 646612667, 561099434, }, + + { 1002047931, 395477707, 821317480, 890482112, + 697094476, 263813044, 840275189, 469664185, + 795625845, 211504898, 99204277, 1004491153, + 725930417, 1064479221, 893834767, 839719181, }, + + { 278507126, 985111995, 706462983, 1042178726, + 123281719, 963778122, 500881056, 726291104, + 134293026, 568379664, 317050609, 533470307, + 1022365922, 197645211, 315125721, 634827678, }, + + { 219227366, 553960647, 870169525, 322232839, + 508322497, 648672696, 249405795, 883596102, + 476433133, 541372919, 646647793, 1042679515, + 43242483, 600187508, 499866821, 135713210, }, + + { 52837162, 96966684, 401840460, 1071661176, + 733560065, 150035417, 341319946, 811582750, + 636173904, 519054065, 196321433, 1028294565, + 882204070, 522965093, 48884074, 117810166, }, + + { 650860353, 789534698, 328813544, 473250022, + 143128306, 173196006, 846958825, 174632187, + 683273509, 405459497, 787235556, 773873501, + 240110267, 426797736, 92043842, 711789240, }, + + { 586637493, 5059646, 398035664, 6686087, + 498300175, 948278148, 681227731, 592751744, + 572019677, 558044722, 589368271, 695745538, + 1073416749, 529192035, 550984939, 1070620580, }, + + { 102904663, 647598516, 758863940, 313426443, + 76504114, 1050747783, 708436441, 563815069, + 224107668, 875925186, 167675944, 926209739, + 279737287, 1040288182, 768184312, 371708956, }, + + { 683968868, 1027427757, 180781926, 742898864, + 624078545, 645659833, 577225838, 987150210, + 723410002, 224013421, 993286634, 33188488, + 247264323, 888018697, 38048664, 189037096, }, + + { 475612146, 426739285, 873726278, 529192871, + 607715202, 388486246, 987001312, 474493980, + 259747270, 417465536, 217062395, 392858482, + 563810075, 137852805, 1051814153, 72895217, }, + + { 71277086, 785496675, 500608842, 89633426, + 274085706, 248467935, 838061983, 48106147, + 773662506, 49545328, 9071573, 100739031, + 602018002, 904371654, 534132064, 332211304, }, + + { 401893602, 735125342, 775548339, 210224843, + 256081130, 482894412, 350801633, 1035713633, + 429458128, 327281409, 739927752, 359327650, + 886942880, 847691759, 752417993, 359445596, }, + + { 267472014, 1050659620, 1068232362, 1049684368, + 17130239, 690524969, 793224378, 14455158, + 423092885, 873853424, 430535778, 7867877, + 309731959, 370260786, 862353083, 403906850, }, + + { 993077283, 218812656, 389234651, 393202875, + 413116501, 263300295, 470013158, 592730725, + 441847172, 732392823, 407574059, 875664777, + 271347307, 792954404, 554774761, 1022424300, }, + + { 675919719, 637054073, 784720745, 149714381, + 813144874, 502525801, 635436670, 1003196587, + 160786091, 947509775, 969788637, 26854073, + 257964369, 63898568, 539767732, 772364518, }, + + { 943076868, 1021732472, 697575075, 15843624, + 617573396, 534113303, 122953324, 964873912, + 942995378, 87830944, 1012914818, 455484661, + 592160054, 599844284, 810394353, 836812568, }, + + { 688992674, 279465370, 731582262, 687883235, + 438178468, 80493001, 342701501, 663561405, + 23360106, 531315007, 508931618, 36294623, + 231216223, 840438413, 255665680, 663205938, }, + + { 857265418, 552630887, 8173237, 792122963, + 210140052, 823124938, 667709953, 751538219, + 991957789, 462064153, 19070176, 726604748, + 714567823, 151147895, 1012619677, 697114353, }, + + { 467105652, 683256174, 702387467, 28730434, + 549942998, 48712701, 960519696, 1008345587, + 679267717, 370932249, 880419471, 352141567, + 331640403, 598772468, 95160685, 812053015, }, + + { 1053491323, 430526562, 1014938507, 109685515, + 765949103, 177288303, 1034642653, 485421658, + 71850281, 981034542, 61620389, 601367920, + 504420930, 220599168, 583051998, 158735752, }, + + { 103033901, 522494916, 658494760, 959206022, + 931348143, 834510661, 21542994, 189699884, + 679327018, 171983002, 96774168, 456133168, + 543103352, 923945936, 970074188, 643658485, }, + + { 566379913, 805798263, 840662512, 820206124, + 796507494, 223712542, 118811519, 662246595, + 809326534, 416471323, 748027186, 161169753, + 739149488, 276330378, 924837051, 964873733, }, + + { 585882743, 135502711, 3386031, 625631285, + 1068193307, 270342640, 432739484, 556606453, + 826419155, 1038540977, 158000202, 69109538, + 207087256, 298111218, 678046259, 184611498, }, + + { 305310710, 46237988, 855726974, 735975153, + 930663798, 425764232, 104362407, 391371443, + 867622101, 71645091, 61824734, 661902640, + 293738633, 309416189, 281710675, 879317360, }, + + { 398146324, 398293087, 689145387, 1038451703, + 521637478, 516134620, 314658937, 830334981, + 583400300, 340083705, 68029852, 675389876, + 994635780, 788959180, 406967042, 74403607, }, + + { 69463153, 744427484, 191639960, 590927798, + 969916795, 546846769, 728756758, 889355646, + 520855076, 136068426, 776132410, 189663815, + 252051082, 533662856, 362198652, 1026161384, }, + + { 584984279, 1004834381, 568439705, 834508761, + 21812513, 670870173, 1052043300, 341868768, + 473755574, 124339439, 36193947, 437997647, + 137419489, 58705193, 337793711, 340738909, }, + + { 898051466, 512792906, 234874060, 655358775, + 683745319, 671676404, 428888546, 639928192, + 672697722, 176477579, 747020991, 758211282, + 443045009, 205395173, 1016944273, 5584717, }, + + { 156038300, 138620174, 588466825, 1061494056, + 1013672100, 1064257198, 881417791, 839470738, + 83519030, 100875683, 237486447, 461483733, + 681527127, 777996147, 574635362, 815974538, }, + + { 184168473, 519509808, 62531892, 51821173, + 43787358, 385711644, 141325169, 36069511, + 584183031, 571372909, 671503175, 226486781, + 194932686, 1045460970, 753718579, 331442433, }, + + { 73065106, 1015327221, 630916840, 1058053470, + 306737587, 296343219, 907194989, 920172546, + 224516225, 818625553, 551143849, 634570650, + 432966225, 756438259, 939564853, 767999933, }, + + { 884775648, 394862257, 446787794, 219833788, + 727195727, 728122304, 249888353, 732947974, + 289908868, 448282580, 618161877, 898939716, + 739554163, 860631799, 1058977530, 86916736, }, + + { 143850006, 352708694, 200194048, 979764914, + 629404175, 546279766, 72106714, 860980514, + 313190585, 897143111, 308425797, 953791785, + 349924906, 221457005, 950588925, 908254505, }, + + { 950032043, 829868728, 68623614, 714624605, + 69760597, 297275854, 355894016, 985369737, + 882852618, 864071289, 958512902, 950910111, + 991368991, 829645051, 434698210, 771350575, }, + + { 552695074, 319195551, 80297396, 496413831, + 944046531, 621525571, 617653363, 416729825, + 441842808, 9847464, 99420657, 1033914550, + 812966458, 937053011, 673390195, 934577365, }, + + { 1034695843, 190969665, 332900185, 51897434, + 523888639, 883512843, 146908572, 506785674, + 565814307, 692255649, 314052926, 826386588, + 430691325, 866927620, 413880214, 936474339, }, + + { 129380164, 741739952, 1013703462, 494392795, + 957214600, 1010879043, 931790677, 94551922, + 988065869, 120637871, 882506912, 395075379, + 210570485, 812422692, 910383687, 817722285, }, + + { 51850866, 283408630, 1053047202, 858940389, + 818507731, 477082181, 353546901, 993324368, + 407093779, 231608253, 1067319867, 73159811, + 429792535, 971320614, 565699344, 718823399, }, + + { 408185106, 491493570, 596050720, 310776444, + 703628192, 454438809, 523988035, 728512200, + 686012353, 976339656, 72816924, 116926720, + 165866591, 452043792, 866943072, 968545481, }, + + { 443231195, 905907843, 1061421320, 746360489, + 1043120338, 1069659155, 463359031, 688303227, + 186550710, 155347339, 1044842421, 1005904570, + 69332909, 706951903, 422513657, 882038450, }, + + { 430990623, 946501980, 742556791, 278398643, + 183759217, 659404315, 279754382, 1069347846, + 843746517, 222777670, 990835599, 548741637, + 129220580, 1392170, 1032654091, 894058935, }, + + { 452042227, 751640705, 259481376, 765824585, + 145991469, 1013683228, 1055491225, 536379588, + 392593350, 913368594, 1029429776, 226857786, + 31505342, 1054416381, 32341741, 687106649, }, + + { 404750944, 811417027, 869530820, 773491060, + 810901282, 979340397, 1036910290, 461764404, + 834235095, 765695033, 604692390, 452158120, + 928988098, 442719218, 1024059719, 167723114, }, + + { 974245177, 1046377300, 1003424287, 787349855, + 336314155, 875074696, 1018462718, 890313003, + 367376809, 86355556, 1020618772, 890710345, + 444741481, 373230261, 767064947, 840920177, }, + + { 719581124, 431808156, 138301690, 668222575, + 497413494, 740492013, 485033226, 125301442, + 831265111, 879071459, 341690480, 152975256, + 850330086, 717444507, 694225877, 785340566, }, + + { 1032766252, 140959364, 737474726, 1062767538, + 364464647, 331414723, 356152634, 642832379, + 158733632, 374691640, 285504811, 345349905, + 876599880, 476392727, 479589210, 606376325, }, + + { 174997730, 778177086, 319164313, 163614456, + 10331364, 599358958, 8331663, 237538058, + 159173957, 174533880, 65588684, 878222844, + 424467599, 901803515, 187504218, 776690353, }, + + { 803856182, 965850321, 694948067, 218315960, + 358416571, 683713254, 178069303, 428076035, + 686176454, 579553217, 357306738, 315018080, + 886852373, 568563910, 896839725, 257416821, }, + + { 401650013, 183289141, 497957228, 879734476, + 265024455, 825794561, 889237440, 323359863, + 100258491, 991414783, 313986632, 85847250, + 362520248, 276103512, 1041630342, 525981595, }, + + { 487732740, 46201705, 990837834, 62744493, + 1067364756, 58015363, 690846283, 680262648, + 997278956, 469357861, 432164624, 996763915, + 211907847, 167824295, 144928194, 454839915, }, + + { 41404232, 514493300, 259546924, 578217256, + 972345130, 123299213, 346040332, 1014668104, + 520910639, 579955198, 36627803, 179072921, + 547684341, 598950511, 269497394, 854352266, }, + + { 603906768, 100863318, 708837659, 204175569, + 375560904, 908375384, 28314106, 6303733, + 175283124, 749851198, 308667367, 415293931, + 225365403, 1032188331, 977112710, 819705229, }, + + { 399767123, 697985692, 356790426, 643687584, + 298624218, 185095167, 381653926, 876816342, + 296720023, 2205879, 235816616, 521850105, + 622753786, 1021421218, 726349744, 256504902, }, + + { 851245024, 1022500222, 511909628, 313809625, + 99776025, 39710175, 798739932, 741832408, + 140631966, 898295927, 607660421, 870669312, + 1051422478, 789055529, 669113756, 681943450, }, + + { 853872755, 491465269, 503341472, 98019440, + 258267420, 335602837, 320687824, 1053324395, + 24932389, 955011453, 934255131, 435625663, + 501568768, 238967025, 549987406, 248619780, }, + + { 411151284, 576471205, 757985419, 544137226, + 968135693, 877548443, 194586894, 74882373, + 248353663, 21207540, 273789651, 853653916, + 861267970, 533253322, 3739570, 661358586, }, + + { 271430986, 71390029, 257643671, 949329860, + 348156406, 251939238, 445808698, 48269799, + 907589462, 105677619, 635451508, 20805932, + 464874661, 7542147, 243619464, 288304568, }, + + { 368215982, 530288964, 770090421, 660961164, + 614935537, 630760399, 931299233, 794519275, + 779918979, 401746493, 561237006, 1027202224, + 258968003, 339508073, 1050610516, 1064307013, }, + + { 1039172162, 448331205, 928997884, 49813151, + 198712120, 992335354, 671024050, 879525220, + 745915336, 1038822580, 138669665, 917958819, + 681422342, 792868818, 924762727, 816386174, }, + + { 515190336, 313808618, 441296783, 1022120897, + 792325033, 354387581, 59273006, 280075434, + 411357221, 665274694, 4054464, 1059046246, + 394261773, 848616745, 15446017, 517723271, }, +}; H3BloomFilter::H3BloomFilter(string str) { - //TODO: change this ugly init code... - primes_list[0] = 9323; - primes_list[1] = 11279; - primes_list[2] = 10247; - primes_list[3] = 30637; - primes_list[4] = 25717; - primes_list[5] = 43711; - - mults_list[0] = 255; - mults_list[1] = 29; - mults_list[2] = 51; - mults_list[3] = 3; - mults_list[4] = 77; - mults_list[5] = 43; - - adds_list[0] = 841; - adds_list[1] = 627; - adds_list[2] = 1555; - adds_list[3] = 241; - adds_list[4] = 7777; - adds_list[5] = 65931; - - - - string tail(str); - string head = string_split(tail, '_'); - - // head contains filter size, tail contains bit offset from block number - m_filter_size = atoi(head.c_str()); - - head = string_split(tail, '_'); - m_num_hashes = atoi(head.c_str()); - - if(tail == "Regular") { - isParallel = false; - } else if (tail == "Parallel") { - isParallel = true; - } else { - cout << "ERROR: Incorrect config string for MultiHash Bloom! :" << str << endl; - assert(0); - } - - m_filter_size_bits = log_int(m_filter_size); - - m_par_filter_size = m_filter_size/m_num_hashes; - m_par_filter_size_bits = log_int(m_par_filter_size); - - m_filter.setSize(m_filter_size); - clear(); + //TODO: change this ugly init code... + primes_list[0] = 9323; + primes_list[1] = 11279; + primes_list[2] = 10247; + primes_list[3] = 30637; + primes_list[4] = 25717; + primes_list[5] = 43711; + + mults_list[0] = 255; + mults_list[1] = 29; + mults_list[2] = 51; + mults_list[3] = 3; + mults_list[4] = 77; + mults_list[5] = 43; + + adds_list[0] = 841; + adds_list[1] = 627; + adds_list[2] = 1555; + adds_list[3] = 241; + adds_list[4] = 7777; + adds_list[5] = 65931; + + string tail(str); + string head = string_split(tail, '_'); + + // head contains filter size, tail contains bit offset from block number + m_filter_size = atoi(head.c_str()); + + head = string_split(tail, '_'); + m_num_hashes = atoi(head.c_str()); + + if(tail == "Regular") { + isParallel = false; + } else if (tail == "Parallel") { + isParallel = true; + } else { + cout << "ERROR: Incorrect config string for MultiHash Bloom! :" + << str << endl; + assert(0); + } + + m_filter_size_bits = log_int(m_filter_size); + + m_par_filter_size = m_filter_size/m_num_hashes; + m_par_filter_size_bits = log_int(m_par_filter_size); + + m_filter.setSize(m_filter_size); + clear(); } -H3BloomFilter::~H3BloomFilter(){ +H3BloomFilter::~H3BloomFilter() +{ } -void H3BloomFilter::clear() +void +H3BloomFilter::clear() { - for (int i = 0; i < m_filter_size; i++) { - m_filter[i] = 0; - } + for (int i = 0; i < m_filter_size; i++) { + m_filter[i] = 0; + } } -void H3BloomFilter::increment(const Address& addr) +void +H3BloomFilter::increment(const Address& addr) { - // Not used + // Not used } - -void H3BloomFilter::decrement(const Address& addr) +void +H3BloomFilter::decrement(const Address& addr) { - // Not used + // Not used } -void H3BloomFilter::merge(AbstractBloomFilter * other_filter){ - // assumes both filters are the same size! - H3BloomFilter * temp = (H3BloomFilter*) other_filter; - for(int i=0; i < m_filter_size; ++i){ - m_filter[i] |= (*temp)[i]; - } - +void +H3BloomFilter::merge(AbstractBloomFilter *other_filter) +{ + // assumes both filters are the same size! + H3BloomFilter * temp = (H3BloomFilter*) other_filter; + for(int i = 0; i < m_filter_size; ++i){ + m_filter[i] |= (*temp)[i]; + } } -void H3BloomFilter::set(const Address& addr) +void +H3BloomFilter::set(const Address& addr) { - for (int i = 0; i < m_num_hashes; i++) { - int idx = get_index(addr, i); - m_filter[idx] = 1; - - //Profile hash value distribution - //g_system_ptr->getProfiler()->getXactProfiler()->profileHashValue(i, idx); // gem5:Arka decomissiong of log_tm - } + for (int i = 0; i < m_num_hashes; i++) { + int idx = get_index(addr, i); + m_filter[idx] = 1; + } } -void H3BloomFilter::unset(const Address& addr) +void +H3BloomFilter::unset(const Address& addr) { - cout << "ERROR: Unset should never be called in a Bloom filter"; - assert(0); + cout << "ERROR: Unset should never be called in a Bloom filter"; + assert(0); } -bool H3BloomFilter::isSet(const Address& addr) +bool +H3BloomFilter::isSet(const Address& addr) { - bool res = true; + bool res = true; - for (int i=0; i < m_num_hashes; i++) { - int idx = get_index(addr, i); - res = res && m_filter[idx]; - } - return res; + for (int i = 0; i < m_num_hashes; i++) { + int idx = get_index(addr, i); + res = res && m_filter[idx]; + } + return res; } - -int H3BloomFilter::getCount(const Address& addr) +int +H3BloomFilter::getCount(const Address& addr) { - return isSet(addr)? 1: 0; + return isSet(addr)? 1: 0; } -int H3BloomFilter::getIndex(const Address& addr) +int +H3BloomFilter::getIndex(const Address& addr) { - return 0; + return 0; } -int H3BloomFilter::readBit(const int index) { - return 0; +int +H3BloomFilter::readBit(const int index) +{ + return 0; } -void H3BloomFilter::writeBit(const int index, const int value) { - +void +H3BloomFilter::writeBit(const int index, const int value) +{ } -int H3BloomFilter::getTotalCount() +int +H3BloomFilter::getTotalCount() { - int count = 0; + int count = 0; - for (int i = 0; i < m_filter_size; i++) { - count += m_filter[i]; - } - return count; + for (int i = 0; i < m_filter_size; i++) { + count += m_filter[i]; + } + return count; } -void H3BloomFilter::print(ostream& out) const +void +H3BloomFilter::print(ostream& out) const { } -int H3BloomFilter::get_index(const Address& addr, int i) +int +H3BloomFilter::get_index(const Address& addr, int i) { - uint64 x = addr.getLineAddress(); - //uint64 y = (x*mults_list[i] + adds_list[i]) % primes_list[i]; - int y = hash_H3(x,i); - - if(isParallel) { - return (y % m_par_filter_size) + i*m_par_filter_size; - } else { - return y % m_filter_size; - } + uint64 x = addr.getLineAddress(); + // uint64 y = (x*mults_list[i] + adds_list[i]) % primes_list[i]; + int y = hash_H3(x,i); + + if (isParallel) { + return (y % m_par_filter_size) + i*m_par_filter_size; + } else { + return y % m_filter_size; + } } -int H3BloomFilter::hash_H3(uint64 value, int index) { - uint64 mask = 1; - uint64 val = value; - int result = 0; - - for(int i = 0; i < 64; i++) { - if(val&mask) result ^= H3[i][index]; - val = val >> 1; - } - return result; - } +int +H3BloomFilter::hash_H3(uint64 value, int index) +{ + uint64 mask = 1; + uint64 val = value; + int result = 0; + + for (int i = 0; i < 64; i++) { + if(val&mask) result ^= H3[i][index]; + val = val >> 1; + } + return result; +} diff --git a/src/mem/ruby/filters/H3BloomFilter.hh b/src/mem/ruby/filters/H3BloomFilter.hh index 360000540..6c18508eb 100644 --- a/src/mem/ruby/filters/H3BloomFilter.hh +++ b/src/mem/ruby/filters/H3BloomFilter.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,76 +26,65 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * H3BloomFilter.hh - * - * Description: - * - * - */ - -#ifndef H3_BLOOM_FILTER_H -#define H3_BLOOM_FILTER_H +#ifndef __MEM_RUBY_FILTERS_H3BLOOMFILTER_HH__ +#define __MEM_RUBY_FILTERS_H3BLOOMFILTER_HH__ #include "mem/gems_common/Map.hh" -#include "mem/ruby/common/Global.hh" -#include "mem/ruby/system/System.hh" -#include "mem/ruby/profiler/Profiler.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/filters/AbstractBloomFilter.hh" +#include "mem/ruby/profiler/Profiler.hh" +#include "mem/ruby/system/System.hh" -class H3BloomFilter : public AbstractBloomFilter { -public: - - ~H3BloomFilter(); - H3BloomFilter(string config); - - void clear(); - void increment(const Address& addr); - void decrement(const Address& addr); - void merge(AbstractBloomFilter * other_filter); - void set(const Address& addr); - void unset(const Address& addr); - - bool isSet(const Address& addr); - int getCount(const Address& addr); - int getTotalCount(); - void print(ostream& out) const; - - int getIndex(const Address& addr); - int readBit(const int index); - void writeBit(const int index, const int value); - - int operator[](const int index) const{ - return this->m_filter[index]; - } +class H3BloomFilter : public AbstractBloomFilter +{ + public: + H3BloomFilter(string config); + ~H3BloomFilter(); -private: + void clear(); + void increment(const Address& addr); + void decrement(const Address& addr); + void merge(AbstractBloomFilter * other_filter); + void set(const Address& addr); + void unset(const Address& addr); - int get_index(const Address& addr, int hashNumber); + bool isSet(const Address& addr); + int getCount(const Address& addr); + int getTotalCount(); + void print(ostream& out) const; - int hash_H3(uint64 value, int index); + int getIndex(const Address& addr); + int readBit(const int index); + void writeBit(const int index, const int value); - Vector<int> m_filter; - int m_filter_size; - int m_num_hashes; - int m_filter_size_bits; + int + operator[](const int index) const + { + return this->m_filter[index]; + } - int m_par_filter_size; - int m_par_filter_size_bits; + private: + int get_index(const Address& addr, int hashNumber); - int m_count_bits; - int m_count; + int hash_H3(uint64 value, int index); + Vector<int> m_filter; + int m_filter_size; + int m_num_hashes; + int m_filter_size_bits; + int m_par_filter_size; + int m_par_filter_size_bits; - int primes_list[6];// = {9323,11279,10247,30637,25717,43711}; - int mults_list[6]; //= {255,29,51,3,77,43}; - int adds_list[6]; //= {841,627,1555,241,7777,65391}; + int m_count_bits; + int m_count; - bool isParallel; + int primes_list[6];// = {9323,11279,10247,30637,25717,43711}; + int mults_list[6]; //= {255,29,51,3,77,43}; + int adds_list[6]; //= {841,627,1555,241,7777,65391}; + bool isParallel; }; - -#endif +#endif // __MEM_RUBY_FILTERS_H3BLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/LSB_CountingBloomFilter.cc b/src/mem/ruby/filters/LSB_CountingBloomFilter.cc index a79201ad4..b64c3e75a 100644 --- a/src/mem/ruby/filters/LSB_CountingBloomFilter.cc +++ b/src/mem/ruby/filters/LSB_CountingBloomFilter.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,116 +26,126 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * LSB_CountingBloomFilter.cc - * - * Description: - * - * - */ - -#include "mem/ruby/filters/LSB_CountingBloomFilter.hh" #include "mem/gems_common/Map.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/filters/LSB_CountingBloomFilter.hh" LSB_CountingBloomFilter::LSB_CountingBloomFilter(string str) { - string tail(str); - string head = string_split(tail, ':'); + string tail(str); + string head = string_split(tail, ':'); - m_filter_size = atoi(head.c_str()); - m_filter_size_bits = log_int(m_filter_size); + m_filter_size = atoi(head.c_str()); + m_filter_size_bits = log_int(m_filter_size); - m_count = atoi(tail.c_str()); - m_count_bits = log_int(m_count); + m_count = atoi(tail.c_str()); + m_count_bits = log_int(m_count); - m_filter.setSize(m_filter_size); - clear(); + m_filter.setSize(m_filter_size); + clear(); } -LSB_CountingBloomFilter::~LSB_CountingBloomFilter(){ +LSB_CountingBloomFilter::~LSB_CountingBloomFilter() +{ } -void LSB_CountingBloomFilter::clear() +void +LSB_CountingBloomFilter::clear() { - for (int i = 0; i < m_filter_size; i++) { - m_filter[i] = 0; - } + for (int i = 0; i < m_filter_size; i++) { + m_filter[i] = 0; + } } -void LSB_CountingBloomFilter::increment(const Address& addr) +void +LSB_CountingBloomFilter::increment(const Address& addr) { - int i = get_index(addr); - if (m_filter[i] < m_count); - m_filter[i] += 1; + int i = get_index(addr); + if (m_filter[i] < m_count) + m_filter[i] += 1; } -void LSB_CountingBloomFilter::decrement(const Address& addr) +void +LSB_CountingBloomFilter::decrement(const Address& addr) { - int i = get_index(addr); - if (m_filter[i] > 0) - m_filter[i] -= 1; + int i = get_index(addr); + if (m_filter[i] > 0) + m_filter[i] -= 1; } -void LSB_CountingBloomFilter::merge(AbstractBloomFilter * other_filter) +void +LSB_CountingBloomFilter::merge(AbstractBloomFilter * other_filter) { - // TODO + // TODO } -void LSB_CountingBloomFilter::set(const Address& addr) +void +LSB_CountingBloomFilter::set(const Address& addr) { - // TODO + // TODO } -void LSB_CountingBloomFilter::unset(const Address& addr) +void +LSB_CountingBloomFilter::unset(const Address& addr) { - // TODO + // TODO } -bool LSB_CountingBloomFilter::isSet(const Address& addr) +bool +LSB_CountingBloomFilter::isSet(const Address& addr) { - // TODO - return false; + // TODO + return false; } - -int LSB_CountingBloomFilter::getCount(const Address& addr) +int +LSB_CountingBloomFilter::getCount(const Address& addr) { - return m_filter[get_index(addr)]; + return m_filter[get_index(addr)]; } -int LSB_CountingBloomFilter::getTotalCount() +int +LSB_CountingBloomFilter::getTotalCount() { - int count = 0; + int count = 0; - for (int i = 0; i < m_filter_size; i++) { - count += m_filter[i]; - } - return count; + for (int i = 0; i < m_filter_size; i++) { + count += m_filter[i]; + } + return count; } -int LSB_CountingBloomFilter::getIndex(const Address& addr) +int +LSB_CountingBloomFilter::getIndex(const Address& addr) { - return get_index(addr); + return get_index(addr); } -void LSB_CountingBloomFilter::print(ostream& out) const +void +LSB_CountingBloomFilter::print(ostream& out) const { } -int LSB_CountingBloomFilter::readBit(const int index) { - return 0; - // TODO +int +LSB_CountingBloomFilter::readBit(const int index) +{ + return 0; + // TODO } -void LSB_CountingBloomFilter::writeBit(const int index, const int value) { - // TODO +void +LSB_CountingBloomFilter::writeBit(const int index, const int value) +{ + // TODO } -int LSB_CountingBloomFilter::get_index(const Address& addr) +int +LSB_CountingBloomFilter::get_index(const Address& addr) { - return addr.bitSelect( RubySystem::getBlockSizeBits(), RubySystem::getBlockSizeBits() + m_filter_size_bits - 1); + return addr.bitSelect(RubySystem::getBlockSizeBits(), + RubySystem::getBlockSizeBits() + + m_filter_size_bits - 1); } diff --git a/src/mem/ruby/filters/LSB_CountingBloomFilter.hh b/src/mem/ruby/filters/LSB_CountingBloomFilter.hh index bfa2673fe..0d74c524a 100644 --- a/src/mem/ruby/filters/LSB_CountingBloomFilter.hh +++ b/src/mem/ruby/filters/LSB_CountingBloomFilter.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,55 +26,45 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * LSB_CountingBloomFilter.hh - * - * Description: - * - * - */ - -#ifndef LSB_COUNTING_BLOOM_FILTER_H -#define LSB_COUNTING_BLOOM_FILTER_H +#ifndef __MEM_RUBY_FILTERS_LSBCOUNTINGBLOOMFILTER_HH__ +#define __MEM_RUBY_FILTERS_LSBCOUNTINGBLOOMFILTER_HH__ #include "mem/gems_common/Map.hh" -#include "mem/ruby/common/Global.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/filters/AbstractBloomFilter.hh" -class LSB_CountingBloomFilter : public AbstractBloomFilter { -public: +class LSB_CountingBloomFilter : public AbstractBloomFilter +{ + public: + LSB_CountingBloomFilter(string config); + ~LSB_CountingBloomFilter(); - ~LSB_CountingBloomFilter(); - LSB_CountingBloomFilter(string config); + void clear(); + void increment(const Address& addr); + void decrement(const Address& addr); + void merge(AbstractBloomFilter * other_filter); + void set(const Address& addr); + void unset(const Address& addr); - void clear(); - void increment(const Address& addr); - void decrement(const Address& addr); - void merge(AbstractBloomFilter * other_filter); - void set(const Address& addr); - void unset(const Address& addr); + bool isSet(const Address& addr); + int getCount(const Address& addr); + int getTotalCount(); + int getIndex(const Address& addr); + int readBit(const int index); + void writeBit(const int index, const int value); - bool isSet(const Address& addr); - int getCount(const Address& addr); - int getTotalCount(); - int getIndex(const Address& addr); - int readBit(const int index); - void writeBit(const int index, const int value); + void print(ostream& out) const; - void print(ostream& out) const; + private: + int get_index(const Address& addr); -private: + Vector<int> m_filter; + int m_filter_size; + int m_filter_size_bits; - int get_index(const Address& addr); - - Vector<int> m_filter; - int m_filter_size; - int m_filter_size_bits; - - int m_count_bits; - int m_count; + int m_count_bits; + int m_count; }; - -#endif +#endif // __MEM_RUBY_FILTERS_LSBCOUNTINGBLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/MultiBitSelBloomFilter.cc b/src/mem/ruby/filters/MultiBitSelBloomFilter.cc index 844f80160..1fe316800 100644 --- a/src/mem/ruby/filters/MultiBitSelBloomFilter.cc +++ b/src/mem/ruby/filters/MultiBitSelBloomFilter.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,165 +26,173 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * NonCountingBloomFilter.cc - * - * Description: - * - * - */ - -#include "mem/ruby/filters/MultiBitSelBloomFilter.hh" #include "mem/gems_common/Map.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/filters/MultiBitSelBloomFilter.hh" MultiBitSelBloomFilter::MultiBitSelBloomFilter(string str) { + string tail(str); + string head = string_split(tail, '_'); - string tail(str); - string head = string_split(tail, '_'); - - // head contains filter size, tail contains bit offset from block number - m_filter_size = atoi(head.c_str()); + // head contains filter size, tail contains bit offset from block number + m_filter_size = atoi(head.c_str()); - head = string_split(tail, '_'); - m_num_hashes = atoi(head.c_str()); + head = string_split(tail, '_'); + m_num_hashes = atoi(head.c_str()); - head = string_split(tail, '_'); - m_skip_bits = atoi(head.c_str()); + head = string_split(tail, '_'); + m_skip_bits = atoi(head.c_str()); - if(tail == "Regular") { - isParallel = false; - } else if (tail == "Parallel") { - isParallel = true; - } else { - cout << "ERROR: Incorrect config string for MultiBitSel Bloom! :" << str << endl; - assert(0); - } + if(tail == "Regular") { + isParallel = false; + } else if (tail == "Parallel") { + isParallel = true; + } else { + cout << "ERROR: Incorrect config string for MultiBitSel Bloom! :" + << str << endl; + assert(0); + } - m_filter_size_bits = log_int(m_filter_size); + m_filter_size_bits = log_int(m_filter_size); - m_par_filter_size = m_filter_size/m_num_hashes; - m_par_filter_size_bits = log_int(m_par_filter_size); + m_par_filter_size = m_filter_size/m_num_hashes; + m_par_filter_size_bits = log_int(m_par_filter_size); - m_filter.setSize(m_filter_size); - clear(); + m_filter.setSize(m_filter_size); + clear(); } -MultiBitSelBloomFilter::~MultiBitSelBloomFilter(){ +MultiBitSelBloomFilter::~MultiBitSelBloomFilter() +{ } -void MultiBitSelBloomFilter::clear() +void +MultiBitSelBloomFilter::clear() { - for (int i = 0; i < m_filter_size; i++) { - m_filter[i] = 0; - } + for (int i = 0; i < m_filter_size; i++) { + m_filter[i] = 0; + } } -void MultiBitSelBloomFilter::increment(const Address& addr) +void +MultiBitSelBloomFilter::increment(const Address& addr) { - // Not used + // Not used } -void MultiBitSelBloomFilter::decrement(const Address& addr) +void +MultiBitSelBloomFilter::decrement(const Address& addr) { - // Not used + // Not used } -void MultiBitSelBloomFilter::merge(AbstractBloomFilter * other_filter){ - // assumes both filters are the same size! - MultiBitSelBloomFilter * temp = (MultiBitSelBloomFilter*) other_filter; - for(int i=0; i < m_filter_size; ++i){ - m_filter[i] |= (*temp)[i]; - } - +void +MultiBitSelBloomFilter::merge(AbstractBloomFilter *other_filter) +{ + // assumes both filters are the same size! + MultiBitSelBloomFilter * temp = (MultiBitSelBloomFilter*) other_filter; + for(int i = 0; i < m_filter_size; ++i){ + m_filter[i] |= (*temp)[i]; + } } -void MultiBitSelBloomFilter::set(const Address& addr) +void +MultiBitSelBloomFilter::set(const Address& addr) { - for (int i = 0; i < m_num_hashes; i++) { - int idx = get_index(addr, i); - m_filter[idx] = 1; - - //Profile hash value distribution - //g_system_ptr->getProfiler()->getXactProfiler()->profileHashValue(i, idx); //gem5:Arka for decomissioning of log_tm - } + for (int i = 0; i < m_num_hashes; i++) { + int idx = get_index(addr, i); + m_filter[idx] = 1; + } } -void MultiBitSelBloomFilter::unset(const Address& addr) +void +MultiBitSelBloomFilter::unset(const Address& addr) { - cout << "ERROR: Unset should never be called in a Bloom filter"; - assert(0); + cout << "ERROR: Unset should never be called in a Bloom filter"; + assert(0); } -bool MultiBitSelBloomFilter::isSet(const Address& addr) +bool +MultiBitSelBloomFilter::isSet(const Address& addr) { - bool res = true; + bool res = true; - for (int i=0; i < m_num_hashes; i++) { - int idx = get_index(addr, i); - res = res && m_filter[idx]; - } - return res; + for (int i=0; i < m_num_hashes; i++) { + int idx = get_index(addr, i); + res = res && m_filter[idx]; + } + return res; } - -int MultiBitSelBloomFilter::getCount(const Address& addr) +int +MultiBitSelBloomFilter::getCount(const Address& addr) { - return isSet(addr)? 1: 0; + return isSet(addr)? 1: 0; } -int MultiBitSelBloomFilter::getIndex(const Address& addr) +int +MultiBitSelBloomFilter::getIndex(const Address& addr) { - return 0; + return 0; } -int MultiBitSelBloomFilter::readBit(const int index) { - return 0; +int +MultiBitSelBloomFilter::readBit(const int index) +{ + return 0; } -void MultiBitSelBloomFilter::writeBit(const int index, const int value) { - +void +MultiBitSelBloomFilter::writeBit(const int index, const int value) +{ } -int MultiBitSelBloomFilter::getTotalCount() +int +MultiBitSelBloomFilter::getTotalCount() { - int count = 0; + int count = 0; - for (int i = 0; i < m_filter_size; i++) { - count += m_filter[i]; - } - return count; + for (int i = 0; i < m_filter_size; i++) { + count += m_filter[i]; + } + return count; } -void MultiBitSelBloomFilter::print(ostream& out) const +void +MultiBitSelBloomFilter::print(ostream& out) const { } -int MultiBitSelBloomFilter::get_index(const Address& addr, int i) +int +MultiBitSelBloomFilter::get_index(const Address& addr, int i) { - // m_skip_bits is used to perform BitSelect after skipping some bits. Used to simulate BitSel hashing on larger than cache-line granularities - uint64 x = (addr.getLineAddress()) >> m_skip_bits; - int y = hash_bitsel(x, i, m_num_hashes, 30, m_filter_size_bits); - //36-bit addresses, 6-bit cache lines - - if(isParallel) { - return (y % m_par_filter_size) + i*m_par_filter_size; - } else { - return y % m_filter_size; - } -} - - -int MultiBitSelBloomFilter::hash_bitsel(uint64 value, int index, int jump, int maxBits, int numBits) { - uint64 mask = 1; - int result = 0; - int bit, i; - - for(i = 0; i < numBits; i++) { - bit = (index + jump*i) % maxBits; - if (value & (mask << bit)) result += mask << i; - } - return result; + // m_skip_bits is used to perform BitSelect after skipping some + // bits. Used to simulate BitSel hashing on larger than cache-line + // granularities + uint64 x = (addr.getLineAddress()) >> m_skip_bits; + int y = hash_bitsel(x, i, m_num_hashes, 30, m_filter_size_bits); + //36-bit addresses, 6-bit cache lines + + if (isParallel) { + return (y % m_par_filter_size) + i*m_par_filter_size; + } else { + return y % m_filter_size; + } +} + +int +MultiBitSelBloomFilter::hash_bitsel(uint64 value, int index, int jump, + int maxBits, int numBits) +{ + uint64 mask = 1; + int result = 0; + int bit, i; + + for (i = 0; i < numBits; i++) { + bit = (index + jump*i) % maxBits; + if (value & (mask << bit)) result += mask << i; + } + return result; } diff --git a/src/mem/ruby/filters/MultiBitSelBloomFilter.hh b/src/mem/ruby/filters/MultiBitSelBloomFilter.hh index 360cbfdff..c3b441c20 100644 --- a/src/mem/ruby/filters/MultiBitSelBloomFilter.hh +++ b/src/mem/ruby/filters/MultiBitSelBloomFilter.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,70 +26,63 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * MultiBitSelBloomFilter.hh - * - * Description: - * - * - */ - -#ifndef MULTIBITSEL_BLOOM_FILTER_H -#define MULTIBITSEL_BLOOM_FILTER_H +#ifndef __MEM_RUBY_FILTERS_MULTIBITSELBLOOMFILTER_HH__ +#define __MEM_RUBY_FILTERS_MULTIBITSELBLOOMFILTER_HH__ #include "mem/gems_common/Map.hh" -#include "mem/ruby/common/Global.hh" -#include "mem/ruby/system/System.hh" -#include "mem/ruby/profiler/Profiler.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/filters/AbstractBloomFilter.hh" +#include "mem/ruby/profiler/Profiler.hh" +#include "mem/ruby/system/System.hh" -class MultiBitSelBloomFilter : public AbstractBloomFilter { -public: - - ~MultiBitSelBloomFilter(); - MultiBitSelBloomFilter(string config); - - void clear(); - void increment(const Address& addr); - void decrement(const Address& addr); - void merge(AbstractBloomFilter * other_filter); - void set(const Address& addr); - void unset(const Address& addr); - - bool isSet(const Address& addr); - int getCount(const Address& addr); - int getTotalCount(); - void print(ostream& out) const; - - int getIndex(const Address& addr); - int readBit(const int index); - void writeBit(const int index, const int value); - - int operator[](const int index) const{ - return this->m_filter[index]; - } - -private: - - int get_index(const Address& addr, int hashNumber); - - int hash_bitsel(uint64 value, int index, int jump, int maxBits, int numBits); - - Vector<int> m_filter; - int m_filter_size; - int m_num_hashes; - int m_filter_size_bits; - int m_skip_bits; - - int m_par_filter_size; - int m_par_filter_size_bits; - - int m_count_bits; - int m_count; - - bool isParallel; - +class MultiBitSelBloomFilter : public AbstractBloomFilter +{ + public: + MultiBitSelBloomFilter(string config); + ~MultiBitSelBloomFilter(); + + void clear(); + void increment(const Address& addr); + void decrement(const Address& addr); + void merge(AbstractBloomFilter * other_filter); + void set(const Address& addr); + void unset(const Address& addr); + + bool isSet(const Address& addr); + int getCount(const Address& addr); + int getTotalCount(); + void print(ostream& out) const; + + int getIndex(const Address& addr); + int readBit(const int index); + void writeBit(const int index, const int value); + + int + operator[](const int index) const + { + return this->m_filter[index]; + } + + private: + int get_index(const Address& addr, int hashNumber); + + int hash_bitsel(uint64 value, int index, int jump, int maxBits, + int numBits); + + Vector<int> m_filter; + int m_filter_size; + int m_num_hashes; + int m_filter_size_bits; + int m_skip_bits; + + int m_par_filter_size; + int m_par_filter_size_bits; + + int m_count_bits; + int m_count; + + bool isParallel; }; -#endif +#endif // __MEM_RUBY_FILTERS_MULTIBITSELBLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/MultiGrainBloomFilter.cc b/src/mem/ruby/filters/MultiGrainBloomFilter.cc index 108168db3..543c4312a 100644 --- a/src/mem/ruby/filters/MultiGrainBloomFilter.cc +++ b/src/mem/ruby/filters/MultiGrainBloomFilter.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,142 +26,156 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * MultiGrainBloomFilter.cc - * - * Description: - * - * - */ - -#include "mem/ruby/filters/MultiGrainBloomFilter.hh" #include "mem/gems_common/Map.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/filters/MultiGrainBloomFilter.hh" MultiGrainBloomFilter::MultiGrainBloomFilter(string str) { - string tail(str); + string tail(str); - // split into the 2 filter sizes - string head = string_split(tail, '_'); + // split into the 2 filter sizes + string head = string_split(tail, '_'); - // head contains size of 1st bloom filter, tail contains size of 2nd bloom filter + // head contains size of 1st bloom filter, tail contains size of + // 2nd bloom filter - m_filter_size = atoi(head.c_str()); - m_filter_size_bits = log_int(m_filter_size); + m_filter_size = atoi(head.c_str()); + m_filter_size_bits = log_int(m_filter_size); - m_page_filter_size = atoi(tail.c_str()); - m_page_filter_size_bits = log_int(m_page_filter_size); + m_page_filter_size = atoi(tail.c_str()); + m_page_filter_size_bits = log_int(m_page_filter_size); - m_filter.setSize(m_filter_size); - m_page_filter.setSize(m_page_filter_size); - clear(); + m_filter.setSize(m_filter_size); + m_page_filter.setSize(m_page_filter_size); + clear(); } -MultiGrainBloomFilter::~MultiGrainBloomFilter(){ +MultiGrainBloomFilter::~MultiGrainBloomFilter() +{ } -void MultiGrainBloomFilter::clear() +void +MultiGrainBloomFilter::clear() { - for (int i = 0; i < m_filter_size; i++) { - m_filter[i] = 0; - } - for(int i=0; i < m_page_filter_size; ++i){ - m_page_filter[i] = 0; - } + for (int i = 0; i < m_filter_size; i++) { + m_filter[i] = 0; + } + for(int i=0; i < m_page_filter_size; ++i){ + m_page_filter[i] = 0; + } } -void MultiGrainBloomFilter::increment(const Address& addr) +void +MultiGrainBloomFilter::increment(const Address& addr) { - // Not used + // Not used } -void MultiGrainBloomFilter::decrement(const Address& addr) +void +MultiGrainBloomFilter::decrement(const Address& addr) { - // Not used + // Not used } -void MultiGrainBloomFilter::merge(AbstractBloomFilter * other_filter) +void +MultiGrainBloomFilter::merge(AbstractBloomFilter *other_filter) { - // TODO + // TODO } -void MultiGrainBloomFilter::set(const Address& addr) +void +MultiGrainBloomFilter::set(const Address& addr) { - int i = get_block_index(addr); - assert(i < m_filter_size); - assert(get_page_index(addr) < m_page_filter_size); - m_filter[i] = 1; - m_page_filter[i] = 1; + int i = get_block_index(addr); + assert(i < m_filter_size); + assert(get_page_index(addr) < m_page_filter_size); + m_filter[i] = 1; + m_page_filter[i] = 1; } -void MultiGrainBloomFilter::unset(const Address& addr) +void +MultiGrainBloomFilter::unset(const Address& addr) { - // not used + // not used } -bool MultiGrainBloomFilter::isSet(const Address& addr) +bool +MultiGrainBloomFilter::isSet(const Address& addr) { - int i = get_block_index(addr); - assert(i < m_filter_size); - assert(get_page_index(addr) < m_page_filter_size); - // we have to have both indices set - return (m_filter[i] && m_page_filter[i]); + int i = get_block_index(addr); + assert(i < m_filter_size); + assert(get_page_index(addr) < m_page_filter_size); + // we have to have both indices set + return (m_filter[i] && m_page_filter[i]); } -int MultiGrainBloomFilter::getCount(const Address& addr) +int +MultiGrainBloomFilter::getCount(const Address& addr) { - // not used - return 0; + // not used + return 0; } -int MultiGrainBloomFilter::getTotalCount() +int +MultiGrainBloomFilter::getTotalCount() { - int count = 0; + int count = 0; - for (int i = 0; i < m_filter_size; i++) { - count += m_filter[i]; - } + for (int i = 0; i < m_filter_size; i++) { + count += m_filter[i]; + } - for(int i=0; i < m_page_filter_size; ++i){ - count += m_page_filter[i] = 0; - } + for(int i=0; i < m_page_filter_size; ++i) { + count += m_page_filter[i] = 0; + } - return count; + return count; } -int MultiGrainBloomFilter::getIndex(const Address& addr) +int +MultiGrainBloomFilter::getIndex(const Address& addr) { - return 0; - // TODO + return 0; + // TODO } -int MultiGrainBloomFilter::readBit(const int index) { - return 0; - // TODO +int +MultiGrainBloomFilter::readBit(const int index) +{ + return 0; + // TODO } -void MultiGrainBloomFilter::writeBit(const int index, const int value) { - // TODO +void +MultiGrainBloomFilter::writeBit(const int index, const int value) +{ + // TODO } -void MultiGrainBloomFilter::print(ostream& out) const +void +MultiGrainBloomFilter::print(ostream& out) const { } -int MultiGrainBloomFilter::get_block_index(const Address& addr) +int +MultiGrainBloomFilter::get_block_index(const Address& addr) { - // grap a chunk of bits after byte offset - return addr.bitSelect( RubySystem::getBlockSizeBits(), RubySystem::getBlockSizeBits() + m_filter_size_bits - 1); + // grap a chunk of bits after byte offset + return addr.bitSelect(RubySystem::getBlockSizeBits(), + RubySystem::getBlockSizeBits() + + m_filter_size_bits - 1); } -int MultiGrainBloomFilter::get_page_index(const Address & addr) +int +MultiGrainBloomFilter::get_page_index(const Address & addr) { - // grap a chunk of bits after first chunk - return addr.bitSelect( RubySystem::getBlockSizeBits() + m_filter_size_bits - 1, - RubySystem::getBlockSizeBits() + m_filter_size_bits - 1 + m_page_filter_size_bits - 1); + int bits = RubySystem::getBlockSizeBits() + m_filter_size_bits - 1; + + // grap a chunk of bits after first chunk + return addr.bitSelect(bits, bits + m_page_filter_size_bits - 1); } diff --git a/src/mem/ruby/filters/MultiGrainBloomFilter.hh b/src/mem/ruby/filters/MultiGrainBloomFilter.hh index 4e9bc70a2..4681e2806 100644 --- a/src/mem/ruby/filters/MultiGrainBloomFilter.hh +++ b/src/mem/ruby/filters/MultiGrainBloomFilter.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,61 +26,51 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * MultiGrainBloomFilter.hh - * - * Description: - * - * - */ - -#ifndef MULTIGRAIN_BLOOM_FILTER_H -#define MULTIGRAIN_BLOOM_FILTER_H +#ifndef __MEM_RUBY_FILTERS_MULTIGRAINBLOOMFILTER_HH__ +#define __MEM_RUBY_FILTERS_MULTIGRAINBLOOMFILTER_HH__ #include "mem/gems_common/Map.hh" -#include "mem/ruby/common/Global.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/filters/AbstractBloomFilter.hh" -class MultiGrainBloomFilter : public AbstractBloomFilter { -public: +class MultiGrainBloomFilter : public AbstractBloomFilter +{ + public: + MultiGrainBloomFilter(string str); + ~MultiGrainBloomFilter(); - ~MultiGrainBloomFilter(); - MultiGrainBloomFilter(string str); + void clear(); + void increment(const Address& addr); + void decrement(const Address& addr); + void merge(AbstractBloomFilter * other_filter); + void set(const Address& addr); + void unset(const Address& addr); - void clear(); - void increment(const Address& addr); - void decrement(const Address& addr); - void merge(AbstractBloomFilter * other_filter); - void set(const Address& addr); - void unset(const Address& addr); + bool isSet(const Address& addr); + int getCount(const Address& addr); + int getTotalCount(); + int getIndex(const Address& addr); + int readBit(const int index); + void writeBit(const int index, const int value); - bool isSet(const Address& addr); - int getCount(const Address& addr); - int getTotalCount(); - int getIndex(const Address& addr); - int readBit(const int index); - void writeBit(const int index, const int value); + void print(ostream& out) const; - void print(ostream& out) const; + private: + int get_block_index(const Address& addr); + int get_page_index(const Address & addr); -private: + // The block filter + Vector<int> m_filter; + int m_filter_size; + int m_filter_size_bits; + // The page number filter + Vector<int> m_page_filter; + int m_page_filter_size; + int m_page_filter_size_bits; - int get_block_index(const Address& addr); - int get_page_index(const Address & addr); - - // The block filter - Vector<int> m_filter; - int m_filter_size; - int m_filter_size_bits; - // The page number filter - Vector<int> m_page_filter; - int m_page_filter_size; - int m_page_filter_size_bits; - - int m_count_bits; - int m_count; + int m_count_bits; + int m_count; }; - -#endif +#endif // __MEM_RUBY_FILTERS_MULTIGRAINBLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/NonCountingBloomFilter.cc b/src/mem/ruby/filters/NonCountingBloomFilter.cc index 738945105..06c069c7e 100644 --- a/src/mem/ruby/filters/NonCountingBloomFilter.cc +++ b/src/mem/ruby/filters/NonCountingBloomFilter.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,118 +26,126 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * NonCountingBloomFilter.cc - * - * Description: - * - * - */ - -#include "mem/ruby/filters/NonCountingBloomFilter.hh" #include "mem/gems_common/Map.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/filters/NonCountingBloomFilter.hh" NonCountingBloomFilter::NonCountingBloomFilter(string str) { - string tail(str); - string head = string_split(tail, '_'); + string tail(str); + string head = string_split(tail, '_'); - // head contains filter size, tail contains bit offset from block number - m_filter_size = atoi(head.c_str()); - m_offset = atoi(tail.c_str()); - m_filter_size_bits = log_int(m_filter_size); + // head contains filter size, tail contains bit offset from block number + m_filter_size = atoi(head.c_str()); + m_offset = atoi(tail.c_str()); + m_filter_size_bits = log_int(m_filter_size); - - m_filter.setSize(m_filter_size); - clear(); + m_filter.setSize(m_filter_size); + clear(); } -NonCountingBloomFilter::~NonCountingBloomFilter(){ +NonCountingBloomFilter::~NonCountingBloomFilter() +{ } -void NonCountingBloomFilter::clear() +void +NonCountingBloomFilter::clear() { - for (int i = 0; i < m_filter_size; i++) { - m_filter[i] = 0; - } + for (int i = 0; i < m_filter_size; i++) { + m_filter[i] = 0; + } } -void NonCountingBloomFilter::increment(const Address& addr) +void +NonCountingBloomFilter::increment(const Address& addr) { - // Not used + // Not used } - -void NonCountingBloomFilter::decrement(const Address& addr) +void +NonCountingBloomFilter::decrement(const Address& addr) { - // Not used + // Not used } -void NonCountingBloomFilter::merge(AbstractBloomFilter * other_filter){ - // assumes both filters are the same size! - NonCountingBloomFilter * temp = (NonCountingBloomFilter*) other_filter; - for(int i=0; i < m_filter_size; ++i){ - m_filter[i] |= (*temp)[i]; - } - +void +NonCountingBloomFilter::merge(AbstractBloomFilter *other_filter) +{ + // assumes both filters are the same size! + NonCountingBloomFilter * temp = (NonCountingBloomFilter*) other_filter; + for(int i = 0; i < m_filter_size; ++i){ + m_filter[i] |= (*temp)[i]; + } } -void NonCountingBloomFilter::set(const Address& addr) +void +NonCountingBloomFilter::set(const Address& addr) { - int i = get_index(addr); - m_filter[i] = 1; + int i = get_index(addr); + m_filter[i] = 1; } -void NonCountingBloomFilter::unset(const Address& addr) +void +NonCountingBloomFilter::unset(const Address& addr) { - int i = get_index(addr); - m_filter[i] = 0; + int i = get_index(addr); + m_filter[i] = 0; } -bool NonCountingBloomFilter::isSet(const Address& addr) +bool +NonCountingBloomFilter::isSet(const Address& addr) { - int i = get_index(addr); - return (m_filter[i]); + int i = get_index(addr); + return (m_filter[i]); } -int NonCountingBloomFilter::getCount(const Address& addr) +int +NonCountingBloomFilter::getCount(const Address& addr) { - return m_filter[get_index(addr)]; + return m_filter[get_index(addr)]; } -int NonCountingBloomFilter::getTotalCount() +int +NonCountingBloomFilter::getTotalCount() { - int count = 0; + int count = 0; - for (int i = 0; i < m_filter_size; i++) { - count += m_filter[i]; - } - return count; + for (int i = 0; i < m_filter_size; i++) { + count += m_filter[i]; + } + return count; } -void NonCountingBloomFilter::print(ostream& out) const +void +NonCountingBloomFilter::print(ostream& out) const { } -int NonCountingBloomFilter::getIndex(const Address& addr) +int +NonCountingBloomFilter::getIndex(const Address& addr) { - return get_index(addr); + return get_index(addr); } -int NonCountingBloomFilter::readBit(const int index) { - return m_filter[index]; +int +NonCountingBloomFilter::readBit(const int index) +{ + return m_filter[index]; } -void NonCountingBloomFilter::writeBit(const int index, const int value) { - m_filter[index] = value; +void +NonCountingBloomFilter::writeBit(const int index, const int value) +{ + m_filter[index] = value; } -int NonCountingBloomFilter::get_index(const Address& addr) +int +NonCountingBloomFilter::get_index(const Address& addr) { - return addr.bitSelect( RubySystem::getBlockSizeBits() + m_offset, - RubySystem::getBlockSizeBits() + m_offset + m_filter_size_bits - 1); + return addr.bitSelect(RubySystem::getBlockSizeBits() + m_offset, + RubySystem::getBlockSizeBits() + m_offset + + m_filter_size_bits - 1); } diff --git a/src/mem/ruby/filters/NonCountingBloomFilter.hh b/src/mem/ruby/filters/NonCountingBloomFilter.hh index fd23fbdf7..bec645952 100644 --- a/src/mem/ruby/filters/NonCountingBloomFilter.hh +++ b/src/mem/ruby/filters/NonCountingBloomFilter.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,61 +26,53 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * NonCountingBloomFilter.hh - * - * Description: - * - * - */ - -#ifndef NONCOUNTING_BLOOM_FILTER_H -#define NONCOUNTING_BLOOM_FILTER_H +#ifndef __MEM_RUBY_FILTERS_NONCOUNTINGBLOOMFILTER_HH__ +#define __MEM_RUBY_FILTERS_NONCOUNTINGBLOOMFILTER_HH__ #include "mem/gems_common/Map.hh" -#include "mem/ruby/common/Global.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/filters/AbstractBloomFilter.hh" -class NonCountingBloomFilter : public AbstractBloomFilter { -public: - - ~NonCountingBloomFilter(); - NonCountingBloomFilter(string config); - - void clear(); - void increment(const Address& addr); - void decrement(const Address& addr); - void merge(AbstractBloomFilter * other_filter); - void set(const Address& addr); - void unset(const Address& addr); - - bool isSet(const Address& addr); - int getCount(const Address& addr); - int getTotalCount(); - - int getIndex(const Address& addr); - int readBit(const int index); - void writeBit(const int index, const int value); - - void print(ostream& out) const; - - int operator[](const int index) const{ - return this->m_filter[index]; - } - -private: - - int get_index(const Address& addr); - - Vector<int> m_filter; - int m_filter_size; - int m_offset; - int m_filter_size_bits; - - int m_count_bits; - int m_count; +class NonCountingBloomFilter : public AbstractBloomFilter +{ + public: + NonCountingBloomFilter(string config); + ~NonCountingBloomFilter(); + + void clear(); + void increment(const Address& addr); + void decrement(const Address& addr); + void merge(AbstractBloomFilter * other_filter); + void set(const Address& addr); + void unset(const Address& addr); + + bool isSet(const Address& addr); + int getCount(const Address& addr); + int getTotalCount(); + + int getIndex(const Address& addr); + int readBit(const int index); + void writeBit(const int index, const int value); + + void print(ostream& out) const; + + int + operator[](const int index) const + { + return this->m_filter[index]; + } + + private: + int get_index(const Address& addr); + + Vector<int> m_filter; + int m_filter_size; + int m_offset; + int m_filter_size_bits; + + int m_count_bits; + int m_count; }; - -#endif +#endif // __MEM_RUBY_FILTERS_NONCOUNTINGBLOOMFILTER_HH__ diff --git a/src/mem/ruby/libruby.cc b/src/mem/ruby/libruby.cc index 16b2bf346..de120036b 100644 --- a/src/mem/ruby/libruby.cc +++ b/src/mem/ruby/libruby.cc @@ -30,97 +30,101 @@ #include <algorithm> #include "config/gems_root.hh" +#include "mem/ruby/common/Address.hh" +#include "mem/ruby/eventqueue/RubyEventQueue.hh" #include "mem/ruby/libruby_internal.hh" +#include "mem/ruby/recorder/Tracer.hh" +#include "mem/ruby/system/MemoryVector.hh" #include "mem/ruby/system/RubyPort.hh" #include "mem/ruby/system/System.hh" -#include "mem/ruby/eventqueue/RubyEventQueue.hh" -#include "mem/ruby/system/MemoryVector.hh" -#include "mem/ruby/common/Address.hh" -#include "mem/ruby/recorder/Tracer.hh" -string RubyRequestType_to_string(const RubyRequestType& obj) -{ - switch(obj) { - case RubyRequestType_IFETCH: - return "IFETCH"; - case RubyRequestType_LD: - return "LD"; - case RubyRequestType_ST: - return "ST"; - case RubyRequestType_Locked_Read: - return "Locked_Read"; - case RubyRequestType_Locked_Write: - return "Locked_Write"; - case RubyRequestType_RMW_Read: - return "RMW_Read"; - case RubyRequestType_RMW_Write: - return "RMW_Write"; - case RubyRequestType_NULL: - default: - assert(0); - return ""; - } +string +RubyRequestType_to_string(const RubyRequestType& obj) +{ + switch(obj) { + case RubyRequestType_IFETCH: + return "IFETCH"; + case RubyRequestType_LD: + return "LD"; + case RubyRequestType_ST: + return "ST"; + case RubyRequestType_Locked_Read: + return "Locked_Read"; + case RubyRequestType_Locked_Write: + return "Locked_Write"; + case RubyRequestType_RMW_Read: + return "RMW_Read"; + case RubyRequestType_RMW_Write: + return "RMW_Write"; + case RubyRequestType_NULL: + default: + assert(0); + return ""; + } } -RubyRequestType string_to_RubyRequestType(std::string str) +RubyRequestType +string_to_RubyRequestType(std::string str) { - if (str == "IFETCH") - return RubyRequestType_IFETCH; - else if (str == "LD") - return RubyRequestType_LD; - else if (str == "ST") - return RubyRequestType_ST; - else if (str == "Locked_Read") - return RubyRequestType_Locked_Read; - else if (str == "Locked_Write") - return RubyRequestType_Locked_Write; - else if (str == "RMW_Read") - return RubyRequestType_RMW_Read; - else if (str == "RMW_Write") - return RubyRequestType_RMW_Write; - else - assert(0); - return RubyRequestType_NULL; + if (str == "IFETCH") + return RubyRequestType_IFETCH; + else if (str == "LD") + return RubyRequestType_LD; + else if (str == "ST") + return RubyRequestType_ST; + else if (str == "Locked_Read") + return RubyRequestType_Locked_Read; + else if (str == "Locked_Write") + return RubyRequestType_Locked_Write; + else if (str == "RMW_Read") + return RubyRequestType_RMW_Read; + else if (str == "RMW_Write") + return RubyRequestType_RMW_Write; + else + assert(0); + return RubyRequestType_NULL; } -ostream& operator<<(ostream& out, const RubyRequestType& obj) +ostream& +operator<<(ostream& out, const RubyRequestType& obj) { - out << RubyRequestType_to_string(obj); - out << flush; - return out; + out << RubyRequestType_to_string(obj); + out << flush; + return out; } -ostream& operator<<(std::ostream& out, const RubyRequest& obj) +ostream& +operator<<(std::ostream& out, const RubyRequest& obj) { - out << hex << "0x" << obj.paddr << " data: 0x" << flush; - for (int i = 0; i < obj.len; i++) { - out << (int)obj.data[i]; - } - out << dec << " type: " << RubyRequestType_to_string(obj.type) << endl; - return out; + out << hex << "0x" << obj.paddr << " data: 0x" << flush; + for (int i = 0; i < obj.len; i++) { + out << (int)obj.data[i]; + } + out << dec << " type: " << RubyRequestType_to_string(obj.type) << endl; + return out; } -vector<string> tokenizeString(string str, string delims) +vector<string> +tokenizeString(string str, string delims) { - vector<string> tokens; - char* pch; - char* tmp; - const char* c_delims = delims.c_str(); - tmp = new char[str.length()+1]; - strcpy(tmp, str.c_str()); - pch = strtok(tmp, c_delims); - while (pch != NULL) { - string tmp_str(pch); - if (tmp_str == "null") tmp_str = ""; - tokens.push_back(tmp_str); + vector<string> tokens; + char* pch; + char* tmp; + const char* c_delims = delims.c_str(); + tmp = new char[str.length()+1]; + strcpy(tmp, str.c_str()); + pch = strtok(tmp, c_delims); + while (pch != NULL) { + string tmp_str(pch); + if (tmp_str == "null") tmp_str = ""; + tokens.push_back(tmp_str); - pch = strtok(NULL, c_delims); - } - delete [] tmp; - return tokens; + pch = strtok(NULL, c_delims); + } + delete [] tmp; + return tokens; } - /* * The current state of M5/Ruby integration breaks the libruby * interface. This code is ifdef'd out for now so that we can move @@ -129,41 +133,44 @@ vector<string> tokenizeString(string str, string delims) * later date. */ #if 0 -void libruby_init(const char* cfg_filename) -{ - ifstream cfg_output(cfg_filename); - - vector<RubyObjConf> * sys_conf = new vector<RubyObjConf>; - - string line; - getline(cfg_output, line) ; - while ( !cfg_output.eof() ) { - vector<string> tokens = tokenizeString(line, " "); - assert(tokens.size() >= 2); - vector<string> argv; - for (size_t i=2; i<tokens.size(); i++) { - std::replace(tokens[i].begin(), tokens[i].end(), '%', ' '); - std::replace(tokens[i].begin(), tokens[i].end(), '#', '\n'); - argv.push_back(tokens[i]); +void +libruby_init(const char* cfg_filename) +{ + ifstream cfg_output(cfg_filename); + + vector<RubyObjConf> * sys_conf = new vector<RubyObjConf>; + + string line; + getline(cfg_output, line) ; + while ( !cfg_output.eof() ) { + vector<string> tokens = tokenizeString(line, " "); + assert(tokens.size() >= 2); + vector<string> argv; + for (size_t i=2; i<tokens.size(); i++) { + std::replace(tokens[i].begin(), tokens[i].end(), '%', ' '); + std::replace(tokens[i].begin(), tokens[i].end(), '#', '\n'); + argv.push_back(tokens[i]); + } + sys_conf->push_back(RubyObjConf(tokens[0], tokens[1], argv)); + tokens.clear(); + argv.clear(); + getline(cfg_output, line); } - sys_conf->push_back(RubyObjConf(tokens[0], tokens[1], argv)); - tokens.clear(); - argv.clear(); - getline(cfg_output, line); - } - RubySystem::create(*sys_conf); - delete sys_conf; + RubySystem::create(*sys_conf); + delete sys_conf; } #endif -RubyPortHandle libruby_get_port(const char* port_name, void (*hit_callback)(int64_t access_id)) +RubyPortHandle +libruby_get_port(const char* port_name, + void (*hit_callback)(int64_t access_id)) { - // - // Fix me: Hit callback is now a non-static member function pointer of - // RubyPort and cannot be set to an arbitrary global function - // - return NULL;//static_cast<RubyPortHandle>(RubySystem::getPort(port_name, hit_callback)); + // + // Fix me: Hit callback is now a non-static member function pointer of + // RubyPort and cannot be set to an arbitrary global function + // + return NULL;//static_cast<RubyPortHandle>(RubySystem::getPort(port_name, hit_callback)); } RubyPortHandle libruby_get_port_by_name(const char* port_name) @@ -175,17 +182,20 @@ RubyPortHandle libruby_get_port_by_name(const char* port_name) return NULL;//static_cast<RubyPortHandle>(RubySystem::getPortOnly(port_name)); } -void libruby_write_ram(uint64_t paddr, uint8_t* data, int len) +void +libruby_write_ram(uint64_t paddr, uint8_t* data, int len) { - RubySystem::getMemoryVector()->write(Address(paddr), data, len); + RubySystem::getMemoryVector()->write(Address(paddr), data, len); } -void libruby_read_ram(uint64_t paddr, uint8_t* data, int len) +void +libruby_read_ram(uint64_t paddr, uint8_t* data, int len) { - RubySystem::getMemoryVector()->read(Address(paddr), data, len); + RubySystem::getMemoryVector()->read(Address(paddr), data, len); } -int64_t libruby_issue_request(RubyPortHandle p, struct RubyRequest request) +int64_t +libruby_issue_request(RubyPortHandle p, struct RubyRequest request) { // // Fix me: Ports should now be accessed using the python configuration @@ -194,45 +204,58 @@ int64_t libruby_issue_request(RubyPortHandle p, struct RubyRequest request) return 0;//return static_cast<RubyPort*>(p)->makeRequest(request); } -int libruby_tick(int n) +int +libruby_tick(int n) { - RubySystem::getEventQueue()->triggerEvents(RubySystem::getEventQueue()->getTime() + n); - return 0; + RubyEventQueue *eventq = RubySystem::getEventQueue(); + eventq->triggerEvents(eventq->getTime() + n); + return 0; } -void libruby_destroy() +void +libruby_destroy() { } -const char* libruby_last_error() +const char* +libruby_last_error() { - return ""; + return ""; } -void libruby_print_config(std::ostream & out) +void +libruby_print_config(std::ostream & out) { - RubySystem::printConfig(out); + RubySystem::printConfig(out); } -void libruby_print_stats(std::ostream & out) +void +libruby_print_stats(std::ostream & out) { - RubySystem::printStats(out); + RubySystem::printStats(out); } -void libruby_playback_trace(char * trace_filename) +void +libruby_playback_trace(char * trace_filename) { - RubySystem::getTracer()->playbackTrace(trace_filename); + RubySystem::getTracer()->playbackTrace(trace_filename); } -void libruby_start_tracing(char * record_filename) { - // start the trace - RubySystem::getTracer()->startTrace(record_filename); +void +libruby_start_tracing(char * record_filename) +{ + // start the trace + RubySystem::getTracer()->startTrace(record_filename); } -void libruby_stop_tracing() { - // start the trace - RubySystem::getTracer()->stopTrace(); +void +libruby_stop_tracing() +{ + // start the trace + RubySystem::getTracer()->stopTrace(); } -uint64_t libruby_get_time() { - return RubySystem::getCycleCount(0); +uint64_t +libruby_get_time() +{ + return RubySystem::getCycleCount(0); } diff --git a/src/mem/ruby/libruby.hh b/src/mem/ruby/libruby.hh index e22859818..6d83c3f08 100644 --- a/src/mem/ruby/libruby.hh +++ b/src/mem/ruby/libruby.hh @@ -26,11 +26,12 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef LIBRUBY_H -#define LIBRUBY_H +#ifndef __MEM_RUBY_LIBRUBY_HH__ +#define __MEM_RUBY_LIBRUBY_HH__ -#include <stdint.h> #include <ostream> + +#include "base/types.hh" #include "mem/packet.hh" typedef void* RubyPortHandle; @@ -52,34 +53,35 @@ enum RubyAccessMode { RubyAccessMode_Device }; -struct RubyRequest { - uint64_t paddr; - uint8_t* data; - int len; - uint64_t pc; - RubyRequestType type; - RubyAccessMode access_mode; - PacketPtr pkt; - unsigned proc_id; - - RubyRequest() {} - RubyRequest(uint64_t _paddr, - uint8_t* _data, - int _len, - uint64_t _pc, - RubyRequestType _type, - RubyAccessMode _access_mode, - PacketPtr _pkt, - unsigned _proc_id = 100) - : paddr(_paddr), - data(_data), - len(_len), - pc(_pc), - type(_type), - access_mode(_access_mode), - pkt(_pkt), - proc_id(_proc_id) - {} +struct RubyRequest +{ + uint64_t paddr; + uint8_t* data; + int len; + uint64_t pc; + RubyRequestType type; + RubyAccessMode access_mode; + PacketPtr pkt; + unsigned proc_id; + + RubyRequest() {} + RubyRequest(uint64_t _paddr, + uint8_t* _data, + int _len, + uint64_t _pc, + RubyRequestType _type, + RubyAccessMode _access_mode, + PacketPtr _pkt, + unsigned _proc_id = 100) + : paddr(_paddr), + data(_data), + len(_len), + pc(_pc), + type(_type), + access_mode(_access_mode), + pkt(_pkt), + proc_id(_proc_id) + {} }; std::ostream& operator<<(std::ostream& out, const RubyRequest& obj); @@ -90,7 +92,8 @@ std::ostream& operator<<(std::ostream& out, const RubyRequest& obj); void libruby_init(const char* cfg_file); /** - * Tear down a configured system. Must be invoked after a call to libruby_init. + * Tear down a configured system. Must be invoked after a call to + * libruby_init. */ void libruby_destroy(); @@ -105,7 +108,8 @@ const char* libruby_last_error(); * this port to use when a request completes. Only one handle to a * port is allowed at a time. */ -RubyPortHandle libruby_get_port(const char* name, void (*hit_callback)(int64_t access_id)); +RubyPortHandle libruby_get_port(const char* name, + void (*hit_callback)(int64_t access_id)); /** * Retrieve a handle to a RubyPort object, identified by name in the @@ -113,7 +117,6 @@ RubyPortHandle libruby_get_port(const char* name, void (*hit_callback)(int64_t a */ RubyPortHandle libruby_get_port_by_name(const char* name); - /** * issue_request returns a unique access_id to identify the ruby * transaction. This access_id is later returned to the caller via @@ -126,14 +129,14 @@ int64_t libruby_issue_request(RubyPortHandle p, struct RubyRequest request); * ignores caches, and should be considered incoherent after * simulation starts. */ -void libruby_write_ram(uint64_t paddr, uint8_t * data, int len); +void libruby_write_ram(uint64_t paddr, uint8_t *data, int len); /** * reads data directory from Ruby's data array. Note that this * ignores caches, and should be considered incoherent after * simulation starts */ -void libruby_read_ram(uint64_t paddr, uint8_t * data, int len); +void libruby_read_ram(uint64_t paddr, uint8_t *data, int len); /** * tick the system n cycles. Eventually, will return the number of @@ -144,22 +147,22 @@ int libruby_tick(int n); /** * self explainitory */ -void libruby_print_config(std::ostream & out); +void libruby_print_config(std::ostream &out); /** * self explainitory */ -void libruby_print_stats(std::ostream & out); +void libruby_print_stats(std::ostream &out); /** * does not return until done */ -void libruby_playback_trace(char * trace_filename); +void libruby_playback_trace(char *trace_filename); /* * enables the tracer and opens the trace file */ -void libruby_start_tracing(char * record_filename); +void libruby_start_tracing(char *record_filename); /* * closes the trace file @@ -170,4 +173,5 @@ void libruby_stop_tracing(); * get time */ uint64_t libruby_get_time(); -#endif + +#endif // __MEM_RUBY_LIBRUBY_HH__ diff --git a/src/mem/ruby/libruby_internal.hh b/src/mem/ruby/libruby_internal.hh index 9e821ba7c..c64814051 100644 --- a/src/mem/ruby/libruby_internal.hh +++ b/src/mem/ruby/libruby_internal.hh @@ -26,16 +26,16 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef LIBRUBY_INTERNAL_H -#define LIBRUBY_INTERNAL_H - -#include "mem/ruby/libruby.hh" +#ifndef __MEM_RUBY_LIBRUBY_INTERNAL_HH__ +#define __MEM_RUBY_LIBRUBY_INTERNAL_HH__ #include <ostream> #include <string> +#include "mem/ruby/libruby.hh" + std::string RubyRequestType_to_string(const RubyRequestType& obj); RubyRequestType string_to_RubyRequestType(std::string); std::ostream& operator<<(std::ostream& out, const RubyRequestType& obj); -#endif +#endif // __MEM_RUBY_LIBRUBY_INTERNAL_HH__ diff --git a/src/mem/ruby/slicc_interface/AbstractCacheEntry.cc b/src/mem/ruby/slicc_interface/AbstractCacheEntry.cc index 83039a9b0..3d8972c40 100644 --- a/src/mem/ruby/slicc_interface/AbstractCacheEntry.cc +++ b/src/mem/ruby/slicc_interface/AbstractCacheEntry.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,21 +26,15 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - * - * Description: See AbstractCacheEntry.hh - * - */ - #include "mem/ruby/slicc_interface/AbstractCacheEntry.hh" -AbstractCacheEntry::AbstractCacheEntry() { - m_Address.setAddress(0); - m_Permission = AccessPermission_NotPresent; +AbstractCacheEntry::AbstractCacheEntry() +{ + m_Address.setAddress(0); + m_Permission = AccessPermission_NotPresent; } -// still need to define destructor for subclasses -AbstractCacheEntry::~AbstractCacheEntry() { +AbstractCacheEntry::~AbstractCacheEntry() +{ } diff --git a/src/mem/ruby/slicc_interface/AbstractCacheEntry.hh b/src/mem/ruby/slicc_interface/AbstractCacheEntry.hh index b98e1fa07..223bc6fc8 100644 --- a/src/mem/ruby/slicc_interface/AbstractCacheEntry.hh +++ b/src/mem/ruby/slicc_interface/AbstractCacheEntry.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -28,49 +27,39 @@ */ /* - * $Id$ - * - * Description: Common base class for a machine node. - * + * Common base class for a machine node. */ -#ifndef AbstractCacheEntry_H -#define AbstractCacheEntry_H +#ifndef __MEM_RUBY_SLICC_INTERFACE_ABSTRACTCACHEENTRY_HH__ +#define __MEM_RUBY_SLICC_INTERFACE_ABSTRACTCACHEENTRY_HH__ -#include "mem/ruby/common/Global.hh" -#include "mem/ruby/common/Address.hh" #include "mem/protocol/AccessPermission.hh" +#include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/slicc_interface/AbstractEntry.hh" class DataBlock; -class AbstractCacheEntry : public AbstractEntry { -public: - // Constructors - AbstractCacheEntry(); - - // Destructor, prevent it from instantiation - virtual ~AbstractCacheEntry() = 0; +class AbstractCacheEntry : public AbstractEntry +{ + public: + AbstractCacheEntry(); + virtual ~AbstractCacheEntry() = 0; - // Data Members (m_ prefix) - Address m_Address; // Address of this block, required by CacheMemory - Time m_LastRef; // Last time this block was referenced, required by CacheMemory - AccessPermission m_Permission; // Access permission for this block, required by CacheMemory + Address m_Address; // Address of this block, required by CacheMemory + Time m_LastRef; // Last time this block was referenced, required + // by CacheMemory + AccessPermission m_Permission; // Access permission for this + // block, required by CacheMemory }; -// Output operator declaration -ostream& operator<<(ostream& out, const AbstractCacheEntry& obj); - -// ******************* Definitions ******************* - -// Output operator definition -extern inline -ostream& operator<<(ostream& out, const AbstractCacheEntry& obj) +inline ostream& +operator<<(ostream& out, const AbstractCacheEntry& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } -#endif //AbstractCacheEntry_H +#endif // __MEM_RUBY_SLICC_INTERFACE_ABSTRACTCACHEENTRY_HH__ diff --git a/src/mem/ruby/slicc_interface/AbstractController.hh b/src/mem/ruby/slicc_interface/AbstractController.hh index 390b7f730..facaf2adf 100644 --- a/src/mem/ruby/slicc_interface/AbstractController.hh +++ b/src/mem/ruby/slicc_interface/AbstractController.hh @@ -26,8 +26,8 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef ABSTRACTCONTROLLER_H -#define ABSTRACTCONTROLLER_H +#ifndef __MEM_RUBY_SLICC_INTERFACE_ABSTRACTCONTROLLER_HH__ +#define __MEM_RUBY_SLICC_INTERFACE_ABSTRACTCONTROLLER_HH__ #include "sim/sim_object.hh" #include "params/RubyController.hh" @@ -40,29 +40,30 @@ class MessageBuffer; class Network; -class AbstractController : public SimObject, public Consumer { -public: +class AbstractController : public SimObject, public Consumer +{ + public: typedef RubyControllerParams Params; AbstractController(const Params *p) : SimObject(p) {} - // returns the number of controllers created of the specific subtype - // virtual int getNumberOfControllers() const = 0; - virtual MessageBuffer* getMandatoryQueue() const = 0; - virtual const int & getVersion() const = 0; - virtual const string toString() const = 0; // returns text version of controller type - virtual const string getName() const = 0; // return instance name - virtual const MachineType getMachineType() const = 0; - virtual void blockOnQueue(Address, MessageBuffer*) = 0; - virtual void unblock(Address) = 0; - virtual void initNetworkPtr(Network* net_ptr) = 0; - - virtual void print(ostream & out) const = 0; - virtual void printStats(ostream & out) const = 0; - virtual void printConfig(ostream & out) const = 0; - virtual void wakeup() = 0; - // virtual void dumpStats(ostream & out) = 0; - virtual void clearStats() = 0; + // returns the number of controllers created of the specific subtype + // virtual int getNumberOfControllers() const = 0; + virtual MessageBuffer* getMandatoryQueue() const = 0; + virtual const int & getVersion() const = 0; + virtual const string toString() const = 0; // returns text version of + // controller type + virtual const string getName() const = 0; // return instance name + virtual const MachineType getMachineType() const = 0; + virtual void blockOnQueue(Address, MessageBuffer*) = 0; + virtual void unblock(Address) = 0; + virtual void initNetworkPtr(Network* net_ptr) = 0; + virtual void print(ostream & out) const = 0; + virtual void printStats(ostream & out) const = 0; + virtual void printConfig(ostream & out) const = 0; + virtual void wakeup() = 0; + // virtual void dumpStats(ostream & out) = 0; + virtual void clearStats() = 0; }; -#endif +#endif // __MEM_RUBY_SLICC_INTERFACE_ABSTRACTCONTROLLER_HH__ diff --git a/src/mem/ruby/slicc_interface/AbstractEntry.cc b/src/mem/ruby/slicc_interface/AbstractEntry.cc index 914d4a37e..d66258eef 100644 --- a/src/mem/ruby/slicc_interface/AbstractEntry.cc +++ b/src/mem/ruby/slicc_interface/AbstractEntry.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -29,10 +28,10 @@ #include "mem/ruby/slicc_interface/AbstractEntry.hh" -// Must define constructor and destructor in subclasses -AbstractEntry::AbstractEntry() { +AbstractEntry::AbstractEntry() +{ } -AbstractEntry::~AbstractEntry() { +AbstractEntry::~AbstractEntry() +{ } - diff --git a/src/mem/ruby/slicc_interface/AbstractEntry.hh b/src/mem/ruby/slicc_interface/AbstractEntry.hh index 8e1968d62..eef9a5227 100644 --- a/src/mem/ruby/slicc_interface/AbstractEntry.hh +++ b/src/mem/ruby/slicc_interface/AbstractEntry.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,47 +26,35 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef AbstractEntry_H -#define AbstractEntry_H +#ifndef __MEM_RUBY_SLICC_INTERFACE_ABSTRACTENTRY_HH__ +#define __MEM_RUBY_SLICC_INTERFACE_ABSTRACTENTRY_HH__ -#include "mem/ruby/common/Global.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" #include "mem/protocol/AccessPermission.hh" class DataBlock; -class AbstractEntry { -public: - // Constructors - AbstractEntry(); - - // Destructor, prevent it from instantiation - virtual ~AbstractEntry() = 0; - - // Public Methods - - // The methods below are those called by ruby runtime, add when it is - // absolutely necessary and should all be virtual function. - virtual DataBlock& getDataBlk() = 0; - +class AbstractEntry +{ + public: + AbstractEntry(); + virtual ~AbstractEntry() = 0; - virtual void print(ostream& out) const = 0; + // The methods below are those called by ruby runtime, add when it + // is absolutely necessary and should all be virtual function. + virtual DataBlock& getDataBlk() = 0; + virtual void print(ostream& out) const = 0; }; -// Output operator declaration -ostream& operator<<(ostream& out, const AbstractEntry& obj); - -// ******************* Definitions ******************* - -// Output operator definition -extern inline -ostream& operator<<(ostream& out, const AbstractEntry& obj) +inline ostream& +operator<<(ostream& out, const AbstractEntry& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } -#endif //AbstractEntry_H +#endif // __MEM_RUBY_SLICC_INTERFACE_ABSTRACTENTRY_HH__ diff --git a/src/mem/ruby/slicc_interface/AbstractProtocol.hh b/src/mem/ruby/slicc_interface/AbstractProtocol.hh index d602f5e54..2cc64a258 100644 --- a/src/mem/ruby/slicc_interface/AbstractProtocol.hh +++ b/src/mem/ruby/slicc_interface/AbstractProtocol.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -28,33 +27,24 @@ */ /* - * $Id$ - * - * Description: Define all possible protocol parameters and their - * default value here. Normally, all parameters should - * have default value "false" means the feature of the - * protocol is turned off. - * + * Define all possible protocol parameters and their default value + * here. Normally, all parameters should have default value "false" + * means the feature of the protocol is turned off. */ -#ifndef AbstractProtocol_H -#define AbstractProtocol_H - -class AbstractProtocol { -public: - // Constructors - AbstractProtocol() {}; +#ifndef __MEM_RUBY_SLICC_INTERFACE_ABSTRACTPROTOCOL_HH__ +#define __MEM_RUBY_SLICC_INTERFACE_ABSTRACTPROTOCOL_HH__ - // Destructor, no instantiation - // No definition also, so no subclass can be instantiated also - virtual ~AbstractProtocol() = 0; +class AbstractProtocol +{ + public: + AbstractProtocol() {} - // Public Methods + virtual ~AbstractProtocol() = 0; - // Data Members (m_ prefix) - static const bool m_CMP = false ; - static const bool m_TwoLevelCache = false ; + static const bool m_CMP = false ; + static const bool m_TwoLevelCache = false ; }; -#endif //AbstractProtocol_H +#endif // __MEM_RUBY_SLICC_INTERFACE_ABSTRACTPROTOCOL_HH__ diff --git a/src/mem/ruby/slicc_interface/Message.hh b/src/mem/ruby/slicc_interface/Message.hh index fef4bdf59..d9df6f131 100644 --- a/src/mem/ruby/slicc_interface/Message.hh +++ b/src/mem/ruby/slicc_interface/Message.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,67 +26,58 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - */ - -#ifndef MESSAGE_H -#define MESSAGE_H +#ifndef __MEM_RUBY_SLICC_INTERFACE_MESSAGE_HH__ +#define __MEM_RUBY_SLICC_INTERFACE_MESSAGE_HH__ #include <iostream> -#include "mem/ruby/common/Global.hh" #include "mem/gems_common/RefCnt.hh" #include "mem/gems_common/RefCountable.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/eventqueue/RubyEventQueue.hh" class Message; typedef RefCnt<Message> MsgPtr; -class Message : public RefCountable { -public: - // Constructors - Message() : RefCountable() { m_time = g_eventQueue_ptr->getTime(); m_LastEnqueueTime = g_eventQueue_ptr->getTime(); m_DelayedCycles = 0;} - - // Destructor - virtual ~Message() { } - - // Public Methods - 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; } - const int& getDelayedCycles() const {return m_DelayedCycles;} - int& getDelayedCycles() {return m_DelayedCycles;} - void setLastEnqueueTime(const Time& time) { m_LastEnqueueTime = time; } - const Time& getLastEnqueueTime() const {return m_LastEnqueueTime;} - Time& getLastEnqueueTime() {return m_LastEnqueueTime;} - - const Time& getTime() const { return m_time; } - void setTime(const Time& new_time) { m_time = new_time; } -private: - // Private Methods - - // Data Members (m_ prefix) - Time m_time; - Time m_LastEnqueueTime; // my last enqueue time - int m_DelayedCycles; // my delayed cycles - +class Message : public RefCountable +{ + public: + Message() + : RefCountable() + { + m_time = g_eventQueue_ptr->getTime(); + m_LastEnqueueTime = g_eventQueue_ptr->getTime(); + m_DelayedCycles = 0; + } + + 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; } + const int& getDelayedCycles() const {return m_DelayedCycles;} + int& getDelayedCycles() {return m_DelayedCycles;} + void setLastEnqueueTime(const Time& time) { m_LastEnqueueTime = time; } + const Time& getLastEnqueueTime() const {return m_LastEnqueueTime;} + Time& getLastEnqueueTime() {return m_LastEnqueueTime;} + + const Time& getTime() const { return m_time; } + void setTime(const Time& new_time) { m_time = new_time; } + + private: + Time m_time; + Time m_LastEnqueueTime; // my last enqueue time + int m_DelayedCycles; // my delayed cycles }; -// Output operator declaration -std::ostream& operator<<(std::ostream& out, const Message& obj); - -// ******************* Definitions ******************* - -// Output operator definition -extern inline -std::ostream& operator<<(std::ostream& out, const Message& obj) +inline std::ostream& +operator<<(std::ostream& out, const Message& obj) { - obj.print(out); - out << std::flush; - return out; + obj.print(out); + out << std::flush; + return out; } -#endif //MESSAGE_H +#endif // __MEM_RUBY_SLICC_INTERFACE_MESSAGE_HH__ diff --git a/src/mem/ruby/slicc_interface/NetworkMessage.hh b/src/mem/ruby/slicc_interface/NetworkMessage.hh index 150fd70fc..8a7c00094 100644 --- a/src/mem/ruby/slicc_interface/NetworkMessage.hh +++ b/src/mem/ruby/slicc_interface/NetworkMessage.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,89 +26,69 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * NetworkMessage.hh - * - * Description: - * - * $Id$ - * - */ - -#ifndef NetworkMessage_H -#define NetworkMessage_H +#ifndef __MEM_RUBY_SLICC_INTERFACE_NETWORKMESSAGE_HH__ +#define __MEM_RUBY_SLICC_INTERFACE_NETWORKMESSAGE_HH__ -#include "mem/ruby/common/Global.hh" #include "mem/gems_common/RefCnt.hh" #include "mem/gems_common/RefCountable.hh" -#include "mem/ruby/slicc_interface/Message.hh" #include "mem/protocol/MessageSizeType.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/common/NetDest.hh" +#include "mem/ruby/slicc_interface/Message.hh" class Address; class NetworkMessage; typedef RefCnt<NetworkMessage> NetMsgPtr; -class NetworkMessage : public Message { -public: - // Constructors - NetworkMessage() - :Message() +class NetworkMessage : public Message +{ + public: + NetworkMessage() + : Message() { - m_internal_dest_valid = false; + m_internal_dest_valid = false; } - // Destructor - virtual ~NetworkMessage() { } + virtual ~NetworkMessage() { } - // Public Methods + virtual const NetDest& getDestination() const = 0; + virtual NetDest& getDestination() = 0; + virtual const MessageSizeType& getMessageSize() const = 0; + virtual MessageSizeType& getMessageSize() = 0; - virtual const NetDest& getDestination() const = 0; - virtual NetDest& getDestination() = 0; - virtual const MessageSizeType& getMessageSize() const = 0; - virtual MessageSizeType& getMessageSize() = 0; - // virtual const Address& getAddress() const = 0; - // virtual Address& getAddress() = 0; + const NetDest& + getInternalDestination() const + { + if (m_internal_dest_valid == false) + return getDestination(); - const NetDest& getInternalDestination() const { - if (m_internal_dest_valid == false) { - return getDestination(); - } else { - return m_internal_dest; + return m_internal_dest; } - } - NetDest& getInternalDestination() { - if (m_internal_dest_valid == false) { - m_internal_dest = getDestination(); - m_internal_dest_valid = true; + NetDest& + getInternalDestination() + { + if (m_internal_dest_valid == false) { + m_internal_dest = getDestination(); + m_internal_dest_valid = true; + } + return m_internal_dest; } - return m_internal_dest; - } - - virtual void print(ostream& out) const = 0; -private: - // Private Methods + virtual void print(ostream& out) const = 0; - // Data Members (m_ prefix) - NetDest m_internal_dest; - bool m_internal_dest_valid; + private: + NetDest m_internal_dest; + bool m_internal_dest_valid; }; -// Output operator declaration -ostream& operator<<(ostream& out, const NetworkMessage& obj); - -// ******************* Definitions ******************* - -// Output operator definition -extern inline -ostream& operator<<(ostream& out, const NetworkMessage& obj) +inline ostream& +operator<<(ostream& out, const NetworkMessage& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } -#endif //NetworkMessage_H +#endif // __MEM_RUBY_SLICC_INTERFACE_NETWORKMESSAGE_HH__ diff --git a/src/mem/ruby/slicc_interface/RubySlicc_ComponentMapping.cc b/src/mem/ruby/slicc_interface/RubySlicc_ComponentMapping.cc index 0821201e7..79b9821ba 100644 --- a/src/mem/ruby/slicc_interface/RubySlicc_ComponentMapping.cc +++ b/src/mem/ruby/slicc_interface/RubySlicc_ComponentMapping.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,7 +26,6 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - #include "mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh" #include "mem/ruby/system/CacheMemory.hh" diff --git a/src/mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh b/src/mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh index 5ffd0f295..c96667028 100644 --- a/src/mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh +++ b/src/mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,22 +26,18 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - */ - -#ifndef COMPONENTMAPPINGFNS_H -#define COMPONENTMAPPINGFNS_H +#ifndef __MEM_RUBY_SLICC_INTERFACE_RUBYSLICC_COMPONENTMAPPINGS_HH__ +#define __MEM_RUBY_SLICC_INTERFACE_RUBYSLICC_COMPONENTMAPPINGS_HH__ -#include "mem/ruby/common/Global.hh" -#include "mem/ruby/system/NodeID.hh" -#include "mem/ruby/system/MachineID.hh" +#include "mem/protocol/GenericMachineType.hh" +#include "mem/protocol/MachineType.hh" #include "mem/ruby/common/Address.hh" -#include "mem/ruby/common/Set.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/common/NetDest.hh" -#include "mem/protocol/GenericMachineType.hh" +#include "mem/ruby/common/Set.hh" #include "mem/ruby/system/DirectoryMemory.hh" -#include "mem/protocol/MachineType.hh" +#include "mem/ruby/system/MachineID.hh" +#include "mem/ruby/system/NodeID.hh" #ifdef MACHINETYPE_L1Cache #define MACHINETYPE_L1CACHE_ENUM MachineType_L1Cache @@ -70,88 +65,100 @@ // used to determine the home directory // returns a value between 0 and total_directories_within_the_system -inline -NodeID map_Address_to_DirectoryNode(const Address& addr) +inline NodeID +map_Address_to_DirectoryNode(const Address& addr) { - return DirectoryMemory::mapAddressToDirectoryVersion(addr); + return DirectoryMemory::mapAddressToDirectoryVersion(addr); } // used to determine the home directory // returns a value between 0 and total_directories_within_the_system -inline -MachineID map_Address_to_Directory(const Address &addr) +inline MachineID +map_Address_to_Directory(const Address &addr) { - MachineID mach = {MachineType_Directory, map_Address_to_DirectoryNode(addr)}; - return mach; + MachineID mach = + {MachineType_Directory, map_Address_to_DirectoryNode(addr)}; + return mach; } -inline -MachineID map_Address_to_DMA(const Address & addr) +inline MachineID +map_Address_to_DMA(const Address & addr) { - MachineID dma = {MACHINETYPE_DMA_ENUM, 0}; - return dma; + MachineID dma = {MACHINETYPE_DMA_ENUM, 0}; + return dma; } -inline -NetDest broadcast(MachineType type) +inline NetDest +broadcast(MachineType type) { - NetDest dest; - for (int i=0; i<MachineType_base_count(type); i++) { - MachineID mach = {type, i}; - dest.add(mach); - } - return dest; + NetDest dest; + for (int i = 0; i < MachineType_base_count(type); i++) { + MachineID mach = {type, i}; + dest.add(mach); + } + return dest; } -inline -MachineID mapAddressToRange(const Address & addr, MachineType type, int low_bit, int num_bits) +inline MachineID +mapAddressToRange(const Address & addr, MachineType type, int low_bit, + int num_bits) { - MachineID mach = {type, 0}; - if (num_bits == 0) + MachineID mach = {type, 0}; + if (num_bits == 0) + return mach; + mach.num = addr.bitSelect(low_bit, low_bit + num_bits - 1); return mach; - mach.num = addr.bitSelect(low_bit, low_bit+num_bits-1); - return mach; } -extern inline NodeID machineIDToNodeID(MachineID machID) +inline NodeID +machineIDToNodeID(MachineID machID) { - return machID.num; + return machID.num; } -extern inline MachineType machineIDToMachineType(MachineID machID) +inline MachineType +machineIDToMachineType(MachineID machID) { - return machID.type; + return machID.type; } -extern inline NodeID L1CacheMachIDToProcessorNum(MachineID machID) +inline NodeID +L1CacheMachIDToProcessorNum(MachineID machID) { - assert(machID.type == MachineType_L1Cache); - return machID.num; + assert(machID.type == MachineType_L1Cache); + return machID.num; } -extern inline MachineID getL1MachineID(NodeID L1RubyNode) +inline MachineID +getL1MachineID(NodeID L1RubyNode) { - MachineID mach = {MACHINETYPE_L1CACHE_ENUM, L1RubyNode}; - return mach; + MachineID mach = {MACHINETYPE_L1CACHE_ENUM, L1RubyNode}; + return mach; } -extern inline GenericMachineType ConvertMachToGenericMach(MachineType machType) { - if (machType == MACHINETYPE_L1CACHE_ENUM) { - return GenericMachineType_L1Cache; - } else if (machType == MACHINETYPE_L2CACHE_ENUM) { - return GenericMachineType_L2Cache; - } else if (machType == MACHINETYPE_L3CACHE_ENUM) { - return GenericMachineType_L3Cache; - } else if (machType == MachineType_Directory) { - return GenericMachineType_Directory; - } else { +inline GenericMachineType +ConvertMachToGenericMach(MachineType machType) +{ + if (machType == MACHINETYPE_L1CACHE_ENUM) + return GenericMachineType_L1Cache; + + if (machType == MACHINETYPE_L2CACHE_ENUM) + return GenericMachineType_L2Cache; + + if (machType == MACHINETYPE_L3CACHE_ENUM) + return GenericMachineType_L3Cache; + + if (machType == MachineType_Directory) + return GenericMachineType_Directory; + ERROR_MSG("cannot convert to a GenericMachineType"); return GenericMachineType_NULL; - } } -extern inline int machineCount(MachineType machType) { +inline int +machineCount(MachineType machType) +{ return MachineType_base_count(machType); } -#endif // COMPONENTMAPPINGFNS_H +#endif // __MEM_RUBY_SLICC_INTERFACE_COMPONENTMAPPINGS_HH__ diff --git a/src/mem/ruby/slicc_interface/RubySlicc_Profiler_interface.cc b/src/mem/ruby/slicc_interface/RubySlicc_Profiler_interface.cc index 54d38c187..6ffc7fdb4 100644 --- a/src/mem/ruby/slicc_interface/RubySlicc_Profiler_interface.cc +++ b/src/mem/ruby/slicc_interface/RubySlicc_Profiler_interface.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,66 +26,75 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * slicc_util.cc - * - * Description: See slicc_util.hh - * - * $Id$ - * - */ - +#include "mem/protocol/Protocol.hh" #include "mem/ruby/common/Global.hh" -#include "mem/ruby/system/System.hh" -#include "mem/ruby/profiler/Profiler.hh" #include "mem/ruby/profiler/AddressProfiler.hh" -#include "mem/protocol/Protocol.hh" -#include "mem/ruby/slicc_interface/RubySlicc_Profiler_interface.hh" +#include "mem/ruby/profiler/Profiler.hh" #include "mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh" -// #include "TransactionInterfaceManager.hh" +#include "mem/ruby/slicc_interface/RubySlicc_Profiler_interface.hh" +#include "mem/ruby/system/System.hh" -void profile_request(int cache_state, Directory_State directory_state, GenericRequestType request_type) +void +profile_request(int cache_state, Directory_State directory_state, + GenericRequestType request_type) { - string requestStr = L1Cache_State_to_string(L1Cache_State(cache_state))+":"+ - Directory_State_to_string(directory_state)+":"+ - GenericRequestType_to_string(request_type); - g_system_ptr->getProfiler()->profileRequest(requestStr); + string requestStr = L1Cache_State_to_string(L1Cache_State(cache_state))+ + ":" + + Directory_State_to_string(directory_state) + ":" + + GenericRequestType_to_string(request_type); + g_system_ptr->getProfiler()->profileRequest(requestStr); } -void profile_request(const string& L1CacheState, const string& L2CacheState, const string& directoryState, const string& requestType) +void +profile_request(const string& L1CacheState, const string& L2CacheState, + const string& directoryState, const string& requestType) { - string requestStr = L1CacheState+":"+L2CacheState+":"+directoryState+":"+requestType; - g_system_ptr->getProfiler()->profileRequest(requestStr); + string requestStr = L1CacheState + ":" + L2CacheState + ":" + + directoryState + ":" + requestType; + + g_system_ptr->getProfiler()->profileRequest(requestStr); } -void profile_outstanding_request(int outstanding) +void +profile_outstanding_request(int outstanding) { - g_system_ptr->getProfiler()->profileOutstandingRequest(outstanding); + g_system_ptr->getProfiler()->profileOutstandingRequest(outstanding); } -void profile_average_latency_estimate(int latency) +void +profile_average_latency_estimate(int latency) { - g_system_ptr->getProfiler()->profileAverageLatencyEstimate(latency); + g_system_ptr->getProfiler()->profileAverageLatencyEstimate(latency); } -void profile_sharing(const Address& addr, AccessType type, NodeID requestor, const Set& sharers, const Set& owner) +void +profile_sharing(const Address& addr, AccessType type, NodeID requestor, + const Set& sharers, const Set& owner) { - g_system_ptr->getProfiler()->profileSharing(addr, type, requestor, sharers, owner); + g_system_ptr->getProfiler()-> + profileSharing(addr, type, requestor, sharers, owner); } -void profileMsgDelay(int virtualNetwork, int delayCycles) +void +profileMsgDelay(int virtualNetwork, int delayCycles) { - g_system_ptr->getProfiler()->profileMsgDelay(virtualNetwork, delayCycles); + g_system_ptr->getProfiler()->profileMsgDelay(virtualNetwork, delayCycles); } -void profileGetX(const Address& datablock, const Address& PC, const Set& owner, const Set& sharers, NodeID requestor) +void +profileGetX(const Address& datablock, const Address& PC, const Set& owner, + const Set& sharers, NodeID requestor) { - g_system_ptr->getProfiler()->getAddressProfiler()->profileGetX(datablock, PC, owner, sharers, requestor); + g_system_ptr->getProfiler()->getAddressProfiler()-> + profileGetX(datablock, PC, owner, sharers, requestor); } -void profileGetS(const Address& datablock, const Address& PC, const Set& owner, const Set& sharers, NodeID requestor) +void +profileGetS(const Address& datablock, const Address& PC, const Set& owner, + const Set& sharers, NodeID requestor) { - g_system_ptr->getProfiler()->getAddressProfiler()->profileGetS(datablock, PC, owner, sharers, requestor); + g_system_ptr->getProfiler()->getAddressProfiler()-> + profileGetS(datablock, PC, owner, sharers, requestor); } diff --git a/src/mem/ruby/slicc_interface/RubySlicc_Profiler_interface.hh b/src/mem/ruby/slicc_interface/RubySlicc_Profiler_interface.hh index 1529e6317..25495b6fa 100644 --- a/src/mem/ruby/slicc_interface/RubySlicc_Profiler_interface.hh +++ b/src/mem/ruby/slicc_interface/RubySlicc_Profiler_interface.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -28,36 +27,37 @@ */ /* - * slicc_util.hh - * - * Description: These are the functions that exported to slicc from ruby. - * - * $Id$ - * + * These are the functions that exported to slicc from ruby. */ -#ifndef RUBYSLICC_PROFILER_INTERFACE_H -#define RUBYSLICC_PROFILER_INTERFACE_H +#ifndef __MEM_RUBY_SLICC_INTERFACE_RUBYSLICC_PROFILER_INTERFACE_HH__ +#define __MEM_RUBY_SLICC_INTERFACE_RUBYSLICC_PROFILER_INTERFACE_HH__ -#include "mem/ruby/common/Global.hh" -#include "mem/ruby/profiler/Profiler.hh" -#include "mem/ruby/common/Address.hh" -#include "mem/protocol/L1Cache_State.hh" #include "mem/protocol/AccessType.hh" -#include "mem/protocol/GenericRequestType.hh" #include "mem/protocol/Directory_State.hh" +#include "mem/protocol/GenericRequestType.hh" +#include "mem/protocol/L1Cache_State.hh" +#include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" +#include "mem/ruby/profiler/Profiler.hh" #include "mem/ruby/system/NodeID.hh" class Set; -void profile_request(int cache_state, Directory_State directory_state, GenericRequestType request_type); +void profile_request(int cache_state, Directory_State directory_state, + GenericRequestType request_type); void profile_outstanding_persistent_request(int outstanding); void profile_outstanding_request(int outstanding); -void profile_sharing(const Address& addr, AccessType type, NodeID requestor, const Set& sharers, const Set& owner); -void profile_request(const string& L1CacheStateStr, const string& L2CacheStateStr, const string& directoryStateStr, const string& requestTypeStr); +void profile_sharing(const Address& addr, AccessType type, NodeID requestor, + const Set& sharers, const Set& owner); +void profile_request(const string& L1CacheStateStr, + const string& L2CacheStateStr, + const string& directoryStateStr, + const string& requestTypeStr); void profile_miss(const CacheMsg& msg, NodeID id); void profile_L1Cache_miss(const CacheMsg& msg, NodeID id); -void profile_L2Cache_miss(GenericRequestType requestType, AccessModeType type, int msgSize, PrefetchBit pfBit, NodeID l2cacheID); +void profile_L2Cache_miss(GenericRequestType requestType, AccessModeType type, + int msgSize, PrefetchBit pfBit, NodeID l2cacheID); void profile_token_retry(const Address& addr, AccessType type, int count); void profile_filter_action(int action); void profile_persistent_prediction(const Address& addr, AccessType type); @@ -65,9 +65,11 @@ void profile_average_latency_estimate(int latency); void profileMsgDelay(int virtualNetwork, int delayCycles); void profile_multicast_retry(const Address& addr, int count); -void profileGetX(const Address& datablock, const Address& PC, const Set& owner, const Set& sharers, NodeID requestor); -void profileGetS(const Address& datablock, const Address& PC, const Set& owner, const Set& sharers, NodeID requestor); +void profileGetX(const Address& datablock, const Address& PC, const Set& owner, + const Set& sharers, NodeID requestor); +void profileGetS(const Address& datablock, const Address& PC, const Set& owner, + const Set& sharers, NodeID requestor); void profileOverflow(const Address & addr, MachineID mach); -#endif // RUBYSLICC_PROFILER_INTERFACE_H +#endif // __MEM_RUBY_SLICC_INTERFACE_RUBYSLICC_PROFILER_INTERFACE_HH__ diff --git a/src/mem/ruby/slicc_interface/RubySlicc_Util.hh b/src/mem/ruby/slicc_interface/RubySlicc_Util.hh index 3d4fa3e5c..24240dc52 100644 --- a/src/mem/ruby/slicc_interface/RubySlicc_Util.hh +++ b/src/mem/ruby/slicc_interface/RubySlicc_Util.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -28,149 +27,163 @@ */ /* - * slicc_util.hh - * - * Description: These are the functions that exported to slicc from ruby. - * - * $Id$ - * + * These are the functions that exported to slicc from ruby. */ -#ifndef SLICC_UTIL_H -#define SLICC_UTIL_H +#ifndef __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__ +#define __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__ -#include "mem/ruby/common/Global.hh" -#include "mem/ruby/common/Address.hh" -#include "mem/ruby/system/NodeID.hh" -#include "mem/ruby/system/MachineID.hh" +#include "mem/protocol/AccessType.hh" #include "mem/protocol/CacheMsg.hh" -#include "mem/protocol/GenericRequestType.hh" #include "mem/protocol/CacheRequestType.hh" -#include "mem/protocol/AccessType.hh" -#include "mem/protocol/MachineType.hh" #include "mem/protocol/Directory_State.hh" +#include "mem/protocol/GenericRequestType.hh" #include "mem/protocol/L1Cache_State.hh" +#include "mem/protocol/MachineType.hh" #include "mem/protocol/MessageSizeType.hh" -#include "mem/ruby/network/Network.hh" #include "mem/protocol/PrefetchBit.hh" -#include "mem/ruby/system/System.hh" - +#include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" +#include "mem/ruby/network/Network.hh" #include "mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh" +#include "mem/ruby/system/MachineID.hh" +#include "mem/ruby/system/NodeID.hh" +#include "mem/ruby/system/System.hh" class Set; class NetDest; -extern inline int random(int n) +inline int +random(int n) { return random() % n; } -extern inline bool multicast_retry() +inline bool +multicast_retry() { - if (RubySystem::getRandomization()) { - return (random() & 0x1); - } else { - return true; - } + if (RubySystem::getRandomization()) { + return (random() & 0x1); + } else { + return true; + } } -extern inline int cache_state_to_int(L1Cache_State state) +inline int +cache_state_to_int(L1Cache_State state) { - return state; + return state; } -extern inline Time get_time() +inline Time +get_time() { - return g_eventQueue_ptr->getTime(); + return g_eventQueue_ptr->getTime(); } -extern inline Time zero_time() +inline Time +zero_time() { - return 0; + return 0; } -extern inline NodeID intToID(int nodenum) +inline NodeID +intToID(int nodenum) { - NodeID id = nodenum; - return id; + NodeID id = nodenum; + return id; } -extern inline int IDToInt(NodeID id) +inline int +IDToInt(NodeID id) { - int nodenum = id; - return nodenum; + int nodenum = id; + return nodenum; } -extern inline int addressToInt(Address addr) +inline int +addressToInt(Address addr) { - return (int) addr.getLineAddress(); + return (int)addr.getLineAddress(); } -extern inline bool long_enough_ago(Time event) +inline bool +long_enough_ago(Time event) { - return ((get_time() - event) > 200); + return ((get_time() - event) > 200); } -extern inline int getAddThenMod(int addend1, int addend2, int modulus) +inline int +getAddThenMod(int addend1, int addend2, int modulus) { - return (addend1 + addend2) % modulus; + return (addend1 + addend2) % modulus; } -extern inline Time getTimeModInt(Time time, int modulus) +inline Time +getTimeModInt(Time time, int modulus) { - return time % modulus; + return time % modulus; } -extern inline Time getTimePlusInt(Time addend1, int addend2) +inline Time +getTimePlusInt(Time addend1, int addend2) { - return (Time) addend1 + addend2; + return (Time) addend1 + addend2; } -extern inline Time getTimeMinusTime(Time t1, Time t2) +inline Time +getTimeMinusTime(Time t1, Time t2) { - ASSERT(t1 >= t2); - return t1 - t2; + ASSERT(t1 >= t2); + return t1 - t2; } -extern inline Time getPreviousDelayedCycles(Time t1, Time t2) +inline Time +getPreviousDelayedCycles(Time t1, Time t2) { - if (RubySystem::getRandomization()) { // when randomizing delayed - return 0; - } else { - return getTimeMinusTime(t1, t2); - } + if (RubySystem::getRandomization()) { // when randomizing delayed + return 0; + } else { + return getTimeMinusTime(t1, t2); + } } -extern inline void WARN_ERROR_TIME(Time time) +inline void +WARN_ERROR_TIME(Time time) { - WARN_EXPR(time); + WARN_EXPR(time); } -// Return type for time_to_int is "Time" and not "int" so we get a 64-bit integer -extern inline Time time_to_int(Time time) +// Return type for time_to_int is "Time" and not "int" so we get a +// 64-bit integer +inline Time +time_to_int(Time time) { - return time; + return time; } // Appends an offset to an address -extern inline Address setOffset(Address addr, int offset) +inline Address +setOffset(Address addr, int offset) { - Address result = addr; - result.setOffset(offset); - return result; + Address result = addr; + result.setOffset(offset); + return result; } // Makes an address into a line address -extern inline Address makeLineAddress(Address addr) +inline Address +makeLineAddress(Address addr) { - Address result = addr; - result.makeLineAddress(); - return result; + Address result = addr; + result.makeLineAddress(); + return result; } -extern inline int addressOffset(Address addr) +inline int +addressOffset(Address addr) { - return addr.getOffset(); + return addr.getOffset(); } -#endif //SLICC_UTIL_H +#endif // __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__ diff --git a/src/mem/ruby/slicc_interface/RubySlicc_includes.hh b/src/mem/ruby/slicc_interface/RubySlicc_includes.hh index 76858ddba..ae98b3084 100644 --- a/src/mem/ruby/slicc_interface/RubySlicc_includes.hh +++ b/src/mem/ruby/slicc_interface/RubySlicc_includes.hh @@ -26,12 +26,12 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef RUBYSLICC_INCLUDES_H -#define RUBYSLICC_INCLUDES_H +#ifndef __MEM_RUBY_SLICC_INTERFACE_RUBYSLICC_INCLUDES_HH__ +#define __MEM_RUBY_SLICC_INTERFACE_RUBYSLICC_INCLUDES_HH__ #include "mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh" #include "mem/ruby/slicc_interface/RubySlicc_Util.hh" #include "mem/ruby/slicc_interface/RubySlicc_Profiler_interface.hh" -#endif +#endif // __MEM_RUBY_SLICC_INTERFACE_RUBYSLICC_INCLUDES_HH__ diff --git a/src/mem/ruby/system/AbstractMemOrCache.hh b/src/mem/ruby/system/AbstractMemOrCache.hh index 4a8b667e8..28b446ef8 100644 --- a/src/mem/ruby/system/AbstractMemOrCache.hh +++ b/src/mem/ruby/system/AbstractMemOrCache.hh @@ -26,42 +26,34 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * AbstractMemOrCache.hh - * - * Description: - * - * - */ - -#ifndef ABSTRACT_MEM_OR_CACHE_H -#define ABSTRACT_MEM_OR_CACHE_H - -#include "mem/ruby/common/Global.hh" -#include "mem/ruby/common/Address.hh" - -class AbstractMemOrCache { -public: - - virtual ~AbstractMemOrCache() {}; - virtual void setConsumer(Consumer* consumer_ptr) = 0; - virtual Consumer* getConsumer() = 0; - - virtual void enqueue (const MsgPtr& message, int latency ) = 0; - virtual void enqueueMemRef (MemoryNode& memRef) = 0; - virtual void dequeue () = 0; - virtual const Message* peek () = 0; - virtual bool isReady () = 0; - virtual MemoryNode peekNode () = 0; - virtual bool areNSlotsAvailable (int n) = 0; - virtual void printConfig (ostream& out) = 0; - virtual void print (ostream& out) const = 0; - virtual void setDebug (int debugFlag) = 0; - -private: - +#ifndef __MEM_RUBY_SYSTEM_ABSTRACTMEMORCACHE_HH__ +#define __MEM_RUBY_SYSTEM_ABSTRACTMEMORCACHE_HH__ + +#include <iosfwd> + +#include "mem/ruby/slicc_interface/Message.hh" + +class Consumer; +class MemoryNode; +class Message; + +class AbstractMemOrCache +{ + public: + virtual ~AbstractMemOrCache() {}; + virtual void setConsumer(Consumer* consumer_ptr) = 0; + virtual Consumer* getConsumer() = 0; + + virtual void enqueue (const MsgPtr& message, int latency) = 0; + virtual void enqueueMemRef (MemoryNode& memRef) = 0; + virtual void dequeue () = 0; + virtual const Message* peek () = 0; + virtual bool isReady () = 0; + virtual MemoryNode peekNode () = 0; + virtual bool areNSlotsAvailable (int n) = 0; + virtual void printConfig (std::ostream& out) = 0; + virtual void print (std::ostream& out) const = 0; + virtual void setDebug (int debugFlag) = 0; }; - -#endif - +#endif // __MEM_RUBY_SYSTEM_ABSTRACTMEMORCACHE_HH__ diff --git a/src/mem/ruby/system/AbstractReplacementPolicy.hh b/src/mem/ruby/system/AbstractReplacementPolicy.hh index f06b8b8ee..3ddf4ab60 100644 --- a/src/mem/ruby/system/AbstractReplacementPolicy.hh +++ b/src/mem/ruby/system/AbstractReplacementPolicy.hh @@ -26,64 +26,64 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef ABSTRACTREPLACEMENTPOLICY_H -#define ABSTRACTREPLACEMENTPOLICY_H +#ifndef __MEM_RUBY_SYSTEM_ABSTRACTREPLACEMENTPOLICY_HH__ +#define __MEM_RUBY_SYSTEM_ABSTRACTREPLACEMENTPOLICY_HH__ #include "mem/ruby/common/Global.hh" -class AbstractReplacementPolicy { - -public: - - AbstractReplacementPolicy(Index num_sets, Index assoc); - virtual ~AbstractReplacementPolicy(); +class AbstractReplacementPolicy +{ + public: + AbstractReplacementPolicy(Index num_sets, Index assoc); + virtual ~AbstractReplacementPolicy(); - /* touch a block. a.k.a. update timestamp */ - virtual void touch(Index set, Index way, Time time) = 0; + /* touch a block. a.k.a. update timestamp */ + virtual void touch(Index set, Index way, Time time) = 0; - /* returns the way to replace */ - virtual Index getVictim(Index set) const = 0; + /* returns the way to replace */ + virtual Index getVictim(Index set) const = 0; - /* get the time of the last access */ - Time getLastAccess(Index set, Index way); + /* get the time of the last access */ + Time getLastAccess(Index set, Index way); - protected: - unsigned int m_num_sets; /** total number of sets */ - unsigned int m_assoc; /** set associativity */ - Time **m_last_ref_ptr; /** timestamp of last reference */ + protected: + unsigned m_num_sets; /** total number of sets */ + unsigned m_assoc; /** set associativity */ + Time **m_last_ref_ptr; /** timestamp of last reference */ }; inline -AbstractReplacementPolicy::AbstractReplacementPolicy(Index num_sets, Index assoc) +AbstractReplacementPolicy::AbstractReplacementPolicy(Index num_sets, + Index assoc) { - m_num_sets = num_sets; - m_assoc = assoc; - m_last_ref_ptr = new Time*[m_num_sets]; - for(unsigned int i = 0; i < m_num_sets; i++){ - m_last_ref_ptr[i] = new Time[m_assoc]; - for(unsigned int j = 0; j < m_assoc; j++){ - m_last_ref_ptr[i][j] = 0; + m_num_sets = num_sets; + m_assoc = assoc; + m_last_ref_ptr = new Time*[m_num_sets]; + for(unsigned i = 0; i < m_num_sets; i++){ + m_last_ref_ptr[i] = new Time[m_assoc]; + for(unsigned j = 0; j < m_assoc; j++){ + m_last_ref_ptr[i][j] = 0; + } } - } } inline AbstractReplacementPolicy::~AbstractReplacementPolicy() { - if(m_last_ref_ptr != NULL){ - for(unsigned int i = 0; i < m_num_sets; i++){ - if(m_last_ref_ptr[i] != NULL){ - delete[] m_last_ref_ptr[i]; - } + if (m_last_ref_ptr != NULL){ + for (unsigned i = 0; i < m_num_sets; i++){ + if (m_last_ref_ptr[i] != NULL){ + delete[] m_last_ref_ptr[i]; + } + } + delete[] m_last_ref_ptr; } - delete[] m_last_ref_ptr; - } } -inline -Time AbstractReplacementPolicy::getLastAccess(Index set, Index way) +inline Time +AbstractReplacementPolicy::getLastAccess(Index set, Index way) { - return m_last_ref_ptr[set][way]; + return m_last_ref_ptr[set][way]; } -#endif // ABSTRACTREPLACEMENTPOLICY_H +#endif // __MEM_RUBY_SYSTEM_ABSTRACTREPLACEMENTPOLICY_HH__ diff --git a/src/mem/ruby/system/CacheMemory.cc b/src/mem/ruby/system/CacheMemory.cc index 35625245a..10ea8a6fc 100644 --- a/src/mem/ruby/system/CacheMemory.cc +++ b/src/mem/ruby/system/CacheMemory.cc @@ -28,19 +28,14 @@ #include "mem/ruby/system/CacheMemory.hh" -// ******************* Definitions ******************* - -// Output operator definition -ostream& operator<<(ostream& out, const CacheMemory& obj) +ostream& +operator<<(ostream& out, const CacheMemory& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } - -// **************************************************************** - CacheMemory * RubyCacheParams::create() { @@ -57,410 +52,451 @@ CacheMemory::CacheMemory(const Params *p) m_profiler_ptr = new CacheProfiler(name()); } - -void CacheMemory::init() +void +CacheMemory::init() { - m_cache_num_sets = (m_cache_size / m_cache_assoc) / RubySystem::getBlockSizeBytes(); + m_cache_num_sets = (m_cache_size / m_cache_assoc) / + RubySystem::getBlockSizeBytes(); assert(m_cache_num_sets > 1); m_cache_num_set_bits = log_int(m_cache_num_sets); assert(m_cache_num_set_bits > 0); - - if(m_policy == "PSEUDO_LRU") - m_replacementPolicy_ptr = new PseudoLRUPolicy(m_cache_num_sets, m_cache_assoc); + + if (m_policy == "PSEUDO_LRU") + m_replacementPolicy_ptr = + new PseudoLRUPolicy(m_cache_num_sets, m_cache_assoc); else if (m_policy == "LRU") - m_replacementPolicy_ptr = new LRUPolicy(m_cache_num_sets, m_cache_assoc); + m_replacementPolicy_ptr = + new LRUPolicy(m_cache_num_sets, m_cache_assoc); else - assert(false); - - m_cache.setSize(m_cache_num_sets); - m_locked.setSize(m_cache_num_sets); - for (int i = 0; i < m_cache_num_sets; i++) { - m_cache[i].setSize(m_cache_assoc); - m_locked[i].setSize(m_cache_assoc); - for (int j = 0; j < m_cache_assoc; j++) { - m_cache[i][j] = NULL; - m_locked[i][j] = -1; + assert(false); + + m_cache.setSize(m_cache_num_sets); + m_locked.setSize(m_cache_num_sets); + for (int i = 0; i < m_cache_num_sets; i++) { + m_cache[i].setSize(m_cache_assoc); + m_locked[i].setSize(m_cache_assoc); + for (int j = 0; j < m_cache_assoc; j++) { + m_cache[i][j] = NULL; + m_locked[i][j] = -1; + } } - } } CacheMemory::~CacheMemory() { - if(m_replacementPolicy_ptr != NULL) - delete m_replacementPolicy_ptr; - delete m_profiler_ptr; - for (int i = 0; i < m_cache_num_sets; i++) { - for (int j = 0; j < m_cache_assoc; j++) { - delete m_cache[i][j]; + if (m_replacementPolicy_ptr != NULL) + delete m_replacementPolicy_ptr; + delete m_profiler_ptr; + for (int i = 0; i < m_cache_num_sets; i++) { + for (int j = 0; j < m_cache_assoc; j++) { + delete m_cache[i][j]; + } } - } } -void CacheMemory::printConfig(ostream& out) +void +CacheMemory::printConfig(ostream& out) { - out << "Cache config: " << m_cache_name << endl; - out << " cache_associativity: " << m_cache_assoc << endl; - out << " num_cache_sets_bits: " << m_cache_num_set_bits << endl; - const int cache_num_sets = 1 << m_cache_num_set_bits; - out << " num_cache_sets: " << cache_num_sets << endl; - out << " cache_set_size_bytes: " << cache_num_sets * RubySystem::getBlockSizeBytes() << endl; - out << " cache_set_size_Kbytes: " - << double(cache_num_sets * RubySystem::getBlockSizeBytes()) / (1<<10) << endl; - out << " cache_set_size_Mbytes: " - << double(cache_num_sets * RubySystem::getBlockSizeBytes()) / (1<<20) << endl; - out << " cache_size_bytes: " - << cache_num_sets * RubySystem::getBlockSizeBytes() * m_cache_assoc << endl; - out << " cache_size_Kbytes: " - << double(cache_num_sets * RubySystem::getBlockSizeBytes() * m_cache_assoc) / (1<<10) << endl; - out << " cache_size_Mbytes: " - << double(cache_num_sets * RubySystem::getBlockSizeBytes() * m_cache_assoc) / (1<<20) << endl; + int block_size = RubySystem::getBlockSizeBytes(); + + out << "Cache config: " << m_cache_name << endl; + out << " cache_associativity: " << m_cache_assoc << endl; + out << " num_cache_sets_bits: " << m_cache_num_set_bits << endl; + const int cache_num_sets = 1 << m_cache_num_set_bits; + out << " num_cache_sets: " << cache_num_sets << endl; + out << " cache_set_size_bytes: " << cache_num_sets * block_size << endl; + out << " cache_set_size_Kbytes: " + << double(cache_num_sets * block_size) / (1<<10) << endl; + out << " cache_set_size_Mbytes: " + << double(cache_num_sets * block_size) / (1<<20) << endl; + out << " cache_size_bytes: " + << cache_num_sets * block_size * m_cache_assoc << endl; + out << " cache_size_Kbytes: " + << double(cache_num_sets * block_size * m_cache_assoc) / (1<<10) + << endl; + out << " cache_size_Mbytes: " + << double(cache_num_sets * block_size * m_cache_assoc) / (1<<20) + << endl; } -// PRIVATE METHODS - // convert a Address to its location in the cache -Index CacheMemory::addressToCacheSet(const Address& address) const +Index +CacheMemory::addressToCacheSet(const Address& address) const { - assert(address == line_address(address)); - return address.bitSelect(RubySystem::getBlockSizeBits(), RubySystem::getBlockSizeBits() + m_cache_num_set_bits-1); + assert(address == line_address(address)); + return address.bitSelect(RubySystem::getBlockSizeBits(), + RubySystem::getBlockSizeBits() + m_cache_num_set_bits - 1); } // Given a cache index: returns the index of the tag in a set. // returns -1 if the tag is not found. -int CacheMemory::findTagInSet(Index cacheSet, const Address& tag) const +int +CacheMemory::findTagInSet(Index cacheSet, const Address& tag) const { - assert(tag == line_address(tag)); - // search the set for the tags - m5::hash_map<Address, int>::const_iterator it = m_tag_index.find(tag); - if (it != m_tag_index.end()) - if (m_cache[cacheSet][it->second]->m_Permission != AccessPermission_NotPresent) - return it->second; - return -1; // Not found + assert(tag == line_address(tag)); + // search the set for the tags + m5::hash_map<Address, int>::const_iterator it = m_tag_index.find(tag); + if (it != m_tag_index.end()) + if (m_cache[cacheSet][it->second]->m_Permission != + AccessPermission_NotPresent) + return it->second; + return -1; // Not found } // Given a cache index: returns the index of the tag in a set. // returns -1 if the tag is not found. -int CacheMemory::findTagInSetIgnorePermissions(Index cacheSet, const Address& tag) const -{ - assert(tag == line_address(tag)); - // search the set for the tags - m5::hash_map<Address, int>::const_iterator it = m_tag_index.find(tag); - if (it != m_tag_index.end()) - return it->second; - return -1; // Not found -} - -// PUBLIC METHODS -bool CacheMemory::tryCacheAccess(const Address& address, - CacheRequestType type, - DataBlock*& data_ptr) -{ - assert(address == line_address(address)); - DEBUG_EXPR(CACHE_COMP, HighPrio, address); - Index cacheSet = addressToCacheSet(address); - int loc = findTagInSet(cacheSet, address); - if(loc != -1){ // Do we even have a tag match? - AbstractCacheEntry* entry = m_cache[cacheSet][loc]; - m_replacementPolicy_ptr->touch(cacheSet, loc, g_eventQueue_ptr->getTime()); - data_ptr = &(entry->getDataBlk()); - - if(entry->m_Permission == AccessPermission_Read_Write) { - return true; - } - if ((entry->m_Permission == AccessPermission_Read_Only) && - (type == CacheRequestType_LD || type == CacheRequestType_IFETCH)) { - return true; +int +CacheMemory::findTagInSetIgnorePermissions(Index cacheSet, + const Address& tag) const +{ + assert(tag == line_address(tag)); + // search the set for the tags + m5::hash_map<Address, int>::const_iterator it = m_tag_index.find(tag); + if (it != m_tag_index.end()) + return it->second; + return -1; // Not found +} + +bool +CacheMemory::tryCacheAccess(const Address& address, CacheRequestType type, + DataBlock*& data_ptr) +{ + assert(address == line_address(address)); + DEBUG_EXPR(CACHE_COMP, HighPrio, address); + Index cacheSet = addressToCacheSet(address); + int loc = findTagInSet(cacheSet, address); + if (loc != -1) { + // Do we even have a tag match? + AbstractCacheEntry* entry = m_cache[cacheSet][loc]; + m_replacementPolicy_ptr-> + touch(cacheSet, loc, g_eventQueue_ptr->getTime()); + data_ptr = &(entry->getDataBlk()); + + if (entry->m_Permission == AccessPermission_Read_Write) { + return true; + } + if ((entry->m_Permission == AccessPermission_Read_Only) && + (type == CacheRequestType_LD || type == CacheRequestType_IFETCH)) { + return true; + } + // The line must not be accessible } - // The line must not be accessible - } - data_ptr = NULL; - return false; + data_ptr = NULL; + return false; } -bool CacheMemory::testCacheAccess(const Address& address, - CacheRequestType type, - DataBlock*& data_ptr) +bool +CacheMemory::testCacheAccess(const Address& address, CacheRequestType type, + DataBlock*& data_ptr) { - assert(address == line_address(address)); - DEBUG_EXPR(CACHE_COMP, HighPrio, address); - Index cacheSet = addressToCacheSet(address); - int loc = findTagInSet(cacheSet, address); - if(loc != -1){ // Do we even have a tag match? - AbstractCacheEntry* entry = m_cache[cacheSet][loc]; - m_replacementPolicy_ptr->touch(cacheSet, loc, g_eventQueue_ptr->getTime()); - data_ptr = &(entry->getDataBlk()); + assert(address == line_address(address)); + DEBUG_EXPR(CACHE_COMP, HighPrio, address); + Index cacheSet = addressToCacheSet(address); + int loc = findTagInSet(cacheSet, address); + + if (loc != -1) { + // Do we even have a tag match? + AbstractCacheEntry* entry = m_cache[cacheSet][loc]; + m_replacementPolicy_ptr-> + touch(cacheSet, loc, g_eventQueue_ptr->getTime()); + data_ptr = &(entry->getDataBlk()); + + return m_cache[cacheSet][loc]->m_Permission != + AccessPermission_NotPresent; + } - return (m_cache[cacheSet][loc]->m_Permission != AccessPermission_NotPresent); - } - data_ptr = NULL; - return false; + data_ptr = NULL; + return false; } // tests to see if an address is present in the cache -bool CacheMemory::isTagPresent(const Address& address) const +bool +CacheMemory::isTagPresent(const Address& address) const { - assert(address == line_address(address)); - Index cacheSet = addressToCacheSet(address); - int location = findTagInSet(cacheSet, address); - - if (location == -1) { - // We didn't find the tag + assert(address == line_address(address)); + Index cacheSet = addressToCacheSet(address); + int loc = findTagInSet(cacheSet, address); + + if (loc == -1) { + // We didn't find the tag + DEBUG_EXPR(CACHE_COMP, LowPrio, address); + DEBUG_MSG(CACHE_COMP, LowPrio, "No tag match"); + return false; + } DEBUG_EXPR(CACHE_COMP, LowPrio, address); - DEBUG_MSG(CACHE_COMP, LowPrio, "No tag match"); - return false; - } - DEBUG_EXPR(CACHE_COMP, LowPrio, address); - DEBUG_MSG(CACHE_COMP, LowPrio, "found"); - return true; + DEBUG_MSG(CACHE_COMP, LowPrio, "found"); + return true; } // Returns true if there is: // a) a tag match on this address or there is // b) an unused line in the same cache "way" -bool CacheMemory::cacheAvail(const Address& address) const +bool +CacheMemory::cacheAvail(const Address& address) const { - assert(address == line_address(address)); - - Index cacheSet = addressToCacheSet(address); - - for (int i=0; i < m_cache_assoc; i++) { - AbstractCacheEntry* entry = m_cache[cacheSet][i]; - if (entry != NULL) { - if (entry->m_Address == address || // Already in the cache - entry->m_Permission == AccessPermission_NotPresent) { // We found an empty entry - return true; - } - } else { - return true; + assert(address == line_address(address)); + + Index cacheSet = addressToCacheSet(address); + + for (int i = 0; i < m_cache_assoc; i++) { + AbstractCacheEntry* entry = m_cache[cacheSet][i]; + if (entry != NULL) { + if (entry->m_Address == address || + entry->m_Permission == AccessPermission_NotPresent) { + // Already in the cache or we found an empty entry + return true; + } + } else { + return true; + } } - } - return false; + return false; } -void CacheMemory::allocate(const Address& address, AbstractCacheEntry* entry) +void +CacheMemory::allocate(const Address& address, AbstractCacheEntry* entry) { - assert(address == line_address(address)); - assert(!isTagPresent(address)); - assert(cacheAvail(address)); - DEBUG_EXPR(CACHE_COMP, HighPrio, address); - - // Find the first open slot - Index cacheSet = addressToCacheSet(address); - for (int i=0; i < m_cache_assoc; i++) { - if (m_cache[cacheSet][i] == NULL || - m_cache[cacheSet][i]->m_Permission == AccessPermission_NotPresent) { - m_cache[cacheSet][i] = entry; // Init entry - m_cache[cacheSet][i]->m_Address = address; - m_cache[cacheSet][i]->m_Permission = AccessPermission_Invalid; - DPRINTF(RubyCache, "Allocate clearing lock for addr: %llx\n", address); - m_locked[cacheSet][i] = -1; - m_tag_index[address] = i; - - m_replacementPolicy_ptr->touch(cacheSet, i, g_eventQueue_ptr->getTime()); - - return; + assert(address == line_address(address)); + assert(!isTagPresent(address)); + assert(cacheAvail(address)); + DEBUG_EXPR(CACHE_COMP, HighPrio, address); + + // Find the first open slot + Index cacheSet = addressToCacheSet(address); + Vector<AbstractCacheEntry*> &set = m_cache[cacheSet]; + for (int i = 0; i < m_cache_assoc; i++) { + if (!set[i] || set[i]->m_Permission == AccessPermission_NotPresent) { + set[i] = entry; // Init entry + set[i]->m_Address = address; + set[i]->m_Permission = AccessPermission_Invalid; + DPRINTF(RubyCache, "Allocate clearing lock for addr: %x\n", + address); + m_locked[cacheSet][i] = -1; + m_tag_index[address] = i; + + m_replacementPolicy_ptr-> + touch(cacheSet, i, g_eventQueue_ptr->getTime()); + + return; + } } - } - ERROR_MSG("Allocate didn't find an available entry"); + ERROR_MSG("Allocate didn't find an available entry"); } -void CacheMemory::deallocate(const Address& address) +void +CacheMemory::deallocate(const Address& address) { - assert(address == line_address(address)); - assert(isTagPresent(address)); - DEBUG_EXPR(CACHE_COMP, HighPrio, address); - Index cacheSet = addressToCacheSet(address); - int location = findTagInSet(cacheSet, address); - if (location != -1){ - delete m_cache[cacheSet][location]; - m_cache[cacheSet][location] = NULL; - DPRINTF(RubyCache, "Deallocate clearing lock for addr: %llx\n", address); - m_locked[cacheSet][location] = -1; - m_tag_index.erase(address); - } + assert(address == line_address(address)); + assert(isTagPresent(address)); + DEBUG_EXPR(CACHE_COMP, HighPrio, address); + Index cacheSet = addressToCacheSet(address); + int loc = findTagInSet(cacheSet, address); + if (loc != -1) { + delete m_cache[cacheSet][loc]; + m_cache[cacheSet][loc] = NULL; + DPRINTF(RubyCache, "Deallocate clearing lock for addr: %x\n", + address); + m_locked[cacheSet][loc] = -1; + m_tag_index.erase(address); + } } // Returns with the physical address of the conflicting cache line -Address CacheMemory::cacheProbe(const Address& address) const +Address +CacheMemory::cacheProbe(const Address& address) const { - assert(address == line_address(address)); - assert(!cacheAvail(address)); + assert(address == line_address(address)); + assert(!cacheAvail(address)); - Index cacheSet = addressToCacheSet(address); - return m_cache[cacheSet][m_replacementPolicy_ptr->getVictim(cacheSet)]->m_Address; + Index cacheSet = addressToCacheSet(address); + return m_cache[cacheSet][m_replacementPolicy_ptr->getVictim(cacheSet)]-> + m_Address; } // looks an address up in the cache -AbstractCacheEntry& CacheMemory::lookup(const Address& address) +AbstractCacheEntry& +CacheMemory::lookup(const Address& address) { - assert(address == line_address(address)); - Index cacheSet = addressToCacheSet(address); - int loc = findTagInSet(cacheSet, address); - assert(loc != -1); - return *m_cache[cacheSet][loc]; + assert(address == line_address(address)); + Index cacheSet = addressToCacheSet(address); + int loc = findTagInSet(cacheSet, address); + assert(loc != -1); + return *m_cache[cacheSet][loc]; } // looks an address up in the cache -const AbstractCacheEntry& CacheMemory::lookup(const Address& address) const +const AbstractCacheEntry& +CacheMemory::lookup(const Address& address) const { - assert(address == line_address(address)); - Index cacheSet = addressToCacheSet(address); - int loc = findTagInSet(cacheSet, address); - assert(loc != -1); - return *m_cache[cacheSet][loc]; + assert(address == line_address(address)); + Index cacheSet = addressToCacheSet(address); + int loc = findTagInSet(cacheSet, address); + assert(loc != -1); + return *m_cache[cacheSet][loc]; } -AccessPermission CacheMemory::getPermission(const Address& address) const +AccessPermission +CacheMemory::getPermission(const Address& address) const { - assert(address == line_address(address)); - return lookup(address).m_Permission; + assert(address == line_address(address)); + return lookup(address).m_Permission; } -void CacheMemory::changePermission(const Address& address, AccessPermission new_perm) +void +CacheMemory::changePermission(const Address& address, + AccessPermission new_perm) { - assert(address == line_address(address)); - lookup(address).m_Permission = new_perm; - Index cacheSet = addressToCacheSet(address); - int loc = findTagInSet(cacheSet, address); - if (new_perm != AccessPermission_Read_Write) { - DPRINTF(RubyCache, "Permission clearing lock for addr: %llx\n", address); - m_locked[cacheSet][loc] = -1; - } - assert(getPermission(address) == new_perm); + assert(address == line_address(address)); + lookup(address).m_Permission = new_perm; + Index cacheSet = addressToCacheSet(address); + int loc = findTagInSet(cacheSet, address); + if (new_perm != AccessPermission_Read_Write) { + DPRINTF(RubyCache, "Permission clearing lock for addr: %x\n", address); + m_locked[cacheSet][loc] = -1; + } + assert(getPermission(address) == new_perm); } // Sets the most recently used bit for a cache block -void CacheMemory::setMRU(const Address& address) +void +CacheMemory::setMRU(const Address& address) { - Index cacheSet; + Index cacheSet; - cacheSet = addressToCacheSet(address); - m_replacementPolicy_ptr->touch(cacheSet, - findTagInSet(cacheSet, address), - g_eventQueue_ptr->getTime()); + cacheSet = addressToCacheSet(address); + m_replacementPolicy_ptr-> + touch(cacheSet, findTagInSet(cacheSet, address), + g_eventQueue_ptr->getTime()); } -void CacheMemory::profileMiss(const CacheMsg & msg) +void +CacheMemory::profileMiss(const CacheMsg& msg) { - m_profiler_ptr->addStatSample(msg.getType(), msg.getAccessMode(), - msg.getSize(), msg.getPrefetch()); + m_profiler_ptr->addStatSample(msg.getType(), msg.getAccessMode(), + msg.getSize(), msg.getPrefetch()); } -void CacheMemory::recordCacheContents(CacheRecorder& tr) const +void +CacheMemory::recordCacheContents(CacheRecorder& tr) const { - for (int i = 0; i < m_cache_num_sets; i++) { - for (int j = 0; j < m_cache_assoc; j++) { - AccessPermission perm = m_cache[i][j]->m_Permission; - CacheRequestType request_type = CacheRequestType_NULL; - if (perm == AccessPermission_Read_Only) { - if (m_is_instruction_only_cache) { - request_type = CacheRequestType_IFETCH; - } else { - request_type = CacheRequestType_LD; + for (int i = 0; i < m_cache_num_sets; i++) { + for (int j = 0; j < m_cache_assoc; j++) { + AccessPermission perm = m_cache[i][j]->m_Permission; + CacheRequestType request_type = CacheRequestType_NULL; + if (perm == AccessPermission_Read_Only) { + if (m_is_instruction_only_cache) { + request_type = CacheRequestType_IFETCH; + } else { + request_type = CacheRequestType_LD; + } + } else if (perm == AccessPermission_Read_Write) { + request_type = CacheRequestType_ST; + } + + if (request_type != CacheRequestType_NULL) { +#if 0 + tr.addRecord(m_chip_ptr->getID(), m_cache[i][j].m_Address, + Address(0), request_type, + m_replacementPolicy_ptr->getLastAccess(i, j)); +#endif + } } - } else if (perm == AccessPermission_Read_Write) { - request_type = CacheRequestType_ST; - } - - if (request_type != CacheRequestType_NULL) { - // tr.addRecord(m_chip_ptr->getID(), m_cache[i][j].m_Address, - // Address(0), request_type, m_replacementPolicy_ptr->getLastAccess(i, j)); - } } - } -} - -void CacheMemory::print(ostream& out) const -{ - out << "Cache dump: " << m_cache_name << endl; - for (int i = 0; i < m_cache_num_sets; i++) { - for (int j = 0; j < m_cache_assoc; j++) { - if (m_cache[i][j] != NULL) { - out << " Index: " << i - << " way: " << j - << " entry: " << *m_cache[i][j] << endl; - } else { - out << " Index: " << i - << " way: " << j - << " entry: NULL" << endl; - } +} + +void +CacheMemory::print(ostream& out) const +{ + out << "Cache dump: " << m_cache_name << endl; + for (int i = 0; i < m_cache_num_sets; i++) { + for (int j = 0; j < m_cache_assoc; j++) { + if (m_cache[i][j] != NULL) { + out << " Index: " << i + << " way: " << j + << " entry: " << *m_cache[i][j] << endl; + } else { + out << " Index: " << i + << " way: " << j + << " entry: NULL" << endl; + } + } } - } } -void CacheMemory::printData(ostream& out) const +void +CacheMemory::printData(ostream& out) const { - out << "printData() not supported" << endl; + out << "printData() not supported" << endl; } -void CacheMemory::clearStats() const +void +CacheMemory::clearStats() const { - m_profiler_ptr->clearStats(); + m_profiler_ptr->clearStats(); } -void CacheMemory::printStats(ostream& out) const +void +CacheMemory::printStats(ostream& out) const { - m_profiler_ptr->printStats(out); + m_profiler_ptr->printStats(out); } -void CacheMemory::getMemoryValue(const Address& addr, char* value, - unsigned int size_in_bytes ){ - AbstractCacheEntry& entry = lookup(line_address(addr)); - unsigned int startByte = addr.getAddress() - line_address(addr).getAddress(); - for(unsigned int i=0; i<size_in_bytes; ++i){ - value[i] = entry.getDataBlk().getByte(i + startByte); - } +void +CacheMemory::getMemoryValue(const Address& addr, char* value, + unsigned size_in_bytes) +{ + AbstractCacheEntry& entry = lookup(line_address(addr)); + unsigned startByte = addr.getAddress() - line_address(addr).getAddress(); + for (unsigned i = 0; i < size_in_bytes; ++i) { + value[i] = entry.getDataBlk().getByte(i + startByte); + } } -void CacheMemory::setMemoryValue(const Address& addr, char* value, - unsigned int size_in_bytes ){ - AbstractCacheEntry& entry = lookup(line_address(addr)); - unsigned int startByte = addr.getAddress() - line_address(addr).getAddress(); - assert(size_in_bytes > 0); - for(unsigned int i=0; i<size_in_bytes; ++i){ - entry.getDataBlk().setByte(i + startByte, value[i]); - } +void +CacheMemory::setMemoryValue(const Address& addr, char* value, + unsigned size_in_bytes) +{ + AbstractCacheEntry& entry = lookup(line_address(addr)); + unsigned startByte = addr.getAddress() - line_address(addr).getAddress(); + assert(size_in_bytes > 0); + for (unsigned i = 0; i < size_in_bytes; ++i) { + entry.getDataBlk().setByte(i + startByte, value[i]); + } - // entry = lookup(line_address(addr)); + // entry = lookup(line_address(addr)); } -void -CacheMemory::setLocked(const Address& address, int context) -{ - DPRINTF(RubyCache, - "Setting Lock for addr: %llx to %d\n", - address, - context); - assert(address == line_address(address)); - Index cacheSet = addressToCacheSet(address); - int loc = findTagInSet(cacheSet, address); - assert(loc != -1); - m_locked[cacheSet][loc] = context; +void +CacheMemory::setLocked(const Address& address, int context) +{ + DPRINTF(RubyCache, "Setting Lock for addr: %x to %d\n", address, context); + assert(address == line_address(address)); + Index cacheSet = addressToCacheSet(address); + int loc = findTagInSet(cacheSet, address); + assert(loc != -1); + m_locked[cacheSet][loc] = context; } -void -CacheMemory::clearLocked(const Address& address) +void +CacheMemory::clearLocked(const Address& address) { - DPRINTF(RubyCache, "Clear Lock for addr: %llx\n", address); - assert(address == line_address(address)); - Index cacheSet = addressToCacheSet(address); - int loc = findTagInSet(cacheSet, address); - assert(loc != -1); - m_locked[cacheSet][loc] = -1; + DPRINTF(RubyCache, "Clear Lock for addr: %x\n", address); + assert(address == line_address(address)); + Index cacheSet = addressToCacheSet(address); + int loc = findTagInSet(cacheSet, address); + assert(loc != -1); + m_locked[cacheSet][loc] = -1; } bool CacheMemory::isLocked(const Address& address, int context) { - assert(address == line_address(address)); - Index cacheSet = addressToCacheSet(address); - int loc = findTagInSet(cacheSet, address); - assert(loc != -1); - DPRINTF(RubyCache, - "Testing Lock for addr: %llx cur %d con %d\n", - address, - m_locked[cacheSet][loc], - context); - return m_locked[cacheSet][loc] == context; + assert(address == line_address(address)); + Index cacheSet = addressToCacheSet(address); + int loc = findTagInSet(cacheSet, address); + assert(loc != -1); + DPRINTF(RubyCache, "Testing Lock for addr: %llx cur %d con %d\n", + address, m_locked[cacheSet][loc], context); + return m_locked[cacheSet][loc] == context; } diff --git a/src/mem/ruby/system/CacheMemory.hh b/src/mem/ruby/system/CacheMemory.hh index 74eb5d68d..bdf2bb25c 100644 --- a/src/mem/ruby/system/CacheMemory.hh +++ b/src/mem/ruby/system/CacheMemory.hh @@ -26,151 +26,144 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * CacheMemory.hh - * - * Description: - * - * $Id: CacheMemory.hh,v 3.7 2004/06/18 20:15:15 beckmann Exp $ - * - */ +#ifndef __MEM_RUBY_SYSTEM_CACHEMEMORY_HH__ +#define __MEM_RUBY_SYSTEM_CACHEMEMORY_HH__ -#ifndef CACHEMEMORY_H -#define CACHEMEMORY_H - -#include "sim/sim_object.hh" -#include "params/RubyCache.hh" +#include <vector> -#include "mem/ruby/common/Global.hh" +#include "base/hashmap.hh" +#include "mem/gems_common/Vector.hh" #include "mem/protocol/AccessPermission.hh" -#include "mem/ruby/common/Address.hh" -#include "mem/ruby/recorder/CacheRecorder.hh" +#include "mem/protocol/CacheMsg.hh" #include "mem/protocol/CacheRequestType.hh" -#include "mem/gems_common/Vector.hh" -#include "mem/ruby/common/DataBlock.hh" #include "mem/protocol/MachineType.hh" +#include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/DataBlock.hh" +#include "mem/ruby/common/Global.hh" +#include "mem/ruby/profiler/CacheProfiler.hh" +#include "mem/ruby/recorder/CacheRecorder.hh" +#include "mem/ruby/slicc_interface/AbstractCacheEntry.hh" +#include "mem/ruby/slicc_interface/AbstractController.hh" #include "mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh" -#include "mem/ruby/system/PseudoLRUPolicy.hh" #include "mem/ruby/system/LRUPolicy.hh" -#include "mem/ruby/slicc_interface/AbstractCacheEntry.hh" +#include "mem/ruby/system/PseudoLRUPolicy.hh" #include "mem/ruby/system/System.hh" -#include "mem/ruby/slicc_interface/AbstractController.hh" -#include "mem/ruby/profiler/CacheProfiler.hh" -#include "mem/protocol/CacheMsg.hh" -#include "base/hashmap.hh" -#include <vector> - -class CacheMemory : public SimObject { -public: +#include "params/RubyCache.hh" +#include "sim/sim_object.hh" +class CacheMemory : public SimObject +{ + public: typedef RubyCacheParams Params; - // Constructors - CacheMemory(const Params *p); - // CacheMemory(const string & name); - void init(); - - // Destructor - ~CacheMemory(); + CacheMemory(const Params *p); + ~CacheMemory(); - // Public Methods - void printConfig(ostream& out); + void init(); - // perform a cache access and see if we hit or not. Return true on a hit. - bool tryCacheAccess(const Address& address, CacheRequestType type, DataBlock*& data_ptr); + // Public Methods + void printConfig(ostream& out); - // similar to above, but doesn't require full access check - bool testCacheAccess(const Address& address, CacheRequestType type, DataBlock*& data_ptr); + // perform a cache access and see if we hit or not. Return true on a hit. + bool tryCacheAccess(const Address& address, CacheRequestType type, + DataBlock*& data_ptr); - // tests to see if an address is present in the cache - bool isTagPresent(const Address& address) const; + // similar to above, but doesn't require full access check + bool testCacheAccess(const Address& address, CacheRequestType type, + DataBlock*& data_ptr); - // Returns true if there is: - // a) a tag match on this address or there is - // b) an unused line in the same cache "way" - bool cacheAvail(const Address& address) const; + // tests to see if an address is present in the cache + bool isTagPresent(const Address& address) const; - // find an unused entry and sets the tag appropriate for the address - void allocate(const Address& address, AbstractCacheEntry* new_entry); + // Returns true if there is: + // a) a tag match on this address or there is + // b) an unused line in the same cache "way" + bool cacheAvail(const Address& address) const; - // Explicitly free up this address - void deallocate(const Address& address); + // find an unused entry and sets the tag appropriate for the address + void allocate(const Address& address, AbstractCacheEntry* new_entry); - // Returns with the physical address of the conflicting cache line - Address cacheProbe(const Address& address) const; + // Explicitly free up this address + void deallocate(const Address& address); - // looks an address up in the cache - AbstractCacheEntry& lookup(const Address& address); - const AbstractCacheEntry& lookup(const Address& address) const; + // Returns with the physical address of the conflicting cache line + Address cacheProbe(const Address& address) const; - // Get/Set permission of cache block - AccessPermission getPermission(const Address& address) const; - void changePermission(const Address& address, AccessPermission new_perm); + // looks an address up in the cache + AbstractCacheEntry& lookup(const Address& address); + const AbstractCacheEntry& lookup(const Address& address) const; - int getLatency() const { return m_latency; } + // Get/Set permission of cache block + AccessPermission getPermission(const Address& address) const; + void changePermission(const Address& address, AccessPermission new_perm); - // Hook for checkpointing the contents of the cache - void recordCacheContents(CacheRecorder& tr) const; - void setAsInstructionCache(bool is_icache) { m_is_instruction_only_cache = is_icache; } + int getLatency() const { return m_latency; } - // Set this address to most recently used - void setMRU(const Address& address); + // Hook for checkpointing the contents of the cache + void recordCacheContents(CacheRecorder& tr) const; + void + setAsInstructionCache(bool is_icache) + { + m_is_instruction_only_cache = is_icache; + } - void profileMiss(const CacheMsg & msg); + // Set this address to most recently used + void setMRU(const Address& address); - void getMemoryValue(const Address& addr, char* value, - unsigned int size_in_bytes ); - void setMemoryValue(const Address& addr, char* value, - unsigned int size_in_bytes ); + void profileMiss(const CacheMsg & msg); - void setLocked (const Address& addr, int context); - void clearLocked (const Address& addr); - bool isLocked (const Address& addr, int context); - // Print cache contents - void print(ostream& out) const; - void printData(ostream& out) const; + void getMemoryValue(const Address& addr, char* value, + unsigned int size_in_bytes); + void setMemoryValue(const Address& addr, char* value, + unsigned int size_in_bytes); - void clearStats() const; - void printStats(ostream& out) const; + void setLocked (const Address& addr, int context); + void clearLocked (const Address& addr); + bool isLocked (const Address& addr, int context); + // Print cache contents + void print(ostream& out) const; + void printData(ostream& out) const; -private: - // Private Methods + void clearStats() const; + void printStats(ostream& out) const; - // convert a Address to its location in the cache - Index addressToCacheSet(const Address& address) const; + private: + // convert a Address to its location in the cache + Index addressToCacheSet(const Address& address) const; - // Given a cache tag: returns the index of the tag in a set. - // returns -1 if the tag is not found. - int findTagInSet(Index line, const Address& tag) const; - int findTagInSetIgnorePermissions(Index cacheSet, const Address& tag) const; + // Given a cache tag: returns the index of the tag in a set. + // returns -1 if the tag is not found. + int findTagInSet(Index line, const Address& tag) const; + int findTagInSetIgnorePermissions(Index cacheSet, + const Address& tag) const; - // Private copy constructor and assignment operator - CacheMemory(const CacheMemory& obj); - CacheMemory& operator=(const CacheMemory& obj); + // Private copy constructor and assignment operator + CacheMemory(const CacheMemory& obj); + CacheMemory& operator=(const CacheMemory& obj); -private: - const string m_cache_name; - int m_latency; + private: + const string m_cache_name; + int m_latency; - // Data Members (m_prefix) - bool m_is_instruction_only_cache; - bool m_is_data_only_cache; + // Data Members (m_prefix) + bool m_is_instruction_only_cache; + bool m_is_data_only_cache; - // The first index is the # of cache lines. - // The second index is the the amount associativity. - m5::hash_map<Address, int> m_tag_index; - Vector<Vector<AbstractCacheEntry*> > m_cache; - Vector<Vector<int> > m_locked; + // The first index is the # of cache lines. + // The second index is the the amount associativity. + m5::hash_map<Address, int> m_tag_index; + Vector<Vector<AbstractCacheEntry*> > m_cache; + Vector<Vector<int> > m_locked; - AbstractReplacementPolicy *m_replacementPolicy_ptr; + AbstractReplacementPolicy *m_replacementPolicy_ptr; - CacheProfiler* m_profiler_ptr; + CacheProfiler* m_profiler_ptr; - int m_cache_size; - string m_policy; - int m_cache_num_sets; - int m_cache_num_set_bits; - int m_cache_assoc; + int m_cache_size; + string m_policy; + int m_cache_num_sets; + int m_cache_num_set_bits; + int m_cache_assoc; }; -#endif //CACHEMEMORY_H +#endif // __MEM_RUBY_SYSTEM_CACHEMEMORY_HH__ diff --git a/src/mem/ruby/system/DMASequencer.cc b/src/mem/ruby/system/DMASequencer.cc index 063b66862..315dab62a 100644 --- a/src/mem/ruby/system/DMASequencer.cc +++ b/src/mem/ruby/system/DMASequencer.cc @@ -26,149 +26,148 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "mem/ruby/system/DMASequencer.hh" -#include "mem/ruby/buffers/MessageBuffer.hh" -#include "mem/ruby/slicc_interface/AbstractController.hh" - -/* SLICC generated types */ #include "mem/protocol/SequencerMsg.hh" #include "mem/protocol/SequencerRequestType.hh" +#include "mem/ruby/buffers/MessageBuffer.hh" +#include "mem/ruby/slicc_interface/AbstractController.hh" +#include "mem/ruby/system/DMASequencer.hh" #include "mem/ruby/system/System.hh" -// -// Fix me: This code needs comments! -// - DMASequencer::DMASequencer(const Params *p) - : RubyPort(p) + : RubyPort(p) { } -void DMASequencer::init() +void +DMASequencer::init() { - RubyPort::init(); - m_is_busy = false; - m_data_block_mask = ~ (~0 << RubySystem::getBlockSizeBits()); + RubyPort::init(); + m_is_busy = false; + m_data_block_mask = ~ (~0 << RubySystem::getBlockSizeBits()); } -RequestStatus DMASequencer::makeRequest(const RubyRequest & request) +RequestStatus +DMASequencer::makeRequest(const RubyRequest &request) { - uint64_t paddr = request.paddr; - uint8_t* data = request.data; - int len = request.len; - bool write = false; - switch(request.type) { - case RubyRequestType_LD: - write = false; - break; - case RubyRequestType_ST: - write = true; - break; - case RubyRequestType_NULL: - case RubyRequestType_IFETCH: - case RubyRequestType_Locked_Read: - case RubyRequestType_Locked_Write: - case RubyRequestType_RMW_Read: - case RubyRequestType_RMW_Write: - case RubyRequestType_NUM: - panic("DMASequencer::makeRequest does not support the RubyRequestType"); - return RequestStatus_NULL; - } - - assert(!m_is_busy); // only support one outstanding DMA request - m_is_busy = true; - - active_request.start_paddr = paddr; - active_request.write = write; - active_request.data = data; - active_request.len = len; - active_request.bytes_completed = 0; - 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; - int offset = paddr & m_data_block_mask; - - msg.getLen() = (offset + len) <= RubySystem::getBlockSizeBytes() ? - len : - RubySystem::getBlockSizeBytes() - offset; - - if (write) { - 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(); - - return RequestStatus_Issued; + uint64_t paddr = request.paddr; + uint8_t* data = request.data; + int len = request.len; + bool write = false; + switch(request.type) { + case RubyRequestType_LD: + write = false; + break; + case RubyRequestType_ST: + write = true; + break; + case RubyRequestType_NULL: + case RubyRequestType_IFETCH: + case RubyRequestType_Locked_Read: + case RubyRequestType_Locked_Write: + case RubyRequestType_RMW_Read: + case RubyRequestType_RMW_Write: + case RubyRequestType_NUM: + panic("DMASequencer::makeRequest does not support RubyRequestType"); + return RequestStatus_NULL; + } + + assert(!m_is_busy); // only support one outstanding DMA request + m_is_busy = true; + + active_request.start_paddr = paddr; + active_request.write = write; + active_request.data = data; + active_request.len = len; + active_request.bytes_completed = 0; + 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; + int offset = paddr & m_data_block_mask; + + msg.getLen() = (offset + len) <= RubySystem::getBlockSizeBytes() ? + len : RubySystem::getBlockSizeBytes() - offset; + + if (write) { + 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(); + + return RequestStatus_Issued; } -void DMASequencer::issueNext() +void +DMASequencer::issueNext() { - assert(m_is_busy == true); - active_request.bytes_completed = active_request.bytes_issued; - if (active_request.len == active_request.bytes_completed) { - ruby_hit_callback(active_request.pkt); - m_is_busy = false; - return; - } - - SequencerMsg msg; - 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()); - - msg.getType() = (active_request.write ? SequencerRequestType_ST : - SequencerRequestType_LD); - - 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().setData(&active_request.data[active_request.bytes_completed], - 0, msg.getLen()); - msg.getType() = SequencerRequestType_ST; - } else { - msg.getType() = SequencerRequestType_LD; - } - - assert(m_mandatory_q_ptr != NULL); - m_mandatory_q_ptr->enqueue(msg); - active_request.bytes_issued += msg.getLen(); + assert(m_is_busy == true); + active_request.bytes_completed = active_request.bytes_issued; + if (active_request.len == active_request.bytes_completed) { + ruby_hit_callback(active_request.pkt); + m_is_busy = false; + return; + } + + SequencerMsg msg; + 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()); + + msg.getType() = (active_request.write ? SequencerRequestType_ST : + SequencerRequestType_LD); + + 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(). + setData(&active_request.data[active_request.bytes_completed], + 0, msg.getLen()); + msg.getType() = SequencerRequestType_ST; + } else { + msg.getType() = SequencerRequestType_LD; + } + + assert(m_mandatory_q_ptr != NULL); + m_mandatory_q_ptr->enqueue(msg); + active_request.bytes_issued += msg.getLen(); } -void DMASequencer::dataCallback(const DataBlock & dblk) +void +DMASequencer::dataCallback(const DataBlock & dblk) { - assert(m_is_busy == true); - int len = active_request.bytes_issued - active_request.bytes_completed; - int offset = 0; - if (active_request.bytes_completed == 0) - offset = active_request.start_paddr & m_data_block_mask; - assert( active_request.write == false ); - memcpy(&active_request.data[active_request.bytes_completed], - dblk.getData(offset, len), len); - issueNext(); + assert(m_is_busy == true); + int len = active_request.bytes_issued - active_request.bytes_completed; + int offset = 0; + if (active_request.bytes_completed == 0) + offset = active_request.start_paddr & m_data_block_mask; + assert(active_request.write == false); + memcpy(&active_request.data[active_request.bytes_completed], + dblk.getData(offset, len), len); + issueNext(); } -void DMASequencer::ackCallback() +void +DMASequencer::ackCallback() { - issueNext(); + issueNext(); } -void DMASequencer::printConfig(ostream & out) +void +DMASequencer::printConfig(ostream & out) { - } - DMASequencer * DMASequencerParams::create() { diff --git a/src/mem/ruby/system/DMASequencer.hh b/src/mem/ruby/system/DMASequencer.hh index 24129526a..61d7ef1c6 100644 --- a/src/mem/ruby/system/DMASequencer.hh +++ b/src/mem/ruby/system/DMASequencer.hh @@ -26,48 +26,50 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef DMASEQUENCER_H -#define DMASEQUENCER_H +#ifndef __MEM_RUBY_SYSTEM_DMASEQUENCER_HH__ +#define __MEM_RUBY_SYSTEM_DMASEQUENCER_HH__ #include <ostream> + #include "mem/ruby/common/DataBlock.hh" #include "mem/ruby/system/RubyPort.hh" - #include "params/DMASequencer.hh" -struct DMARequest { - uint64_t start_paddr; - int len; - bool write; - int bytes_completed; - int bytes_issued; - uint8* data; - PacketPtr pkt; +struct DMARequest +{ + uint64_t start_paddr; + int len; + bool write; + int bytes_completed; + int bytes_issued; + uint8* data; + PacketPtr pkt; }; -class DMASequencer :public RubyPort { -public: +class DMASequencer : public RubyPort +{ + public: typedef DMASequencerParams Params; - DMASequencer(const Params *); - void init(); - /* external interface */ - RequestStatus makeRequest(const RubyRequest & request); - bool busy() { return m_is_busy;} + DMASequencer(const Params *); + void init(); + /* external interface */ + RequestStatus makeRequest(const RubyRequest & request); + bool busy() { return m_is_busy;} - /* SLICC callback */ - void dataCallback(const DataBlock & dblk); - void ackCallback(); + /* SLICC callback */ + void dataCallback(const DataBlock & dblk); + void ackCallback(); - void printConfig(std::ostream & out); + void printConfig(std::ostream & out); -private: - void issueNext(); + private: + void issueNext(); -private: - bool m_is_busy; - uint64_t m_data_block_mask; - DMARequest active_request; - int num_active_requests; + private: + bool m_is_busy; + uint64_t m_data_block_mask; + DMARequest active_request; + int num_active_requests; }; -#endif // DMACONTROLLER_H +#endif // __MEM_RUBY_SYSTEM_DMASEQUENCER_HH__ diff --git a/src/mem/ruby/system/DirectoryMemory.cc b/src/mem/ruby/system/DirectoryMemory.cc index d8037aec1..93f537090 100644 --- a/src/mem/ruby/system/DirectoryMemory.cc +++ b/src/mem/ruby/system/DirectoryMemory.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,19 +26,10 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * DirectoryMemory.cc - * - * Description: See DirectoryMemory.hh - * - * $Id$ - * - */ - -#include "mem/ruby/system/System.hh" -#include "mem/ruby/system/DirectoryMemory.hh" -#include "mem/ruby/slicc_interface/RubySlicc_Util.hh" #include "mem/gems_common/util.hh" +#include "mem/ruby/slicc_interface/RubySlicc_Util.hh" +#include "mem/ruby/system/DirectoryMemory.hh" +#include "mem/ruby/system/System.hh" int DirectoryMemory::m_num_directories = 0; int DirectoryMemory::m_num_directories_bits = 0; @@ -58,89 +48,95 @@ DirectoryMemory::DirectoryMemory(const Params *p) m_numa_high_bit = p->numa_high_bit; } -void DirectoryMemory::init() +void +DirectoryMemory::init() { - m_num_entries = m_size_bytes / RubySystem::getBlockSizeBytes(); - - if (m_use_map) { - int entry_bits = log_int(m_num_entries); - assert(entry_bits >= m_map_levels); - m_sparseMemory = new SparseMemory(entry_bits, m_map_levels); - } else { - m_entries = new Directory_Entry*[m_num_entries]; - for (int i=0; i < m_num_entries; i++) - m_entries[i] = NULL; - m_ram = g_system_ptr->getMemoryVector(); - } - - m_num_directories++; - m_num_directories_bits = log_int(m_num_directories); - m_total_size_bytes += m_size_bytes; - - if (m_numa_high_bit == 0) { - m_numa_high_bit = RubySystem::getMemorySizeBits(); - } - assert(m_numa_high_bit != 0); + m_num_entries = m_size_bytes / RubySystem::getBlockSizeBytes(); + + if (m_use_map) { + int entry_bits = log_int(m_num_entries); + assert(entry_bits >= m_map_levels); + m_sparseMemory = new SparseMemory(entry_bits, m_map_levels); + } else { + m_entries = new Directory_Entry*[m_num_entries]; + for (int i = 0; i < m_num_entries; i++) + m_entries[i] = NULL; + m_ram = g_system_ptr->getMemoryVector(); + } + + m_num_directories++; + m_num_directories_bits = log_int(m_num_directories); + m_total_size_bytes += m_size_bytes; + + if (m_numa_high_bit == 0) { + m_numa_high_bit = RubySystem::getMemorySizeBits(); + } + assert(m_numa_high_bit != 0); } DirectoryMemory::~DirectoryMemory() { - // free up all the directory entries - if (m_entries != NULL) { - for (uint64 i = 0; i < m_num_entries; i++) { - if (m_entries[i] != NULL) { - delete m_entries[i]; - } - } - delete [] m_entries; - } else if (m_use_map) { - delete m_sparseMemory; - } + // free up all the directory entries + if (m_entries != NULL) { + for (uint64 i = 0; i < m_num_entries; i++) { + if (m_entries[i] != NULL) { + delete m_entries[i]; + } + } + delete [] m_entries; + } else if (m_use_map) { + delete m_sparseMemory; + } } -void DirectoryMemory::printConfig(ostream& out) const +void +DirectoryMemory::printConfig(ostream& out) const { - out << "DirectoryMemory module config: " << m_name << endl; - out << " version: " << m_version << endl; - out << " memory_bits: " << m_size_bits << endl; - out << " memory_size_bytes: " << m_size_bytes << endl; - out << " memory_size_Kbytes: " << double(m_size_bytes) / (1<<10) << endl; - out << " memory_size_Mbytes: " << double(m_size_bytes) / (1<<20) << endl; - out << " memory_size_Gbytes: " << double(m_size_bytes) / (1<<30) << endl; + out << "DirectoryMemory module config: " << m_name << endl + << " version: " << m_version << endl + << " memory_bits: " << m_size_bits << endl + << " memory_size_bytes: " << m_size_bytes << endl + << " memory_size_Kbytes: " << double(m_size_bytes) / (1<<10) << endl + << " memory_size_Mbytes: " << double(m_size_bytes) / (1<<20) << endl + << " memory_size_Gbytes: " << double(m_size_bytes) / (1<<30) << endl; } // Static method -void DirectoryMemory::printGlobalConfig(ostream & out) +void +DirectoryMemory::printGlobalConfig(ostream & out) { - out << "DirectoryMemory Global Config: " << endl; - out << " number of directory memories: " << m_num_directories << endl; - if (m_num_directories > 1) { - out << " number of selection bits: " << m_num_directories_bits << endl; - out << " selection bits: " << m_numa_high_bit - << "-" << m_numa_high_bit-m_num_directories_bits - << endl; - } - out << " total memory size bytes: " << m_total_size_bytes << endl; - out << " total memory bits: " << log_int(m_total_size_bytes) << endl; - + out << "DirectoryMemory Global Config: " << endl; + out << " number of directory memories: " << m_num_directories << endl; + if (m_num_directories > 1) { + out << " number of selection bits: " << m_num_directories_bits << endl + << " selection bits: " << m_numa_high_bit + << "-" << m_numa_high_bit-m_num_directories_bits + << endl; + } + out << " total memory size bytes: " << m_total_size_bytes << endl; + out << " total memory bits: " << log_int(m_total_size_bytes) << endl; } -uint64 DirectoryMemory::mapAddressToDirectoryVersion(PhysAddress address) +uint64 +DirectoryMemory::mapAddressToDirectoryVersion(PhysAddress address) { - if (m_num_directories_bits == 0) return 0; - uint64 ret = address.bitSelect(m_numa_high_bit - m_num_directories_bits, - m_numa_high_bit); - return ret; + if (m_num_directories_bits == 0) + return 0; + + uint64 ret = address.bitSelect(m_numa_high_bit - m_num_directories_bits, + m_numa_high_bit); + return ret; } -// Public method -bool DirectoryMemory::isPresent(PhysAddress address) +bool +DirectoryMemory::isPresent(PhysAddress address) { - bool ret = (mapAddressToDirectoryVersion(address) == m_version); - return ret; + bool ret = (mapAddressToDirectoryVersion(address) == m_version); + return ret; } -uint64 DirectoryMemory::mapAddressToLocalIdx(PhysAddress address) +uint64 +DirectoryMemory::mapAddressToLocalIdx(PhysAddress address) { uint64 ret = address.bitRemove(m_numa_high_bit - m_num_directories_bits, m_numa_high_bit) @@ -148,98 +144,99 @@ uint64 DirectoryMemory::mapAddressToLocalIdx(PhysAddress address) return ret; } -Directory_Entry& DirectoryMemory::lookup(PhysAddress address) +Directory_Entry& +DirectoryMemory::lookup(PhysAddress address) { - assert(isPresent(address)); - Directory_Entry* entry; - uint64 idx; - DEBUG_EXPR(CACHE_COMP, HighPrio, address); - - if (m_use_map) { - if (m_sparseMemory->exist(address)) { - entry = m_sparseMemory->lookup(address); - assert(entry != NULL); - } else { - // - // Note: SparseMemory internally creates a new Directory Entry - // - m_sparseMemory->add(address); - entry = m_sparseMemory->lookup(address); - } - } else { - idx = mapAddressToLocalIdx(address); - assert(idx < m_num_entries); - entry = m_entries[idx]; + assert(isPresent(address)); + Directory_Entry* entry; + uint64 idx; + DEBUG_EXPR(CACHE_COMP, HighPrio, address); - if (entry == NULL) { - entry = new Directory_Entry(); - entry->getDataBlk().assign(m_ram->getBlockPtr(address)); - m_entries[idx] = entry; + if (m_use_map) { + if (m_sparseMemory->exist(address)) { + entry = m_sparseMemory->lookup(address); + assert(entry != NULL); + } else { + // Note: SparseMemory internally creates a new Directory Entry + m_sparseMemory->add(address); + entry = m_sparseMemory->lookup(address); + } + } else { + idx = mapAddressToLocalIdx(address); + assert(idx < m_num_entries); + entry = m_entries[idx]; + + if (entry == NULL) { + entry = new Directory_Entry(); + entry->getDataBlk().assign(m_ram->getBlockPtr(address)); + m_entries[idx] = entry; + } } - } - return (*entry); -} -/* -Directory_Entry& DirectoryMemory::lookup(PhysAddress address) -{ - assert(isPresent(address)); - Index index = address.memoryModuleIndex(); - - if (index < 0 || index > m_size) { - WARN_EXPR(address.getAddress()); - WARN_EXPR(index); - WARN_EXPR(m_size); - ERROR_MSG("Directory Memory Assertion: accessing memory out of range."); - } - Directory_Entry* entry = m_entries[index]; - - // allocate the directory entry on demand. - if (entry == NULL) { - entry = new Directory_Entry; - entry->getDataBlk().assign(m_ram->getBlockPtr(address)); - - // store entry to the table - m_entries[index] = entry; - } - - return (*entry); + return *entry; } -*/ -void DirectoryMemory::invalidateBlock(PhysAddress address) +#if 0 +Directory_Entry& +DirectoryMemory::lookup(PhysAddress address) { - - if (m_use_map) { - assert(m_sparseMemory->exist(address)); - m_sparseMemory->remove(address); - } - /* - else { assert(isPresent(address)); - Index index = address.memoryModuleIndex(); - + if (index < 0 || index > m_size) { - ERROR_MSG("Directory Memory Assertion: accessing memory out of range."); + WARN_EXPR(address.getAddress()); + WARN_EXPR(index); + WARN_EXPR(m_size); + ERROR_MSG("Directory Memory Assertion: accessing memory out of range"); } + Directory_Entry* entry = m_entries[index]; - if(m_entries[index] != NULL){ - delete m_entries[index]; - m_entries[index] = NULL; - } - } - */ + // allocate the directory entry on demand. + if (entry == NULL) { + entry = new Directory_Entry; + entry->getDataBlk().assign(m_ram->getBlockPtr(address)); + // store entry to the table + m_entries[index] = entry; + } + return *entry; } +#endif -void DirectoryMemory::print(ostream& out) const +void +DirectoryMemory::invalidateBlock(PhysAddress address) { + if (m_use_map) { + assert(m_sparseMemory->exist(address)); + m_sparseMemory->remove(address); + } +#if 0 + else { + assert(isPresent(address)); + + Index index = address.memoryModuleIndex(); + + if (index < 0 || index > m_size) { + ERROR_MSG("Directory Memory Assertion: " + "accessing memory out of range."); + } + + if (m_entries[index] != NULL){ + delete m_entries[index]; + m_entries[index] = NULL; + } + } +#endif +} +void +DirectoryMemory::print(ostream& out) const +{ } -void DirectoryMemory::printStats(ostream& out) const +void +DirectoryMemory::printStats(ostream& out) const { if (m_use_map) { m_sparseMemory->printStats(out); diff --git a/src/mem/ruby/system/DirectoryMemory.hh b/src/mem/ruby/system/DirectoryMemory.hh index 8b23ced02..4e7bfc4f6 100644 --- a/src/mem/ruby/system/DirectoryMemory.hh +++ b/src/mem/ruby/system/DirectoryMemory.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,94 +26,74 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * DirectoryMemory.hh - * - * Description: - * - * $Id$ - * - */ - -#ifndef DIRECTORYMEMORY_H -#define DIRECTORYMEMORY_H +#ifndef __MEM_RUBY_SYSTEM_DIRECTORYMEMORY_HH__ +#define __MEM_RUBY_SYSTEM_DIRECTORYMEMORY_HH__ -#include "mem/ruby/common/Global.hh" +#include "mem/protocol/Directory_Entry.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/system/MemoryVector.hh" -#include "mem/protocol/Directory_Entry.hh" -#include "sim/sim_object.hh" -#include "params/RubyDirectoryMemory.hh" #include "mem/ruby/system/SparseMemory.hh" +#include "params/RubyDirectoryMemory.hh" +#include "sim/sim_object.hh" -class DirectoryMemory : public SimObject { -public: - // Constructors +class DirectoryMemory : public SimObject +{ + public: typedef RubyDirectoryMemoryParams Params; DirectoryMemory(const Params *p); - void init(); - // DirectoryMemory(int version); - - // Destructor - ~DirectoryMemory(); - - uint64 mapAddressToLocalIdx(PhysAddress address); - static uint64 mapAddressToDirectoryVersion(PhysAddress address); - - bool isSparseImplementation() { return m_use_map; } - uint64 getSize() { return m_size_bytes; } - - // Public Methods - void printConfig(ostream& out) const; - static void printGlobalConfig(ostream & out); - bool isPresent(PhysAddress address); - Directory_Entry& lookup(PhysAddress address); - - void invalidateBlock(PhysAddress address); - - void print(ostream& out) const; - void printStats(ostream& out) const; - -private: - // Private Methods - - // Private copy constructor and assignment operator - DirectoryMemory(const DirectoryMemory& obj); - DirectoryMemory& operator=(const DirectoryMemory& obj); - -private: - const string m_name; - // Data Members (m_ prefix) - Directory_Entry **m_entries; - // int m_size; // # of memory module blocks this directory is responsible for - uint64 m_size_bytes; - uint64 m_size_bits; - uint64 m_num_entries; - int m_version; - - static int m_num_directories; - static int m_num_directories_bits; - static uint64_t m_total_size_bytes; - static int m_numa_high_bit; - - MemoryVector* m_ram; - SparseMemory* m_sparseMemory; - bool m_use_map; - int m_map_levels; + ~DirectoryMemory(); + + void init(); + + uint64 mapAddressToLocalIdx(PhysAddress address); + static uint64 mapAddressToDirectoryVersion(PhysAddress address); + + bool isSparseImplementation() { return m_use_map; } + uint64 getSize() { return m_size_bytes; } + + void printConfig(ostream& out) const; + static void printGlobalConfig(ostream & out); + bool isPresent(PhysAddress address); + Directory_Entry& lookup(PhysAddress address); + + void invalidateBlock(PhysAddress address); + + void print(ostream& out) const; + void printStats(ostream& out) const; + + private: + // Private copy constructor and assignment operator + DirectoryMemory(const DirectoryMemory& obj); + DirectoryMemory& operator=(const DirectoryMemory& obj); + + private: + const string m_name; + Directory_Entry **m_entries; + // int m_size; // # of memory module blocks this directory is + // responsible for + uint64 m_size_bytes; + uint64 m_size_bits; + uint64 m_num_entries; + int m_version; + + static int m_num_directories; + static int m_num_directories_bits; + static uint64_t m_total_size_bytes; + static int m_numa_high_bit; + + MemoryVector* m_ram; + SparseMemory* m_sparseMemory; + bool m_use_map; + int m_map_levels; }; -// Output operator declaration -ostream& operator<<(ostream& out, const DirectoryMemory& obj); - -// ******************* Definitions ******************* - -// Output operator definition -extern inline -ostream& operator<<(ostream& out, const DirectoryMemory& obj) +inline ostream& +operator<<(ostream& out, const DirectoryMemory& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } -#endif //DIRECTORYMEMORY_H +#endif // __MEM_RUBY_SYSTEM_DIRECTORYMEMORY_HH__ diff --git a/src/mem/ruby/system/LRUPolicy.hh b/src/mem/ruby/system/LRUPolicy.hh index 55b1eec6e..b1b9d7478 100644 --- a/src/mem/ruby/system/LRUPolicy.hh +++ b/src/mem/ruby/system/LRUPolicy.hh @@ -26,26 +26,26 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef LRUPOLICY_H -#define LRUPOLICY_H +#ifndef __MEM_RUBY_SYSTEM_LRUPOLICY_HH__ +#define __MEM_RUBY_SYSTEM_LRUPOLICY_HH__ #include "mem/ruby/system/AbstractReplacementPolicy.hh" /* Simple true LRU replacement policy */ -class LRUPolicy : public AbstractReplacementPolicy { - public: - - LRUPolicy(Index num_sets, Index assoc); - ~LRUPolicy(); +class LRUPolicy : public AbstractReplacementPolicy +{ + public: + LRUPolicy(Index num_sets, Index assoc); + ~LRUPolicy(); - void touch(Index set, Index way, Time time); - Index getVictim(Index set) const; + void touch(Index set, Index way, Time time); + Index getVictim(Index set) const; }; inline LRUPolicy::LRUPolicy(Index num_sets, Index assoc) - : AbstractReplacementPolicy(num_sets, assoc) + : AbstractReplacementPolicy(num_sets, assoc) { } @@ -54,39 +54,42 @@ LRUPolicy::~LRUPolicy() { } -inline -void LRUPolicy::touch(Index set, Index index, Time time){ - assert(index >= 0 && index < m_assoc); - assert(set >= 0 && set < m_num_sets); +inline void +LRUPolicy::touch(Index set, Index index, Time time) +{ + assert(index >= 0 && index < m_assoc); + assert(set >= 0 && set < m_num_sets); - m_last_ref_ptr[set][index] = time; + m_last_ref_ptr[set][index] = time; } -inline -Index LRUPolicy::getVictim(Index set) const { - // assert(m_assoc != 0); - Time time, smallest_time; - Index smallest_index; - - smallest_index = 0; - smallest_time = m_last_ref_ptr[set][0]; - - for (unsigned int i=0; i < m_assoc; i++) { - time = m_last_ref_ptr[set][i]; - //assert(m_cache[cacheSet][i].m_Permission != AccessPermission_NotPresent); - - if (time < smallest_time){ - smallest_index = i; - smallest_time = time; +inline Index +LRUPolicy::getVictim(Index set) const +{ + // assert(m_assoc != 0); + Time time, smallest_time; + Index smallest_index; + + smallest_index = 0; + smallest_time = m_last_ref_ptr[set][0]; + + for (unsigned i = 0; i < m_assoc; i++) { + time = m_last_ref_ptr[set][i]; + // assert(m_cache[cacheSet][i].m_Permission != + // AccessPermission_NotPresent); + + if (time < smallest_time) { + smallest_index = i; + smallest_time = time; + } } - } - // DEBUG_EXPR(CACHE_COMP, MedPrio, cacheSet); - // DEBUG_EXPR(CACHE_COMP, MedPrio, smallest_index); - // DEBUG_EXPR(CACHE_COMP, MedPrio, m_cache[cacheSet][smallest_index]); - // DEBUG_EXPR(CACHE_COMP, MedPrio, *this); + // DEBUG_EXPR(CACHE_COMP, MedPrio, cacheSet); + // DEBUG_EXPR(CACHE_COMP, MedPrio, smallest_index); + // DEBUG_EXPR(CACHE_COMP, MedPrio, m_cache[cacheSet][smallest_index]); + // DEBUG_EXPR(CACHE_COMP, MedPrio, *this); - return smallest_index; + return smallest_index; } -#endif // PSEUDOLRUBITS_H +#endif // __MEM_RUBY_SYSTEM_LRUPOLICY_HH__ diff --git a/src/mem/ruby/system/MachineID.hh b/src/mem/ruby/system/MachineID.hh index 9da71f349..716196248 100644 --- a/src/mem/ruby/system/MachineID.hh +++ b/src/mem/ruby/system/MachineID.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,66 +26,55 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * NodeID.hh - * - * Description: - * - * $Id$ - * - */ - -#ifndef MACHINEID_H -#define MACHINEID_H +#ifndef __MEM_RUBY_SYSTEM_MACHINEID_HH__ +#define __MEM_RUBY_SYSTEM_MACHINEID_HH__ #include <iostream> #include <string> -#include "mem/ruby/common/Global.hh" #include "mem/gems_common/util.hh" #include "mem/protocol/MachineType.hh" +#include "mem/ruby/common/Global.hh" -struct MachineID { - MachineType type; - int num; // range: 0 ... number of this machine's components in the system - 1 +struct MachineID +{ + MachineType type; + int num; // range: 0 ... number of this machine's components in system - 1 }; -extern inline -std::string MachineIDToString (MachineID machine) { - return MachineType_to_string(machine.type)+"_"+int_to_string(machine.num); +inline std::string +MachineIDToString(MachineID machine) +{ + return MachineType_to_string(machine.type)+"_"+int_to_string(machine.num); } -extern inline -bool operator==(const MachineID & obj1, const MachineID & obj2) +inline bool +operator==(const MachineID & obj1, const MachineID & obj2) { - return (obj1.type == obj2.type && obj1.num == obj2.num); + return (obj1.type == obj2.type && obj1.num == obj2.num); } -extern inline -bool operator!=(const MachineID & obj1, const MachineID & obj2) +inline bool +operator!=(const MachineID & obj1, const MachineID & obj2) { - return (obj1.type != obj2.type || obj1.num != obj2.num); + return (obj1.type != obj2.type || obj1.num != obj2.num); } // Output operator declaration std::ostream& operator<<(std::ostream& out, const MachineID& obj); -// ******************* Definitions ******************* - -// Output operator definition -extern inline -std::ostream& operator<<(std::ostream& out, const MachineID& obj) +inline std::ostream& +operator<<(std::ostream& out, const MachineID& obj) { - if ((obj.type < MachineType_NUM) && (obj.type >= MachineType_FIRST)) { - out << MachineType_to_string(obj.type); - } else { - out << "NULL"; - } - out << "-"; - out << obj.num; - out << std::flush; - return out; + if ((obj.type < MachineType_NUM) && (obj.type >= MachineType_FIRST)) { + out << MachineType_to_string(obj.type); + } else { + out << "NULL"; + } + out << "-"; + out << obj.num; + out << std::flush; + return out; } - -#endif //MACHINEID_H +#endif // __MEM_RUBY_SYSTEM_MACHINEID_HH__ diff --git a/src/mem/ruby/system/MemoryControl.cc b/src/mem/ruby/system/MemoryControl.cc index 0f12efc36..963cc3947 100644 --- a/src/mem/ruby/system/MemoryControl.cc +++ b/src/mem/ruby/system/MemoryControl.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -28,8 +27,6 @@ */ /* - * MemoryControl.cc - * * Description: This module simulates a basic DDR-style memory controller * (and can easily be extended to do FB-DIMM as well). * @@ -105,25 +102,21 @@ * then no more than four activates may happen within any 16 cycle window. * Refreshes are included in the activates. * - * - * $Id: $ - * */ -#include "mem/ruby/common/Global.hh" +#include <list> + +#include "base/cprintf.hh" #include "mem/gems_common/Map.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Consumer.hh" +#include "mem/ruby/common/Global.hh" +#include "mem/ruby/network/Network.hh" #include "mem/ruby/profiler/Profiler.hh" -#include "mem/ruby/system/System.hh" -#include "mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh" #include "mem/ruby/slicc_interface/NetworkMessage.hh" -#include "mem/ruby/network/Network.hh" - -#include "mem/ruby/common/Consumer.hh" - +#include "mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh" #include "mem/ruby/system/MemoryControl.hh" - -#include <list> +#include "mem/ruby/system/System.hh" class Consumer; @@ -140,11 +133,12 @@ class Consumer; // Output operator definition -ostream& operator<<(ostream& out, const MemoryControl& obj) +ostream& +operator<<(ostream& out, const MemoryControl& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } @@ -178,471 +172,509 @@ MemoryControl::MemoryControl(const Params *p) m_dimms_per_channel); } -void MemoryControl::init() +void +MemoryControl::init() { - m_msg_counter = 0; - - m_debug = 0; - - assert(m_tFaw <= 62); // must fit in a uint64 shift register - - m_total_banks = m_banks_per_rank * m_ranks_per_dimm * m_dimms_per_channel; - m_total_ranks = m_ranks_per_dimm * m_dimms_per_channel; - m_refresh_period_system = m_refresh_period / m_total_banks; - - m_bankQueues = new list<MemoryNode> [m_total_banks]; - assert(m_bankQueues); - - m_bankBusyCounter = new int [m_total_banks]; - assert(m_bankBusyCounter); - - m_oldRequest = new int [m_total_banks]; - assert(m_oldRequest); - - for (int i=0; i<m_total_banks; i++) { - m_bankBusyCounter[i] = 0; - m_oldRequest[i] = 0; - } - - m_busBusyCounter_Basic = 0; - m_busBusyCounter_Write = 0; - m_busBusyCounter_ReadNewRank = 0; - m_busBusy_WhichRank = 0; - - m_roundRobin = 0; - m_refresh_count = 1; - m_need_refresh = 0; - m_refresh_bank = 0; - m_awakened = 0; - m_idleCount = 0; - m_ageCounter = 0; - - // Each tfaw shift register keeps a moving bit pattern - // which shows when recent activates have occurred. - // m_tfaw_count keeps track of how many 1 bits are set - // in each shift register. When m_tfaw_count is >= 4, - // new activates are not allowed. - m_tfaw_shift = new uint64 [m_total_ranks]; - m_tfaw_count = new int [m_total_ranks]; - for (int i=0; i<m_total_ranks; i++) { - m_tfaw_shift[i] = 0; - m_tfaw_count[i] = 0; - } -} + m_msg_counter = 0; + m_debug = 0; -// DESTRUCTOR + assert(m_tFaw <= 62); // must fit in a uint64 shift register -MemoryControl::~MemoryControl () { - delete [] m_bankQueues; - delete [] m_bankBusyCounter; - delete [] m_oldRequest; - delete m_profiler_ptr; -} + m_total_banks = m_banks_per_rank * m_ranks_per_dimm * m_dimms_per_channel; + m_total_ranks = m_ranks_per_dimm * m_dimms_per_channel; + m_refresh_period_system = m_refresh_period / m_total_banks; + m_bankQueues = new list<MemoryNode> [m_total_banks]; + assert(m_bankQueues); -// PUBLIC METHODS + m_bankBusyCounter = new int [m_total_banks]; + assert(m_bankBusyCounter); -// enqueue new request from directory - -void 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()); - physical_address_t addr = memMess->getAddress().getAddress(); - MemoryRequestType type = memMess->getType(); - bool is_mem_read = (type == MemoryRequestType_MEMORY_READ); - MemoryNode thisReq(arrival_time, message, addr, is_mem_read, !is_mem_read); - enqueueMemRef(thisReq); -} - -// Alternate entry point used when we already have a MemoryNode structure built. - -void MemoryControl::enqueueMemRef (MemoryNode& memRef) { - m_msg_counter++; - memRef.m_msg_counter = m_msg_counter; - Time arrival_time = memRef.m_time; - uint64 at = arrival_time; - bool is_mem_read = memRef.m_is_mem_read; - physical_address_t addr = memRef.m_addr; - int bank = getBank(addr); - if (m_debug) { - printf("New memory request%7d: 0x%08llx %c arrived at %10lld ", m_msg_counter, addr, is_mem_read? 'R':'W', at); - printf("bank =%3x\n", bank); - } - - m_profiler_ptr->profileMemReq(bank); - m_input_queue.push_back(memRef); - if (!m_awakened) { - g_eventQueue_ptr->scheduleEvent(this, 1); - m_awakened = 1; - } -} + m_oldRequest = new int [m_total_banks]; + assert(m_oldRequest); + for (int i = 0; i < m_total_banks; i++) { + m_bankBusyCounter[i] = 0; + m_oldRequest[i] = 0; + } + m_busBusyCounter_Basic = 0; + m_busBusyCounter_Write = 0; + m_busBusyCounter_ReadNewRank = 0; + m_busBusy_WhichRank = 0; -// dequeue, peek, and isReady are used to transfer completed requests -// back to the directory + m_roundRobin = 0; + m_refresh_count = 1; + m_need_refresh = 0; + m_refresh_bank = 0; + m_awakened = 0; + m_idleCount = 0; + m_ageCounter = 0; -void MemoryControl::dequeue () { - assert(isReady()); - m_response_queue.pop_front(); + // Each tfaw shift register keeps a moving bit pattern + // which shows when recent activates have occurred. + // m_tfaw_count keeps track of how many 1 bits are set + // in each shift register. When m_tfaw_count is >= 4, + // new activates are not allowed. + m_tfaw_shift = new uint64[m_total_ranks]; + m_tfaw_count = new int[m_total_ranks]; + for (int i = 0; i < m_total_ranks; i++) { + m_tfaw_shift[i] = 0; + m_tfaw_count[i] = 0; + } } - -const Message* MemoryControl::peek () { - MemoryNode node = peekNode(); - Message* msg_ptr = node.m_msgptr.ref(); - assert(msg_ptr != NULL); - return msg_ptr; +MemoryControl::~MemoryControl() +{ + delete [] m_bankQueues; + delete [] m_bankBusyCounter; + delete [] m_oldRequest; + delete m_profiler_ptr; } - -MemoryNode MemoryControl::peekNode () { - assert(isReady()); - MemoryNode req = m_response_queue.front(); - uint64 returnTime = req.m_time; - if (m_debug) { - printf("Old memory request%7d: 0x%08llx %c peeked at %10lld\n", - req.m_msg_counter, req.m_addr, req.m_is_mem_read? 'R':'W', returnTime); - } - return req; +// enqueue new request from directory +void +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()); + physical_address_t addr = memMess->getAddress().getAddress(); + MemoryRequestType type = memMess->getType(); + bool is_mem_read = (type == MemoryRequestType_MEMORY_READ); + MemoryNode thisReq(arrival_time, message, addr, is_mem_read, !is_mem_read); + enqueueMemRef(thisReq); } +// Alternate entry point used when we already have a MemoryNode +// structure built. +void +MemoryControl::enqueueMemRef(MemoryNode& memRef) +{ + m_msg_counter++; + memRef.m_msg_counter = m_msg_counter; + Time arrival_time = memRef.m_time; + uint64 at = arrival_time; + bool is_mem_read = memRef.m_is_mem_read; + physical_address_t addr = memRef.m_addr; + int bank = getBank(addr); + if (m_debug) { + cprintf("New memory request%7d: %#08x %c arrived at %10d bank = %3x\n", + m_msg_counter, addr, is_mem_read? 'R':'W', at, bank); + } -bool MemoryControl::isReady () { - return ((!m_response_queue.empty()) && - (m_response_queue.front().m_time <= g_eventQueue_ptr->getTime())); + m_profiler_ptr->profileMemReq(bank); + m_input_queue.push_back(memRef); + if (!m_awakened) { + g_eventQueue_ptr->scheduleEvent(this, 1); + m_awakened = 1; + } } -void MemoryControl::setConsumer (Consumer* consumer_ptr) { - m_consumer_ptr = consumer_ptr; +// dequeue, peek, and isReady are used to transfer completed requests +// back to the directory +void +MemoryControl::dequeue() +{ + assert(isReady()); + m_response_queue.pop_front(); } -void MemoryControl::print (ostream& out) const { +const Message* +MemoryControl::peek() +{ + MemoryNode node = peekNode(); + Message* msg_ptr = node.m_msgptr.ref(); + assert(msg_ptr != NULL); + return msg_ptr; } - -void MemoryControl::printConfig (ostream& out) { - out << "Memory Control " << name() << ":" << endl; - out << " Ruby cycles per memory cycle: " << m_mem_bus_cycle_multiplier << endl; - out << " Basic read latency: " << m_mem_ctl_latency << endl; - if (m_mem_fixed_delay) { - out << " Fixed Latency mode: Added cycles = " << m_mem_fixed_delay << endl; - } else { - out << " Bank busy time: " << m_bank_busy_time << " memory cycles" << endl; - out << " Memory channel busy time: " << m_basic_bus_busy_time << endl; - out << " Dead cycles between reads to different ranks: " << m_rank_rank_delay << endl; - out << " Dead cycle between a read and a write: " << m_read_write_delay << endl; - out << " tFaw (four-activate) window: " << m_tFaw << endl; - } - out << " Banks per rank: " << m_banks_per_rank << endl; - out << " Ranks per DIMM: " << m_ranks_per_dimm << endl; - out << " DIMMs per channel: " << m_dimms_per_channel << endl; - out << " LSB of bank field in address: " << m_bank_bit_0 << endl; - out << " LSB of rank field in address: " << m_rank_bit_0 << endl; - out << " LSB of DIMM field in address: " << m_dimm_bit_0 << endl; - out << " Max size of each bank queue: " << m_bank_queue_size << endl; - out << " Refresh period (within one bank): " << m_refresh_period << endl; - out << " Arbitration randomness: " << m_mem_random_arbitrate << endl; +MemoryNode +MemoryControl::peekNode() +{ + assert(isReady()); + MemoryNode req = m_response_queue.front(); + uint64 returnTime = req.m_time; + if (m_debug) { + cprintf("Old memory request%7d: %#08x %c peeked at %10d\n", + req.m_msg_counter, req.m_addr, req.m_is_mem_read ? 'R':'W', + returnTime); + } + return req; } +bool +MemoryControl::isReady() +{ + return ((!m_response_queue.empty()) && + (m_response_queue.front().m_time <= g_eventQueue_ptr->getTime())); +} -void MemoryControl::setDebug (int debugFlag) { - m_debug = debugFlag; +void +MemoryControl::setConsumer(Consumer* consumer_ptr) +{ + m_consumer_ptr = consumer_ptr; } -void MemoryControl::clearStats() const +void +MemoryControl::print(ostream& out) const { - m_profiler_ptr->clearStats(); } -void MemoryControl::printStats(ostream& out) const +void +MemoryControl::printConfig(ostream& out) { - m_profiler_ptr->printStats(out); + out << "Memory Control " << name() << ":" << endl; + out << " Ruby cycles per memory cycle: " << m_mem_bus_cycle_multiplier + << endl; + out << " Basic read latency: " << m_mem_ctl_latency << endl; + if (m_mem_fixed_delay) { + out << " Fixed Latency mode: Added cycles = " << m_mem_fixed_delay + << endl; + } else { + out << " Bank busy time: " << m_bank_busy_time << " memory cycles" + << endl; + out << " Memory channel busy time: " << m_basic_bus_busy_time << endl; + out << " Dead cycles between reads to different ranks: " + << m_rank_rank_delay << endl; + out << " Dead cycle between a read and a write: " + << m_read_write_delay << endl; + out << " tFaw (four-activate) window: " << m_tFaw << endl; + } + out << " Banks per rank: " << m_banks_per_rank << endl; + out << " Ranks per DIMM: " << m_ranks_per_dimm << endl; + out << " DIMMs per channel: " << m_dimms_per_channel << endl; + out << " LSB of bank field in address: " << m_bank_bit_0 << endl; + out << " LSB of rank field in address: " << m_rank_bit_0 << endl; + out << " LSB of DIMM field in address: " << m_dimm_bit_0 << endl; + out << " Max size of each bank queue: " << m_bank_queue_size << endl; + out << " Refresh period (within one bank): " << m_refresh_period << endl; + out << " Arbitration randomness: " << m_mem_random_arbitrate << endl; } +void +MemoryControl::setDebug(int debugFlag) +{ + m_debug = debugFlag; +} -// **************************************************************** +void +MemoryControl::clearStats() const +{ + m_profiler_ptr->clearStats(); +} -// PRIVATE METHODS +void +MemoryControl::printStats(ostream& out) const +{ + m_profiler_ptr->printStats(out); +} // Queue up a completed request to send back to directory +void +MemoryControl::enqueueToDirectory(MemoryNode req, int latency) +{ + Time arrival_time = g_eventQueue_ptr->getTime() + + (latency * m_mem_bus_cycle_multiplier); + req.m_time = arrival_time; + m_response_queue.push_back(req); -void MemoryControl::enqueueToDirectory (MemoryNode req, int latency) { - Time arrival_time = g_eventQueue_ptr->getTime() - + (latency * m_mem_bus_cycle_multiplier); - req.m_time = arrival_time; - m_response_queue.push_back(req); - - // schedule the wake up - g_eventQueue_ptr->scheduleEventAbsolute(m_consumer_ptr, arrival_time); + // schedule the wake up + g_eventQueue_ptr->scheduleEventAbsolute(m_consumer_ptr, arrival_time); } - - // getBank returns an integer that is unique for each // bank across this memory controller. - -int MemoryControl::getBank (physical_address_t addr) { - int dimm = (addr >> m_dimm_bit_0) & (m_dimms_per_channel - 1); - int rank = (addr >> m_rank_bit_0) & (m_ranks_per_dimm - 1); - int bank = (addr >> m_bank_bit_0) & (m_banks_per_rank - 1); - return (dimm * m_ranks_per_dimm * m_banks_per_rank) - + (rank * m_banks_per_rank) - + bank; +int +MemoryControl::getBank(physical_address_t addr) +{ + int dimm = (addr >> m_dimm_bit_0) & (m_dimms_per_channel - 1); + int rank = (addr >> m_rank_bit_0) & (m_ranks_per_dimm - 1); + int bank = (addr >> m_bank_bit_0) & (m_banks_per_rank - 1); + return (dimm * m_ranks_per_dimm * m_banks_per_rank) + + (rank * m_banks_per_rank) + + bank; } // getRank returns an integer that is unique for each rank // and independent of individual bank. - -int MemoryControl::getRank (int bank) { - int rank = (bank / m_banks_per_rank); - assert (rank < (m_ranks_per_dimm * m_dimms_per_channel)); - return rank; +int +MemoryControl::getRank(int bank) +{ + int rank = (bank / m_banks_per_rank); + assert (rank < (m_ranks_per_dimm * m_dimms_per_channel)); + return rank; } - // queueReady determines if the head item in a bank queue // can be issued this cycle +bool +MemoryControl::queueReady(int bank) +{ + if ((m_bankBusyCounter[bank] > 0) && !m_mem_fixed_delay) { + m_profiler_ptr->profileMemBankBusy(); +#if 0 + if (m_debug) + printf(" bank %x busy %d\n", bank, m_bankBusyCounter[bank]); +#endif + return false; + } -bool MemoryControl::queueReady (int bank) { - if ((m_bankBusyCounter[bank] > 0) && !m_mem_fixed_delay) { - m_profiler_ptr->profileMemBankBusy(); - //if (m_debug) printf(" bank %x busy %d\n", bank, m_bankBusyCounter[bank]); - return false; - } - if (m_mem_random_arbitrate >= 2) { - if ((random() % 100) < m_mem_random_arbitrate) { - m_profiler_ptr->profileMemRandBusy(); - return false; + if (m_mem_random_arbitrate >= 2) { + if ((random() % 100) < m_mem_random_arbitrate) { + m_profiler_ptr->profileMemRandBusy(); + return false; + } } - } - if (m_mem_fixed_delay) return true; - if ((m_ageCounter > (2 * m_bank_busy_time)) && !m_oldRequest[bank]) { - m_profiler_ptr->profileMemNotOld(); - return false; - } - if (m_busBusyCounter_Basic == m_basic_bus_busy_time) { - // Another bank must have issued this same cycle. - // For profiling, we count this as an arb wait rather than - // a bus wait. This is a little inaccurate since it MIGHT - // have also been blocked waiting for a read-write or a - // read-read instead, but it's pretty close. - m_profiler_ptr->profileMemArbWait(1); - return false; - } - if (m_busBusyCounter_Basic > 0) { - m_profiler_ptr->profileMemBusBusy(); - return false; - } - int rank = getRank(bank); - if (m_tfaw_count[rank] >= ACTIVATE_PER_TFAW) { - m_profiler_ptr->profileMemTfawBusy(); - return false; - } - bool write = !m_bankQueues[bank].front().m_is_mem_read; - if (write && (m_busBusyCounter_Write > 0)) { - m_profiler_ptr->profileMemReadWriteBusy(); - return false; - } - if (!write && (rank != m_busBusy_WhichRank) - && (m_busBusyCounter_ReadNewRank > 0)) { - m_profiler_ptr->profileMemDataBusBusy(); - return false; - } - return true; -} + if (m_mem_fixed_delay) + return true; -// issueRefresh checks to see if this bank has a refresh scheduled -// and, if so, does the refresh and returns true + if ((m_ageCounter > (2 * m_bank_busy_time)) && !m_oldRequest[bank]) { + m_profiler_ptr->profileMemNotOld(); + return false; + } -bool MemoryControl::issueRefresh (int bank) { - if (!m_need_refresh || (m_refresh_bank != bank)) return false; - if (m_bankBusyCounter[bank] > 0) return false; - // Note that m_busBusyCounter will prevent multiple issues during - // the same cycle, as well as on different but close cycles: - if (m_busBusyCounter_Basic > 0) return false; - int rank = getRank(bank); - if (m_tfaw_count[rank] >= ACTIVATE_PER_TFAW) return false; - - // Issue it: - - //if (m_debug) { - //uint64 current_time = g_eventQueue_ptr->getTime(); - //printf(" Refresh bank %3x at %lld\n", bank, current_time); - //} - m_profiler_ptr->profileMemRefresh(); - m_need_refresh--; - m_refresh_bank++; - if (m_refresh_bank >= m_total_banks) m_refresh_bank = 0; - m_bankBusyCounter[bank] = m_bank_busy_time; - m_busBusyCounter_Basic = m_basic_bus_busy_time; - m_busBusyCounter_Write = m_basic_bus_busy_time; - m_busBusyCounter_ReadNewRank = m_basic_bus_busy_time; - markTfaw(rank); - return true; -} + if (m_busBusyCounter_Basic == m_basic_bus_busy_time) { + // Another bank must have issued this same cycle. For + // profiling, we count this as an arb wait rather than a bus + // wait. This is a little inaccurate since it MIGHT have also + // been blocked waiting for a read-write or a read-read + // instead, but it's pretty close. + m_profiler_ptr->profileMemArbWait(1); + return false; + } + if (m_busBusyCounter_Basic > 0) { + m_profiler_ptr->profileMemBusBusy(); + return false; + } -// Mark the activate in the tFaw shift register -void MemoryControl::markTfaw (int rank) { - if (m_tFaw) { - m_tfaw_shift[rank] |= (1 << (m_tFaw-1)); - m_tfaw_count[rank]++; - } -} + int rank = getRank(bank); + if (m_tfaw_count[rank] >= ACTIVATE_PER_TFAW) { + m_profiler_ptr->profileMemTfawBusy(); + return false; + } + bool write = !m_bankQueues[bank].front().m_is_mem_read; + if (write && (m_busBusyCounter_Write > 0)) { + m_profiler_ptr->profileMemReadWriteBusy(); + return false; + } -// Issue a memory request: Activate the bank, -// reserve the address and data buses, and queue -// the request for return to the requesting -// processor after a fixed latency. + if (!write && (rank != m_busBusy_WhichRank) + && (m_busBusyCounter_ReadNewRank > 0)) { + m_profiler_ptr->profileMemDataBusBusy(); + return false; + } -void MemoryControl::issueRequest (int bank) { - int rank = getRank(bank); - MemoryNode req = m_bankQueues[bank].front(); - m_bankQueues[bank].pop_front(); - if (m_debug) { - uint64 current_time = g_eventQueue_ptr->getTime(); - printf(" Mem issue request%7d: 0x%08llx %c at %10lld bank =%3x\n", - 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 - enqueueToDirectory(req, m_mem_ctl_latency + m_mem_fixed_delay); - } - m_oldRequest[bank] = 0; - markTfaw(rank); - m_bankBusyCounter[bank] = m_bank_busy_time; - m_busBusy_WhichRank = rank; - if (req.m_is_mem_read) { - m_profiler_ptr->profileMemRead(); - m_busBusyCounter_Basic = m_basic_bus_busy_time; - m_busBusyCounter_Write = m_basic_bus_busy_time + m_read_write_delay; - m_busBusyCounter_ReadNewRank = m_basic_bus_busy_time + m_rank_rank_delay; - } else { - m_profiler_ptr->profileMemWrite(); + return true; +} + +// issueRefresh checks to see if this bank has a refresh scheduled +// and, if so, does the refresh and returns true +bool +MemoryControl::issueRefresh(int bank) +{ + if (!m_need_refresh || (m_refresh_bank != bank)) + return false; + if (m_bankBusyCounter[bank] > 0) + return false; + // Note that m_busBusyCounter will prevent multiple issues during + // the same cycle, as well as on different but close cycles: + if (m_busBusyCounter_Basic > 0) + return false; + int rank = getRank(bank); + if (m_tfaw_count[rank] >= ACTIVATE_PER_TFAW) + return false; + + // Issue it: +#if 0 + if (m_debug) { + uint64 current_time = g_eventQueue_ptr->getTime(); + printf(" Refresh bank %3x at %lld\n", bank, current_time); + } +#endif + + m_profiler_ptr->profileMemRefresh(); + m_need_refresh--; + m_refresh_bank++; + if (m_refresh_bank >= m_total_banks) + m_refresh_bank = 0; + m_bankBusyCounter[bank] = m_bank_busy_time; m_busBusyCounter_Basic = m_basic_bus_busy_time; m_busBusyCounter_Write = m_basic_bus_busy_time; m_busBusyCounter_ReadNewRank = m_basic_bus_busy_time; - } + markTfaw(rank); + return true; +} + +// Mark the activate in the tFaw shift register +void +MemoryControl::markTfaw(int rank) +{ + if (m_tFaw) { + m_tfaw_shift[rank] |= (1 << (m_tFaw-1)); + m_tfaw_count[rank]++; + } } +// Issue a memory request: Activate the bank, reserve the address and +// data buses, and queue the request for return to the requesting +// processor after a fixed latency. +void +MemoryControl::issueRequest(int bank) +{ + int rank = getRank(bank); + MemoryNode req = m_bankQueues[bank].front(); + m_bankQueues[bank].pop_front(); + if (m_debug) { + uint64 current_time = g_eventQueue_ptr->getTime(); + cprintf(" Mem issue request%7d: %#08x %c at %10d " + "bank=%3x\n", + 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 + enqueueToDirectory(req, m_mem_ctl_latency + m_mem_fixed_delay); + } + m_oldRequest[bank] = 0; + markTfaw(rank); + m_bankBusyCounter[bank] = m_bank_busy_time; + m_busBusy_WhichRank = rank; + if (req.m_is_mem_read) { + m_profiler_ptr->profileMemRead(); + m_busBusyCounter_Basic = m_basic_bus_busy_time; + m_busBusyCounter_Write = m_basic_bus_busy_time + m_read_write_delay; + m_busBusyCounter_ReadNewRank = + m_basic_bus_busy_time + m_rank_rank_delay; + } else { + m_profiler_ptr->profileMemWrite(); + m_busBusyCounter_Basic = m_basic_bus_busy_time; + m_busBusyCounter_Write = m_basic_bus_busy_time; + m_busBusyCounter_ReadNewRank = m_basic_bus_busy_time; + } +} // executeCycle: This function is called once per memory clock cycle // to simulate all the periodic hardware. +void +MemoryControl::executeCycle() +{ + // Keep track of time by counting down the busy counters: + for (int bank=0; bank < m_total_banks; bank++) { + if (m_bankBusyCounter[bank] > 0) m_bankBusyCounter[bank]--; + } + if (m_busBusyCounter_Write > 0) + m_busBusyCounter_Write--; + if (m_busBusyCounter_ReadNewRank > 0) + m_busBusyCounter_ReadNewRank--; + if (m_busBusyCounter_Basic > 0) + m_busBusyCounter_Basic--; + + // Count down the tFAW shift registers: + for (int rank=0; rank < m_total_ranks; rank++) { + if (m_tfaw_shift[rank] & 1) m_tfaw_count[rank]--; + m_tfaw_shift[rank] >>= 1; + } + + // After time period expires, latch an indication that we need a refresh. + // Disable refresh if in mem_fixed_delay mode. + if (!m_mem_fixed_delay) m_refresh_count--; + if (m_refresh_count == 0) { + m_refresh_count = m_refresh_period_system; + + // Are we overrunning our ability to refresh? + assert(m_need_refresh < 10); + m_need_refresh++; + } -void MemoryControl::executeCycle () { - // Keep track of time by counting down the busy counters: - for (int bank=0; bank < m_total_banks; bank++) { - if (m_bankBusyCounter[bank] > 0) m_bankBusyCounter[bank]--; - } - if (m_busBusyCounter_Write > 0) m_busBusyCounter_Write--; - if (m_busBusyCounter_ReadNewRank > 0) m_busBusyCounter_ReadNewRank--; - if (m_busBusyCounter_Basic > 0) m_busBusyCounter_Basic--; - - // Count down the tFAW shift registers: - for (int rank=0; rank < m_total_ranks; rank++) { - if (m_tfaw_shift[rank] & 1) m_tfaw_count[rank]--; - m_tfaw_shift[rank] >>= 1; - } - - // After time period expires, latch an indication that we need a refresh. - // Disable refresh if in mem_fixed_delay mode. - if (!m_mem_fixed_delay) m_refresh_count--; - if (m_refresh_count == 0) { - m_refresh_count = m_refresh_period_system; - assert (m_need_refresh < 10); // Are we overrunning our ability to refresh? - m_need_refresh++; - } - - // If this batch of requests is all done, make a new batch: - m_ageCounter++; - int anyOld = 0; - for (int bank=0; bank < m_total_banks; bank++) { - anyOld |= m_oldRequest[bank]; - } - if (!anyOld) { + // If this batch of requests is all done, make a new batch: + m_ageCounter++; + int anyOld = 0; for (int bank=0; bank < m_total_banks; bank++) { - if (!m_bankQueues[bank].empty()) m_oldRequest[bank] = 1; + anyOld |= m_oldRequest[bank]; } - m_ageCounter = 0; - } - - // If randomness desired, re-randomize round-robin position each cycle - if (m_mem_random_arbitrate) { - m_roundRobin = random() % m_total_banks; - } - - - // For each channel, scan round-robin, and pick an old, ready - // request and issue it. Treat a refresh request as if it - // were at the head of its bank queue. After we issue something, - // keep scanning the queues just to gather statistics about - // how many are waiting. If in mem_fixed_delay mode, we can issue - // more than one request per cycle. - - int queueHeads = 0; - int banksIssued = 0; - for (int i = 0; i < m_total_banks; i++) { - m_roundRobin++; - if (m_roundRobin >= m_total_banks) m_roundRobin = 0; - issueRefresh(m_roundRobin); - int qs = m_bankQueues[m_roundRobin].size(); - if (qs > 1) { - m_profiler_ptr->profileMemBankQ(qs-1); + if (!anyOld) { + for (int bank=0; bank < m_total_banks; bank++) { + if (!m_bankQueues[bank].empty()) m_oldRequest[bank] = 1; + } + m_ageCounter = 0; + } + + // If randomness desired, re-randomize round-robin position each cycle + if (m_mem_random_arbitrate) { + m_roundRobin = random() % m_total_banks; } - if (qs > 0) { - m_idleCount = IDLECOUNT_MAX_VALUE; // we're not idle if anything is queued - queueHeads++; - if (queueReady(m_roundRobin)) { - issueRequest(m_roundRobin); - banksIssued++; - if (m_mem_fixed_delay) { - m_profiler_ptr->profileMemWaitCycles(m_mem_fixed_delay); + + // For each channel, scan round-robin, and pick an old, ready + // request and issue it. Treat a refresh request as if it were at + // the head of its bank queue. After we issue something, keep + // scanning the queues just to gather statistics about how many + // are waiting. If in mem_fixed_delay mode, we can issue more + // than one request per cycle. + int queueHeads = 0; + int banksIssued = 0; + for (int i = 0; i < m_total_banks; i++) { + m_roundRobin++; + if (m_roundRobin >= m_total_banks) m_roundRobin = 0; + issueRefresh(m_roundRobin); + int qs = m_bankQueues[m_roundRobin].size(); + if (qs > 1) { + m_profiler_ptr->profileMemBankQ(qs-1); + } + if (qs > 0) { + // we're not idle if anything is queued + m_idleCount = IDLECOUNT_MAX_VALUE; + queueHeads++; + if (queueReady(m_roundRobin)) { + issueRequest(m_roundRobin); + banksIssued++; + if (m_mem_fixed_delay) { + m_profiler_ptr->profileMemWaitCycles(m_mem_fixed_delay); + } + } } - } } - } - - // memWaitCycles is a redundant catch-all for the specific counters in queueReady - m_profiler_ptr->profileMemWaitCycles(queueHeads - banksIssued); - - // Check input queue and move anything to bank queues if not full. - // Since this is done here at the end of the cycle, there will always - // be at least one cycle of latency in the bank queue. - // We deliberately move at most one request per cycle (to simulate - // typical hardware). Note that if one bank queue fills up, other - // requests can get stuck behind it here. - - if (!m_input_queue.empty()) { - m_idleCount = IDLECOUNT_MAX_VALUE; // we're not idle if anything is pending - MemoryNode req = m_input_queue.front(); - int bank = getBank(req.m_addr); - if (m_bankQueues[bank].size() < m_bank_queue_size) { - m_input_queue.pop_front(); - m_bankQueues[bank].push_back(req); + + // memWaitCycles is a redundant catch-all for the specific + // counters in queueReady + m_profiler_ptr->profileMemWaitCycles(queueHeads - banksIssued); + + // Check input queue and move anything to bank queues if not full. + // Since this is done here at the end of the cycle, there will + // always be at least one cycle of latency in the bank queue. We + // deliberately move at most one request per cycle (to simulate + // typical hardware). Note that if one bank queue fills up, other + // requests can get stuck behind it here. + if (!m_input_queue.empty()) { + // we're not idle if anything is pending + m_idleCount = IDLECOUNT_MAX_VALUE; + MemoryNode req = m_input_queue.front(); + int bank = getBank(req.m_addr); + if (m_bankQueues[bank].size() < m_bank_queue_size) { + m_input_queue.pop_front(); + m_bankQueues[bank].push_back(req); + } + m_profiler_ptr->profileMemInputQ(m_input_queue.size()); } - m_profiler_ptr->profileMemInputQ(m_input_queue.size()); - } } - // wakeup: This function is called once per memory controller clock cycle. - -void MemoryControl::wakeup () { - - // execute everything - executeCycle(); - - m_idleCount--; - if (m_idleCount <= 0) { - m_awakened = 0; - } else { - // Reschedule ourselves so that we run every memory cycle: - g_eventQueue_ptr->scheduleEvent(this, m_mem_bus_cycle_multiplier); - } +void +MemoryControl::wakeup() +{ + // execute everything + executeCycle(); + + m_idleCount--; + if (m_idleCount <= 0) { + m_awakened = 0; + } else { + // Reschedule ourselves so that we run every memory cycle: + g_eventQueue_ptr->scheduleEvent(this, m_mem_bus_cycle_multiplier); + } } MemoryControl * diff --git a/src/mem/ruby/system/MemoryControl.hh b/src/mem/ruby/system/MemoryControl.hh index b96055cb1..d42c1e6e0 100644 --- a/src/mem/ruby/system/MemoryControl.hh +++ b/src/mem/ruby/system/MemoryControl.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,34 +26,24 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * MemoryControl.hh - * - * Description: See MemoryControl.cc - * - * $Id: $ - * - */ +#ifndef __MEM_RUBY_SYSTEM_MEMORY_CONTROL_HH__ +#define __MEM_RUBY_SYSTEM_MEMORY_CONTROL_HH__ -#ifndef MEMORY_CONTROL_H -#define MEMORY_CONTROL_H +#include <list> -#include "mem/ruby/common/Global.hh" #include "mem/gems_common/Map.hh" -#include "mem/ruby/common/Address.hh" -#include "mem/ruby/profiler/MemCntrlProfiler.hh" -#include "mem/ruby/system/System.hh" -#include "mem/ruby/slicc_interface/Message.hh" #include "mem/gems_common/util.hh" -#include "mem/ruby/system/MemoryNode.hh" -// Note that "MemoryMsg" is in the "generated" directory: #include "mem/protocol/MemoryMsg.hh" +#include "mem/ruby/common/Address.hh" #include "mem/ruby/common/Consumer.hh" +#include "mem/ruby/common/Global.hh" +#include "mem/ruby/profiler/MemCntrlProfiler.hh" +#include "mem/ruby/slicc_interface/Message.hh" #include "mem/ruby/system/AbstractMemOrCache.hh" -#include "sim/sim_object.hh" +#include "mem/ruby/system/MemoryNode.hh" +#include "mem/ruby/system/System.hh" #include "params/RubyMemoryControl.hh" - -#include <list> +#include "sim/sim_object.hh" // This constant is part of the definition of tFAW; see // the comments in header to MemoryControl.cc @@ -64,124 +53,117 @@ class Consumer; -class MemoryControl : public SimObject, public Consumer, public AbstractMemOrCache { -public: - - // Constructors +class MemoryControl : + public SimObject, public Consumer, public AbstractMemOrCache +{ + public: typedef RubyMemoryControlParams Params; MemoryControl(const Params *p); - void init(); - - // Destructor - ~MemoryControl (); - - // Public Methods - - void wakeup() ; - - void setConsumer (Consumer* consumer_ptr); - Consumer* getConsumer () { return m_consumer_ptr; }; - void setDescription (const string& name) { m_description = name; }; - string getDescription () { return m_description; }; - - // Called from the directory: - void enqueue (const MsgPtr& message, int latency ); - void enqueueMemRef (MemoryNode& memRef); - void dequeue (); - const Message* peek (); - MemoryNode peekNode (); - bool isReady(); - bool areNSlotsAvailable (int n) { return true; }; // infinite queue length - - //// Called from L3 cache: - //void writeBack(physical_address_t addr); - - void printConfig (ostream& out); - void print (ostream& out) const; - void setDebug (int debugFlag); - void clearStats() const; - void printStats(ostream& out) const; - - - //added by SS - int getBanksPerRank() { return m_banks_per_rank; }; - int getRanksPerDimm() { return m_ranks_per_dimm; }; - int getDimmsPerChannel() { return m_dimms_per_channel; } - -private: - - void enqueueToDirectory (MemoryNode req, int latency); - int getBank (physical_address_t addr); - int getRank (int bank); - bool queueReady (int bank); - void issueRequest (int bank); - bool issueRefresh (int bank); - void markTfaw (int rank); - void executeCycle (); - - // Private copy constructor and assignment operator - MemoryControl (const MemoryControl& obj); - MemoryControl& operator=(const MemoryControl& obj); - - // data members - Consumer* m_consumer_ptr; // Consumer to signal a wakeup() - string m_description; - int m_msg_counter; - int m_awakened; - - int m_mem_bus_cycle_multiplier; - int m_banks_per_rank; - int m_ranks_per_dimm; - int m_dimms_per_channel; - int m_bank_bit_0; - int m_rank_bit_0; - int m_dimm_bit_0; - unsigned int m_bank_queue_size; - int m_bank_busy_time; - int m_rank_rank_delay; - int m_read_write_delay; - int m_basic_bus_busy_time; - int m_mem_ctl_latency; - int m_refresh_period; - int m_mem_random_arbitrate; - int m_tFaw; - int m_mem_fixed_delay; - - int m_total_banks; - int m_total_ranks; - int m_refresh_period_system; - - // queues where memory requests live - - list<MemoryNode> m_response_queue; - list<MemoryNode> m_input_queue; - list<MemoryNode>* m_bankQueues; - - // Each entry indicates number of address-bus cycles until bank - // is reschedulable: - int* m_bankBusyCounter; - int* m_oldRequest; - - uint64* m_tfaw_shift; - int* m_tfaw_count; - - // Each of these indicates number of address-bus cycles until - // we can issue a new request of the corresponding type: - int m_busBusyCounter_Write; - int m_busBusyCounter_ReadNewRank; - int m_busBusyCounter_Basic; - - int m_busBusy_WhichRank; // which rank last granted - int m_roundRobin; // which bank queue was last granted - int m_refresh_count; // cycles until next refresh - int m_need_refresh; // set whenever m_refresh_count goes to zero - int m_refresh_bank; // which bank to refresh next - int m_ageCounter; // age of old requests; to detect starvation - int m_idleCount; // watchdog timer for shutting down - int m_debug; // turn on printf's - - MemCntrlProfiler* m_profiler_ptr; + void init(); + + ~MemoryControl(); + + void wakeup(); + + void setConsumer(Consumer* consumer_ptr); + Consumer* getConsumer() { return m_consumer_ptr; }; + void setDescription(const string& name) { m_description = name; }; + string getDescription() { return m_description; }; + + // Called from the directory: + void enqueue(const MsgPtr& message, int latency ); + void enqueueMemRef(MemoryNode& memRef); + void dequeue(); + const Message* peek(); + MemoryNode peekNode(); + bool isReady(); + bool areNSlotsAvailable(int n) { return true; }; // infinite queue length + + //// Called from L3 cache: + //void writeBack(physical_address_t addr); + + void printConfig(ostream& out); + void print(ostream& out) const; + void setDebug(int debugFlag); + void clearStats() const; + void printStats(ostream& out) const; + + //added by SS + int getBanksPerRank() { return m_banks_per_rank; }; + int getRanksPerDimm() { return m_ranks_per_dimm; }; + int getDimmsPerChannel() { return m_dimms_per_channel; } + + private: + void enqueueToDirectory(MemoryNode req, int latency); + int getBank(physical_address_t addr); + int getRank(int bank); + bool queueReady(int bank); + void issueRequest(int bank); + bool issueRefresh(int bank); + void markTfaw(int rank); + void executeCycle(); + + // Private copy constructor and assignment operator + MemoryControl (const MemoryControl& obj); + MemoryControl& operator=(const MemoryControl& obj); + + // data members + Consumer* m_consumer_ptr; // Consumer to signal a wakeup() + string m_description; + int m_msg_counter; + int m_awakened; + + int m_mem_bus_cycle_multiplier; + int m_banks_per_rank; + int m_ranks_per_dimm; + int m_dimms_per_channel; + int m_bank_bit_0; + int m_rank_bit_0; + int m_dimm_bit_0; + unsigned int m_bank_queue_size; + int m_bank_busy_time; + int m_rank_rank_delay; + int m_read_write_delay; + int m_basic_bus_busy_time; + int m_mem_ctl_latency; + int m_refresh_period; + int m_mem_random_arbitrate; + int m_tFaw; + int m_mem_fixed_delay; + + int m_total_banks; + int m_total_ranks; + int m_refresh_period_system; + + // queues where memory requests live + list<MemoryNode> m_response_queue; + list<MemoryNode> m_input_queue; + list<MemoryNode>* m_bankQueues; + + // Each entry indicates number of address-bus cycles until bank + // is reschedulable: + int* m_bankBusyCounter; + int* m_oldRequest; + + uint64* m_tfaw_shift; + int* m_tfaw_count; + + // Each of these indicates number of address-bus cycles until + // we can issue a new request of the corresponding type: + int m_busBusyCounter_Write; + int m_busBusyCounter_ReadNewRank; + int m_busBusyCounter_Basic; + + int m_busBusy_WhichRank; // which rank last granted + int m_roundRobin; // which bank queue was last granted + int m_refresh_count; // cycles until next refresh + int m_need_refresh; // set whenever m_refresh_count goes to zero + int m_refresh_bank; // which bank to refresh next + int m_ageCounter; // age of old requests; to detect starvation + int m_idleCount; // watchdog timer for shutting down + int m_debug; // turn on printf's + + MemCntrlProfiler* m_profiler_ptr; }; -#endif // MEMORY_CONTROL_H - +#endif // __MEM_RUBY_SYSTEM_MEMORY_CONTROL_HH__ diff --git a/src/mem/ruby/system/MemoryNode.cc b/src/mem/ruby/system/MemoryNode.cc index 5b74f497a..07262fba0 100644 --- a/src/mem/ruby/system/MemoryNode.cc +++ b/src/mem/ruby/system/MemoryNode.cc @@ -30,11 +30,12 @@ using namespace std; -void MemoryNode::print(ostream& out) const +void +MemoryNode::print(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/system/MemoryNode.hh b/src/mem/ruby/system/MemoryNode.hh index 2c2b987ae..10648b715 100644 --- a/src/mem/ruby/system/MemoryNode.hh +++ b/src/mem/ruby/system/MemoryNode.hh @@ -35,68 +35,59 @@ * message is enqueued to be sent back to the directory. */ -#ifndef MEMORYNODE_H -#define MEMORYNODE_H +#ifndef __MEM_RUBY_SYSTEM_MEMORYNODE_HH__ +#define __MEM_RUBY_SYSTEM_MEMORYNODE_HH__ #include <iostream> +#include "mem/protocol/MemoryRequestType.hh" #include "mem/ruby/common/Global.hh" #include "mem/ruby/slicc_interface/Message.hh" -#include "mem/protocol/MemoryRequestType.hh" - -class MemoryNode { - -public: - // Constructors - -// old one: - MemoryNode(const Time& time, int counter, const MsgPtr& msgptr, const physical_address_t addr, const bool is_mem_read) { - m_time = time; - m_msg_counter = counter; - m_msgptr = msgptr; - m_addr = addr; - m_is_mem_read = is_mem_read; - m_is_dirty_wb = !is_mem_read; - } - -// new one: - MemoryNode(const Time& time, const MsgPtr& msgptr, const physical_address_t addr, const bool is_mem_read, const bool is_dirty_wb) { - m_time = time; - m_msg_counter = 0; - m_msgptr = msgptr; - m_addr = addr; - m_is_mem_read = is_mem_read; - m_is_dirty_wb = is_dirty_wb; - } - // Destructor - ~MemoryNode() {}; - - // Public Methods - void print(std::ostream& out) const; - - // Data Members (m_ prefix) (all public -- this is really more a struct) - - Time m_time; - int m_msg_counter; - MsgPtr m_msgptr; - physical_address_t m_addr; - bool m_is_mem_read; - bool m_is_dirty_wb; +class MemoryNode +{ + public: + // old constructor + MemoryNode(const Time& time, int counter, const MsgPtr& msgptr, + const physical_address_t addr, const bool is_mem_read) + { + m_time = time; + m_msg_counter = counter; + m_msgptr = msgptr; + m_addr = addr; + m_is_mem_read = is_mem_read; + m_is_dirty_wb = !is_mem_read; + } + + // new constructor + MemoryNode(const Time& time, const MsgPtr& msgptr, + const physical_address_t addr, const bool is_mem_read, + const bool is_dirty_wb) + { + m_time = time; + m_msg_counter = 0; + m_msgptr = msgptr; + m_addr = addr; + m_is_mem_read = is_mem_read; + m_is_dirty_wb = is_dirty_wb; + } + + void print(std::ostream& out) const; + + Time m_time; + int m_msg_counter; + MsgPtr m_msgptr; + physical_address_t m_addr; + bool m_is_mem_read; + bool m_is_dirty_wb; }; -// Output operator declaration -std::ostream& operator<<(std::ostream& out, const MemoryNode& obj); - -// ******************* Definitions ******************* - -// Output operator definition -extern inline -std::ostream& operator<<(std::ostream& out, const MemoryNode& obj) +inline std::ostream& +operator<<(std::ostream& out, const MemoryNode& obj) { - obj.print(out); - out << std::flush; - return out; + obj.print(out); + out << std::flush; + return out; } -#endif //MEMORYNODE_H +#endif // __MEM_RUBY_SYSTEM_MEMORYNODE_HH__ diff --git a/src/mem/ruby/system/MemoryVector.hh b/src/mem/ruby/system/MemoryVector.hh index e450059fd..15cea168d 100644 --- a/src/mem/ruby/system/MemoryVector.hh +++ b/src/mem/ruby/system/MemoryVector.hh @@ -26,8 +26,8 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef MEMORYVECTOR_H -#define MEMORYVECTOR_H +#ifndef __MEM_RUBY_SYSTEM_MEMORYVECTOR_HH__ +#define __MEM_RUBY_SYSTEM_MEMORYVECTOR_HH__ #include "mem/ruby/common/Address.hh" @@ -36,117 +36,121 @@ class DirectoryMemory; /** * MemoryVector holds memory data (DRAM only) */ -class MemoryVector { - public: - MemoryVector(); - MemoryVector(uint32 size); - ~MemoryVector(); - friend class DirectoryMemory; +class MemoryVector +{ + public: + MemoryVector(); + MemoryVector(uint32 size); + ~MemoryVector(); + friend class DirectoryMemory; - void setSize(uint32 size); // destructive + void setSize(uint32 size); // destructive - void write(const Address & paddr, uint8* data, int len); - uint8* read(const Address & paddr, uint8* data, int len); + void write(const Address & paddr, uint8* data, int len); + uint8* read(const Address & paddr, uint8* data, int len); -private: - uint8* getBlockPtr(const PhysAddress & addr); + private: + uint8* getBlockPtr(const PhysAddress & addr); - uint32 m_size; - uint8** m_pages; - uint32 m_num_pages; - const uint32 m_page_offset_mask; + uint32 m_size; + uint8** m_pages; + uint32 m_num_pages; + const uint32 m_page_offset_mask; }; inline MemoryVector::MemoryVector() - : m_page_offset_mask(4095) + : m_page_offset_mask(4095) { - m_size = 0; - m_num_pages = 0; - m_pages = NULL; + m_size = 0; + m_num_pages = 0; + m_pages = NULL; } inline MemoryVector::MemoryVector(uint32 size) - : m_page_offset_mask(4095) + : m_page_offset_mask(4095) { - setSize(size); + setSize(size); } inline MemoryVector::~MemoryVector() { - for (int i=0; i<m_num_pages; i++) { - if (m_pages[i] != 0) { - delete [] m_pages[i]; + for (int i = 0; i < m_num_pages; i++) { + if (m_pages[i] != 0) { + delete [] m_pages[i]; + } } - } - delete [] m_pages; + delete [] m_pages; } -inline -void MemoryVector::setSize(uint32 size) +inline void +MemoryVector::setSize(uint32 size) { - if (m_pages != NULL){ - for (int i=0; i<m_num_pages; i++) { - if (m_pages[i] != 0) { - delete [] m_pages[i]; - } + if (m_pages != NULL){ + for (int i = 0; i < m_num_pages; i++) { + if (m_pages[i] != 0) { + delete [] m_pages[i]; + } + } + delete [] m_pages; } - delete [] m_pages; - } - m_size = size; - assert(size%4096 == 0); - m_num_pages = size >> 12; - m_pages = new uint8*[m_num_pages]; - memset(m_pages, 0, m_num_pages * sizeof(uint8*)); + m_size = size; + assert(size%4096 == 0); + m_num_pages = size >> 12; + m_pages = new uint8*[m_num_pages]; + memset(m_pages, 0, m_num_pages * sizeof(uint8*)); } -inline -void MemoryVector::write(const Address & paddr, uint8* data, int len) +inline void +MemoryVector::write(const Address & paddr, uint8* data, int len) { - assert(paddr.getAddress() + len <= m_size); - uint32 page_num = paddr.getAddress() >> 12; - if (m_pages[page_num] == 0) { - bool all_zeros = true; - for (int i=0;i<len;i++) { - if (data[i] != 0) { - all_zeros = false; - break; - } + assert(paddr.getAddress() + len <= m_size); + uint32 page_num = paddr.getAddress() >> 12; + if (m_pages[page_num] == 0) { + bool all_zeros = true; + for (int i = 0; i < len;i++) { + if (data[i] != 0) { + all_zeros = false; + break; + } + } + if (all_zeros) + return; + m_pages[page_num] = new uint8[4096]; + memset(m_pages[page_num], 0, 4096); + uint32 offset = paddr.getAddress() & m_page_offset_mask; + memcpy(&m_pages[page_num][offset], data, len); + } else { + memcpy(&m_pages[page_num][paddr.getAddress()&m_page_offset_mask], + data, len); } - if (all_zeros) return; - m_pages[page_num] = new uint8[4096]; - memset(m_pages[page_num], 0, 4096); - uint32 offset = paddr.getAddress() & m_page_offset_mask; - memcpy(&m_pages[page_num][offset], data, len); - } else { - memcpy(&m_pages[page_num][paddr.getAddress()&m_page_offset_mask], data, len); - } } -inline -uint8* MemoryVector::read(const Address & paddr, uint8* data, int len) +inline uint8* +MemoryVector::read(const Address & paddr, uint8* data, int len) { - assert(paddr.getAddress() + len <= m_size); - uint32 page_num = paddr.getAddress() >> 12; - if (m_pages[page_num] == 0) { - memset(data, 0, len); - } else { - memcpy(data, &m_pages[page_num][paddr.getAddress()&m_page_offset_mask], len); - } - return data; + assert(paddr.getAddress() + len <= m_size); + uint32 page_num = paddr.getAddress() >> 12; + if (m_pages[page_num] == 0) { + memset(data, 0, len); + } else { + memcpy(data, &m_pages[page_num][paddr.getAddress()&m_page_offset_mask], + len); + } + return data; } -inline -uint8* MemoryVector::getBlockPtr(const PhysAddress & paddr) +inline uint8* +MemoryVector::getBlockPtr(const PhysAddress & paddr) { - uint32 page_num = paddr.getAddress() >> 12; - if (m_pages[page_num] == 0) { - m_pages[page_num] = new uint8[4096]; - memset(m_pages[page_num], 0, 4096); - } - return &m_pages[page_num][paddr.getAddress()&m_page_offset_mask]; + uint32 page_num = paddr.getAddress() >> 12; + if (m_pages[page_num] == 0) { + m_pages[page_num] = new uint8[4096]; + memset(m_pages[page_num], 0, 4096); + } + return &m_pages[page_num][paddr.getAddress()&m_page_offset_mask]; } -#endif // MEMORYVECTOR_H +#endif // __MEM_RUBY_SYSTEM_MEMORYVECTOR_HH__ diff --git a/src/mem/ruby/system/NodeID.hh b/src/mem/ruby/system/NodeID.hh index 6191ad489..4ce8d8a8d 100644 --- a/src/mem/ruby/system/NodeID.hh +++ b/src/mem/ruby/system/NodeID.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,26 +26,20 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * NodeID.hh - * - * Description: - * - * $Id: NodeID.hh,v 3.3 2003/12/04 15:01:39 xu Exp $ - * - */ - -#ifndef NODEID_H -#define NODEID_H +#ifndef __MEM_RUBY_SYSTEM_NODEID_HH__ +#define __MEM_RUBY_SYSTEM_NODEID_HH__ #include <string> -#include "mem/ruby/common/Global.hh" #include "mem/gems_common/util.hh" +#include "mem/ruby/common/Global.hh" typedef int NodeID; -extern inline -std::string NodeIDToString (NodeID node) { return int_to_string(node); } +inline std::string +NodeIDToString(NodeID node) +{ + return int_to_string(node); +} -#endif //NODEID_H +#endif // __MEM_RUBY_SYSTEM_NODEID_HH__ diff --git a/src/mem/ruby/system/PerfectCacheMemory.hh b/src/mem/ruby/system/PerfectCacheMemory.hh index 6561d028b..f1fb8b2e9 100644 --- a/src/mem/ruby/system/PerfectCacheMemory.hh +++ b/src/mem/ruby/system/PerfectCacheMemory.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,215 +26,188 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * PerfectCacheMemory.hh - * - * Description: - * - * $Id$ - * - */ - -#ifndef PERFECTCACHEMEMORY_H -#define PERFECTCACHEMEMORY_H +#ifndef __MEM_RUBY_SYSTEM_PERFECTCACHEMEMORY_HH__ +#define __MEM_RUBY_SYSTEM_PERFECTCACHEMEMORY_HH__ -#include "mem/ruby/common/Global.hh" #include "mem/gems_common/Map.hh" #include "mem/protocol/AccessPermission.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" template<class ENTRY> -class PerfectCacheLineState { -public: - PerfectCacheLineState() { m_permission = AccessPermission_NUM; } - AccessPermission m_permission; - ENTRY m_entry; +struct PerfectCacheLineState +{ + PerfectCacheLineState() { m_permission = AccessPermission_NUM; } + AccessPermission m_permission; + ENTRY m_entry; }; template<class ENTRY> -extern inline -ostream& operator<<(ostream& out, const PerfectCacheLineState<ENTRY>& obj) +inline ostream& +operator<<(ostream& out, const PerfectCacheLineState<ENTRY>& obj) { - return out; + return out; } template<class ENTRY> -class PerfectCacheMemory { -public: - - // Constructors - PerfectCacheMemory(); - - // Destructor - //~PerfectCacheMemory(); - - // Public Methods +class PerfectCacheMemory +{ + public: + PerfectCacheMemory(); - static void printConfig(ostream& out); + static void printConfig(ostream& out); - // perform a cache access and see if we hit or not. Return true on - // a hit. - bool tryCacheAccess(const CacheMsg& msg, bool& block_stc, ENTRY*& entry); + // perform a cache access and see if we hit or not. Return true + // on a hit. + bool tryCacheAccess(const CacheMsg& msg, bool& block_stc, ENTRY*& entry); - // tests to see if an address is present in the cache - bool isTagPresent(const Address& address) const; + // tests to see if an address is present in the cache + bool isTagPresent(const Address& address) const; - // Returns true if there is: - // a) a tag match on this address or there is - // b) an Invalid line in the same cache "way" - bool cacheAvail(const Address& address) const; + // Returns true if there is: + // a) a tag match on this address or there is + // b) an Invalid line in the same cache "way" + bool cacheAvail(const Address& address) const; - // find an Invalid entry and sets the tag appropriate for the address - void allocate(const Address& address); + // find an Invalid entry and sets the tag appropriate for the address + void allocate(const Address& address); - void deallocate(const Address& address); + void deallocate(const Address& address); - // Returns with the physical address of the conflicting cache line - Address cacheProbe(const Address& newAddress) const; + // Returns with the physical address of the conflicting cache line + Address cacheProbe(const Address& newAddress) const; - // looks an address up in the cache - ENTRY& lookup(const Address& address); - const ENTRY& lookup(const Address& address) const; + // looks an address up in the cache + ENTRY& lookup(const Address& address); + const ENTRY& lookup(const Address& address) const; - // Get/Set permission of cache block - AccessPermission getPermission(const Address& address) const; - void changePermission(const Address& address, AccessPermission new_perm); + // Get/Set permission of cache block + AccessPermission getPermission(const Address& address) const; + void changePermission(const Address& address, AccessPermission new_perm); - // Print cache contents - void print(ostream& out) const; -private: - // Private Methods + // Print cache contents + void print(ostream& out) const; - // Private copy constructor and assignment operator - PerfectCacheMemory(const PerfectCacheMemory& obj); - PerfectCacheMemory& operator=(const PerfectCacheMemory& obj); + private: + // Private copy constructor and assignment operator + PerfectCacheMemory(const PerfectCacheMemory& obj); + PerfectCacheMemory& operator=(const PerfectCacheMemory& obj); - // Data Members (m_prefix) - Map<Address, PerfectCacheLineState<ENTRY> > m_map; + // Data Members (m_prefix) + Map<Address, PerfectCacheLineState<ENTRY> > m_map; }; -// Output operator declaration -//ostream& operator<<(ostream& out, const PerfectCacheMemory<ENTRY>& obj); - -// ******************* Definitions ******************* - -// Output operator definition template<class ENTRY> -extern inline -ostream& operator<<(ostream& out, const PerfectCacheMemory<ENTRY>& obj) +inline ostream& +operator<<(ostream& out, const PerfectCacheMemory<ENTRY>& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } - -// **************************************************************** - template<class ENTRY> -extern inline +inline PerfectCacheMemory<ENTRY>::PerfectCacheMemory() { } -// STATIC METHODS - template<class ENTRY> -extern inline -void PerfectCacheMemory<ENTRY>::printConfig(ostream& out) +inline void +PerfectCacheMemory<ENTRY>::printConfig(ostream& out) { } -// PUBLIC METHODS - template<class ENTRY> -extern inline -bool PerfectCacheMemory<ENTRY>::tryCacheAccess(const CacheMsg& msg, bool& block_stc, ENTRY*& entry) +inline bool +PerfectCacheMemory<ENTRY>::tryCacheAccess(const CacheMsg& msg, + bool& block_stc, ENTRY*& entry) { - ERROR_MSG("not implemented"); + ERROR_MSG("not implemented"); } // tests to see if an address is present in the cache template<class ENTRY> -extern inline -bool PerfectCacheMemory<ENTRY>::isTagPresent(const Address& address) const +inline bool +PerfectCacheMemory<ENTRY>::isTagPresent(const Address& address) const { - return m_map.exist(line_address(address)); + return m_map.exist(line_address(address)); } template<class ENTRY> -extern inline -bool PerfectCacheMemory<ENTRY>::cacheAvail(const Address& address) const +inline bool +PerfectCacheMemory<ENTRY>::cacheAvail(const Address& address) const { - return true; + return true; } // find an Invalid or already allocated entry and sets the tag // appropriate for the address template<class ENTRY> -extern inline -void PerfectCacheMemory<ENTRY>::allocate(const Address& address) +inline void +PerfectCacheMemory<ENTRY>::allocate(const Address& address) { - PerfectCacheLineState<ENTRY> line_state; - line_state.m_permission = AccessPermission_Busy; - line_state.m_entry = ENTRY(); - m_map.add(line_address(address), line_state); + PerfectCacheLineState<ENTRY> line_state; + line_state.m_permission = AccessPermission_Busy; + line_state.m_entry = ENTRY(); + m_map.add(line_address(address), line_state); } // deallocate entry template<class ENTRY> -extern inline -void PerfectCacheMemory<ENTRY>::deallocate(const Address& address) +inline void +PerfectCacheMemory<ENTRY>::deallocate(const Address& address) { - m_map.erase(line_address(address)); + m_map.erase(line_address(address)); } // Returns with the physical address of the conflicting cache line template<class ENTRY> -extern inline -Address PerfectCacheMemory<ENTRY>::cacheProbe(const Address& newAddress) const +inline Address +PerfectCacheMemory<ENTRY>::cacheProbe(const Address& newAddress) const { - ERROR_MSG("cacheProbe called in perfect cache"); + ERROR_MSG("cacheProbe called in perfect cache"); } // looks an address up in the cache template<class ENTRY> -extern inline -ENTRY& PerfectCacheMemory<ENTRY>::lookup(const Address& address) +inline ENTRY& +PerfectCacheMemory<ENTRY>::lookup(const Address& address) { - return m_map.lookup(line_address(address)).m_entry; + return m_map.lookup(line_address(address)).m_entry; } // looks an address up in the cache template<class ENTRY> -extern inline -const ENTRY& PerfectCacheMemory<ENTRY>::lookup(const Address& address) const +inline const ENTRY& +PerfectCacheMemory<ENTRY>::lookup(const Address& address) const { - return m_map.lookup(line_address(address)).m_entry; + return m_map.lookup(line_address(address)).m_entry; } template<class ENTRY> -extern inline -AccessPermission PerfectCacheMemory<ENTRY>::getPermission(const Address& address) const +inline AccessPermission +PerfectCacheMemory<ENTRY>::getPermission(const Address& address) const { - return m_map.lookup(line_address(address)).m_permission; + return m_map.lookup(line_address(address)).m_permission; } template<class ENTRY> -extern inline -void PerfectCacheMemory<ENTRY>::changePermission(const Address& address, AccessPermission new_perm) +inline void +PerfectCacheMemory<ENTRY>::changePermission(const Address& address, + AccessPermission new_perm) { - Address line_address = address; - line_address.makeLineAddress(); - PerfectCacheLineState<ENTRY>& line_state = m_map.lookup(line_address); - AccessPermission old_perm = line_state.m_permission; - line_state.m_permission = new_perm; + Address line_address = address; + line_address.makeLineAddress(); + PerfectCacheLineState<ENTRY>& line_state = m_map.lookup(line_address); + AccessPermission old_perm = line_state.m_permission; + line_state.m_permission = new_perm; } template<class ENTRY> -extern inline -void PerfectCacheMemory<ENTRY>::print(ostream& out) const +inline void +PerfectCacheMemory<ENTRY>::print(ostream& out) const { } -#endif //PERFECTCACHEMEMORY_H +#endif // __MEM_RUBY_SYSTEM_PERFECTCACHEMEMORY_HH__ diff --git a/src/mem/ruby/system/PersistentTable.cc b/src/mem/ruby/system/PersistentTable.cc index 58b67ea60..1d971ae21 100644 --- a/src/mem/ruby/system/PersistentTable.cc +++ b/src/mem/ruby/system/PersistentTable.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,178 +26,187 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "mem/ruby/system/PersistentTable.hh" #include "mem/gems_common/util.hh" +#include "mem/ruby/system/PersistentTable.hh" // randomize so that handoffs are not locality-aware -// int persistent_randomize[] = {0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15}; -// int persistent_randomize[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; - +#if 0 +int persistent_randomize[] = {0, 4, 8, 12, 1, 5, 9, 13, 2, 6, + 10, 14, 3, 7, 11, 15}; +int persistent_randomize[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15}; +#endif PersistentTable::PersistentTable() { - m_map_ptr = new Map<Address, PersistentTableEntry>; + m_map_ptr = new Map<Address, PersistentTableEntry>; } PersistentTable::~PersistentTable() { - delete m_map_ptr; - m_map_ptr = NULL; + delete m_map_ptr; + m_map_ptr = NULL; } -void PersistentTable::persistentRequestLock(const Address& address, - MachineID locker, - AccessType type) +void +PersistentTable::persistentRequestLock(const Address& address, + MachineID locker, + AccessType type) { - - // if (locker == m_chip_ptr->getID() ) - // cout << "Chip " << m_chip_ptr->getID() << ": " << llocker - // << " requesting lock for " << address << endl; - - // MachineID locker = (MachineID) persistent_randomize[llocker]; - - assert(address == line_address(address)); - if (!m_map_ptr->exist(address)) { - // Allocate if not present - PersistentTableEntry entry; - entry.m_starving.add(locker); - if (type == AccessType_Write) { - entry.m_request_to_write.add(locker); +#if 0 + if (locker == m_chip_ptr->getID()) + cout << "Chip " << m_chip_ptr->getID() << ": " << llocker + << " requesting lock for " << address << endl; + + MachineID locker = (MachineID) persistent_randomize[llocker]; +#endif + + assert(address == line_address(address)); + if (!m_map_ptr->exist(address)) { + // Allocate if not present + PersistentTableEntry entry; + entry.m_starving.add(locker); + if (type == AccessType_Write) { + entry.m_request_to_write.add(locker); + } + m_map_ptr->add(address, entry); + } else { + PersistentTableEntry& entry = m_map_ptr->lookup(address); + + // + // Make sure we're not already in the locked set + // + assert(!(entry.m_starving.isElement(locker))); + + entry.m_starving.add(locker); + if (type == AccessType_Write) { + entry.m_request_to_write.add(locker); + } + assert(entry.m_marked.isSubset(entry.m_starving)); } - m_map_ptr->add(address, entry); - } else { +} + +void +PersistentTable::persistentRequestUnlock(const Address& address, + MachineID unlocker) +{ +#if 0 + if (unlocker == m_chip_ptr->getID()) + cout << "Chip " << m_chip_ptr->getID() << ": " << uunlocker + << " requesting unlock for " << address << endl; + + MachineID unlocker = (MachineID) persistent_randomize[uunlocker]; +#endif + + assert(address == line_address(address)); + assert(m_map_ptr->exist(address)); PersistentTableEntry& entry = m_map_ptr->lookup(address); // - // Make sure we're not already in the locked set + // Make sure we're in the locked set // - assert(!(entry.m_starving.isElement(locker))); - - entry.m_starving.add(locker); - if (type == AccessType_Write) { - entry.m_request_to_write.add(locker); - } + assert(entry.m_starving.isElement(unlocker)); + assert(entry.m_marked.isSubset(entry.m_starving)); + entry.m_starving.remove(unlocker); + entry.m_marked.remove(unlocker); + entry.m_request_to_write.remove(unlocker); assert(entry.m_marked.isSubset(entry.m_starving)); - } -} -void PersistentTable::persistentRequestUnlock(const Address& address, - MachineID unlocker) -{ - // if (unlocker == m_chip_ptr->getID() ) - // cout << "Chip " << m_chip_ptr->getID() << ": " << uunlocker - // << " requesting unlock for " << address << endl; - - // MachineID unlocker = (MachineID) persistent_randomize[uunlocker]; - - assert(address == line_address(address)); - assert(m_map_ptr->exist(address)); - PersistentTableEntry& entry = m_map_ptr->lookup(address); - - // - // Make sure we're in the locked set - // - assert(entry.m_starving.isElement(unlocker)); - assert(entry.m_marked.isSubset(entry.m_starving)); - entry.m_starving.remove(unlocker); - entry.m_marked.remove(unlocker); - entry.m_request_to_write.remove(unlocker); - assert(entry.m_marked.isSubset(entry.m_starving)); - - // Deallocate if empty - if (entry.m_starving.isEmpty()) { - assert(entry.m_marked.isEmpty()); - m_map_ptr->erase(address); - } + // Deallocate if empty + if (entry.m_starving.isEmpty()) { + assert(entry.m_marked.isEmpty()); + m_map_ptr->erase(address); + } } -bool PersistentTable::okToIssueStarving(const Address& address, - MachineID machId) const +bool +PersistentTable::okToIssueStarving(const Address& address, + MachineID machId) const { - assert(address == line_address(address)); - if (!m_map_ptr->exist(address)) { - // - // No entry present - // - return true; - } else if (m_map_ptr->lookup(address).m_starving.isElement(machId)) { - // - // We can't issue another lockdown until are previous unlock has occurred - // - return false; - } else { - return (m_map_ptr->lookup(address).m_marked.isEmpty()); - } + assert(address == line_address(address)); + if (!m_map_ptr->exist(address)) { + // No entry present + return true; + } else if (m_map_ptr->lookup(address).m_starving.isElement(machId)) { + // We can't issue another lockdown until are previous unlock + // has occurred + return false; + } else { + return m_map_ptr->lookup(address).m_marked.isEmpty(); + } } -MachineID PersistentTable::findSmallest(const Address& address) const +MachineID +PersistentTable::findSmallest(const Address& address) const { - assert(address == line_address(address)); - assert(m_map_ptr->exist(address)); - const PersistentTableEntry& entry = m_map_ptr->lookup(address); - return entry.m_starving.smallestElement(); + assert(address == line_address(address)); + assert(m_map_ptr->exist(address)); + const PersistentTableEntry& entry = m_map_ptr->lookup(address); + return entry.m_starving.smallestElement(); } -AccessType PersistentTable::typeOfSmallest(const Address& address) const +AccessType +PersistentTable::typeOfSmallest(const Address& address) const { - assert(address == line_address(address)); - assert(m_map_ptr->exist(address)); - const PersistentTableEntry& entry = m_map_ptr->lookup(address); - if (entry.m_request_to_write.isElement(entry.m_starving.smallestElement())) { - return AccessType_Write; - } else { - return AccessType_Read; - } + assert(address == line_address(address)); + assert(m_map_ptr->exist(address)); + const PersistentTableEntry& entry = m_map_ptr->lookup(address); + if (entry.m_request_to_write. + isElement(entry.m_starving.smallestElement())) { + return AccessType_Write; + } else { + return AccessType_Read; + } } -void PersistentTable::markEntries(const Address& address) +void +PersistentTable::markEntries(const Address& address) { - assert(address == line_address(address)); - if (m_map_ptr->exist(address)) { - PersistentTableEntry& entry = m_map_ptr->lookup(address); + assert(address == line_address(address)); + if (m_map_ptr->exist(address)) { + PersistentTableEntry& entry = m_map_ptr->lookup(address); - // - // None should be marked - // - assert(entry.m_marked.isEmpty()); + // None should be marked + assert(entry.m_marked.isEmpty()); - // - // Mark all the nodes currently in the table - // - entry.m_marked = entry.m_starving; - } + // Mark all the nodes currently in the table + entry.m_marked = entry.m_starving; + } } -bool PersistentTable::isLocked(const Address& address) const +bool +PersistentTable::isLocked(const Address& address) const { - assert(address == line_address(address)); - // If an entry is present, it must be locked - return (m_map_ptr->exist(address)); + assert(address == line_address(address)); + + // If an entry is present, it must be locked + return m_map_ptr->exist(address); } -int PersistentTable::countStarvingForAddress(const Address& address) const +int +PersistentTable::countStarvingForAddress(const Address& address) const { - if (m_map_ptr->exist(address)) { - PersistentTableEntry& entry = m_map_ptr->lookup(address); - return (entry.m_starving.count()); - } - else { - return 0; - } + if (m_map_ptr->exist(address)) { + PersistentTableEntry& entry = m_map_ptr->lookup(address); + return (entry.m_starving.count()); + } else { + return 0; + } } -int PersistentTable::countReadStarvingForAddress(const Address& address) const +int +PersistentTable::countReadStarvingForAddress(const Address& address) const { - if (m_map_ptr->exist(address)) { - PersistentTableEntry& entry = m_map_ptr->lookup(address); - return (entry.m_starving.count() - entry.m_request_to_write.count()); - } - else { - return 0; - } + if (m_map_ptr->exist(address)) { + PersistentTableEntry& entry = m_map_ptr->lookup(address); + return (entry.m_starving.count() - entry.m_request_to_write.count()); + } else { + return 0; + } } -void PersistentTable::print(ostream& out) const +void +PersistentTable::print(ostream& out) const { } diff --git a/src/mem/ruby/system/PersistentTable.hh b/src/mem/ruby/system/PersistentTable.hh index 8cbb48817..defcae2b8 100644 --- a/src/mem/ruby/system/PersistentTable.hh +++ b/src/mem/ruby/system/PersistentTable.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,76 +26,74 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef PersistentTable_H -#define PersistentTable_H +#ifndef __MEM_RUBY_SYSTEM_PERSISTENTTABLE_HH__ +#define __MEM_RUBY_SYSTEM_PERSISTENTTABLE_HH__ -#include "mem/ruby/common/Global.hh" #include "mem/gems_common/Map.hh" -#include "mem/ruby/common/Address.hh" -#include "mem/ruby/system/MachineID.hh" #include "mem/protocol/AccessType.hh" +#include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/common/NetDest.hh" +#include "mem/ruby/system/MachineID.hh" -class PersistentTableEntry { -public: - void print(ostream& out) const {} +class PersistentTableEntry +{ + public: + void print(ostream& out) const {} - NetDest m_starving; - NetDest m_marked; - NetDest m_request_to_write; + NetDest m_starving; + NetDest m_marked; + NetDest m_request_to_write; }; -class PersistentTable { -public: - // Constructors - PersistentTable(); +class PersistentTable +{ + public: + // Constructors + PersistentTable(); - // Destructor - ~PersistentTable(); + // Destructor + ~PersistentTable(); - // Public Methods - void persistentRequestLock(const Address& address, MachineID locker, AccessType type); - void persistentRequestUnlock(const Address& address, MachineID unlocker); - bool okToIssueStarving(const Address& address, MachineID machID) const; - MachineID findSmallest(const Address& address) const; - AccessType typeOfSmallest(const Address& address) const; - void markEntries(const Address& address); - bool isLocked(const Address& addr) const; - int countStarvingForAddress(const Address& addr) const; - int countReadStarvingForAddress(const Address& addr) const; + // Public Methods + void persistentRequestLock(const Address& address, MachineID locker, + AccessType type); + void persistentRequestUnlock(const Address& address, MachineID unlocker); + bool okToIssueStarving(const Address& address, MachineID machID) const; + MachineID findSmallest(const Address& address) const; + AccessType typeOfSmallest(const Address& address) const; + void markEntries(const Address& address); + bool isLocked(const Address& addr) const; + int countStarvingForAddress(const Address& addr) const; + int countReadStarvingForAddress(const Address& addr) const; - static void printConfig(ostream& out) {} + static void printConfig(ostream& out) {} - void print(ostream& out) const; -private: - // Private Methods + void print(ostream& out) const; - // Private copy constructor and assignment operator - PersistentTable(const PersistentTable& obj); - PersistentTable& operator=(const PersistentTable& obj); + private: + // Private copy constructor and assignment operator + PersistentTable(const PersistentTable& obj); + PersistentTable& operator=(const PersistentTable& obj); - // Data Members (m_prefix) - Map<Address, PersistentTableEntry>* m_map_ptr; + // Data Members (m_prefix) + Map<Address, PersistentTableEntry>* m_map_ptr; }; -// ******************* Definitions ******************* - -// Output operator definition -extern inline -ostream& operator<<(ostream& out, const PersistentTable& obj) +inline ostream& +operator<<(ostream& out, const PersistentTable& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } -// Output operator definition -extern inline -ostream& operator<<(ostream& out, const PersistentTableEntry& obj) +inline ostream& +operator<<(ostream& out, const PersistentTableEntry& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } -#endif //PersistentTable_H +#endif // __MEM_RUBY_SYSTEM_PERSISTENTTABLE_HH__ diff --git a/src/mem/ruby/system/PseudoLRUPolicy.hh b/src/mem/ruby/system/PseudoLRUPolicy.hh index 61bf72c3e..1e1e68188 100644 --- a/src/mem/ruby/system/PseudoLRUPolicy.hh +++ b/src/mem/ruby/system/PseudoLRUPolicy.hh @@ -26,8 +26,8 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef PSEUDOLRUPOLICY_H -#define PSEUDOLRUPOLICY_H +#ifndef __MEM_RUBY_SYSTEM_PSEUDOLRUPOLICY_HH__ +#define __MEM_RUBY_SYSTEM_PSEUDOLRUPOLICY_HH__ #include "mem/ruby/system/AbstractReplacementPolicy.hh" @@ -44,94 +44,97 @@ * 2 is one below the associativy, and most fair when it is one above. */ -class PseudoLRUPolicy : public AbstractReplacementPolicy { - public: - - PseudoLRUPolicy(Index num_sets, Index assoc); - ~PseudoLRUPolicy(); - - void touch(Index set, Index way, Time time); - Index getVictim(Index set) const; - - private: - unsigned int m_effective_assoc; /** nearest (to ceiling) power of 2 */ - unsigned int m_num_levels; /** number of levels in the tree */ - uint64* m_trees; /** bit representation of the trees, one for each set */ +class PseudoLRUPolicy : public AbstractReplacementPolicy +{ + public: + PseudoLRUPolicy(Index num_sets, Index assoc); + ~PseudoLRUPolicy(); + + void touch(Index set, Index way, Time time); + Index getVictim(Index set) const; + + private: + unsigned int m_effective_assoc; /** nearest (to ceiling) power of 2 */ + unsigned int m_num_levels; /** number of levels in the tree */ + uint64* m_trees; /** bit representation of the + * trees, one for each set */ }; inline PseudoLRUPolicy::PseudoLRUPolicy(Index num_sets, Index assoc) - : AbstractReplacementPolicy(num_sets, assoc) + : AbstractReplacementPolicy(num_sets, assoc) { - int num_tree_nodes; - - // associativity cannot exceed capacity of tree representation - assert(num_sets > 0 && assoc > 1 && assoc <= (Index) sizeof(uint64)*4); - - m_trees = NULL; - m_num_levels = 0; - - m_effective_assoc = 1; - while(m_effective_assoc < assoc){ - m_effective_assoc <<= 1; // effective associativity is ceiling power of 2 - } - assoc = m_effective_assoc; - while(true){ - assoc /= 2; - if(!assoc) break; - m_num_levels++; - } - assert(m_num_levels < sizeof(unsigned int)*4); - num_tree_nodes = (1 << m_num_levels) - 1; - m_trees = new uint64[m_num_sets]; - for(unsigned int i=0; i< m_num_sets; i++){ - m_trees[i] = 0; - } + int num_tree_nodes; + + // associativity cannot exceed capacity of tree representation + assert(num_sets > 0 && assoc > 1 && assoc <= (Index) sizeof(uint64)*4); + + m_trees = NULL; + m_num_levels = 0; + + m_effective_assoc = 1; + while (m_effective_assoc < assoc) { + // effective associativity is ceiling power of 2 + m_effective_assoc <<= 1; + } + assoc = m_effective_assoc; + while (true) { + assoc /= 2; + if(!assoc) break; + m_num_levels++; + } + assert(m_num_levels < sizeof(unsigned int)*4); + num_tree_nodes = (1 << m_num_levels) - 1; + m_trees = new uint64[m_num_sets]; + for (unsigned i = 0; i < m_num_sets; i++) { + m_trees[i] = 0; + } } inline PseudoLRUPolicy::~PseudoLRUPolicy() { - if(m_trees != NULL) - delete[] m_trees; + if (m_trees != NULL) + delete[] m_trees; } -inline -void PseudoLRUPolicy::touch(Index set, Index index, Time time){ - assert(index >= 0 && index < m_assoc); - assert(set >= 0 && set < m_num_sets); - - int tree_index = 0; - int node_val; - for(int i=m_num_levels -1; i>=0; i--){ - node_val = (index >> i)&1; - if(node_val) - m_trees[set] |= node_val << tree_index; - else - m_trees[set] &= ~(1 << tree_index); - tree_index = node_val ? (tree_index*2)+2 : (tree_index*2)+1; - } - m_last_ref_ptr[set][index] = time; +inline void +PseudoLRUPolicy::touch(Index set, Index index, Time time) +{ + assert(index >= 0 && index < m_assoc); + assert(set >= 0 && set < m_num_sets); + + int tree_index = 0; + int node_val; + for (int i = m_num_levels - 1; i >= 0; i--) { + node_val = (index >> i)&1; + if (node_val) + m_trees[set] |= node_val << tree_index; + else + m_trees[set] &= ~(1 << tree_index); + tree_index = node_val ? (tree_index*2)+2 : (tree_index*2)+1; + } + m_last_ref_ptr[set][index] = time; } -inline -Index PseudoLRUPolicy::getVictim(Index set) const { - // assert(m_assoc != 0); - - Index index = 0; - - int tree_index = 0; - int node_val; - for(unsigned int i=0;i<m_num_levels;i++){ - node_val = (m_trees[set]>>tree_index)&1; - index += node_val?0:(m_effective_assoc >> (i+1)); - tree_index = node_val? (tree_index*2)+1 : (tree_index*2)+2; - } - assert(index >= 0 && index < m_effective_assoc); - - /* return either the found index or the max possible index */ - /* NOTE: this is not a fair replacement when assoc is not a power of 2 */ - return (index > (m_assoc-1)) ? m_assoc-1:index; +inline Index +PseudoLRUPolicy::getVictim(Index set) const +{ + // assert(m_assoc != 0); + Index index = 0; + + int tree_index = 0; + int node_val; + for (unsigned i = 0; i < m_num_levels; i++){ + node_val = (m_trees[set] >> tree_index) & 1; + index += node_val ? 0 : (m_effective_assoc >> (i + 1)); + tree_index = node_val ? (tree_index * 2) + 1 : (tree_index * 2) + 2; + } + assert(index >= 0 && index < m_effective_assoc); + + /* return either the found index or the max possible index */ + /* NOTE: this is not a fair replacement when assoc is not a power of 2 */ + return (index > (m_assoc - 1)) ? m_assoc - 1 : index; } -#endif // PSEUDOLRUPOLICY_H +#endif // __MEM_RUBY_SYSTEM_PSEUDOLRUPOLICY_HH__ diff --git a/src/mem/ruby/system/RubyPort.cc b/src/mem/ruby/system/RubyPort.cc index 480c13ad8..87a98185c 100644 --- a/src/mem/ruby/system/RubyPort.cc +++ b/src/mem/ruby/system/RubyPort.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 2009 Advanced Micro Devices, Inc. * All rights reserved. @@ -27,10 +26,10 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#include "cpu/rubytest/RubyTester.hh" #include "mem/physical.hh" -#include "mem/ruby/system/RubyPort.hh" #include "mem/ruby/slicc_interface/AbstractController.hh" -#include "cpu/rubytest/RubyTester.hh" +#include "mem/ruby/system/RubyPort.hh" RubyPort::RubyPort(const Params *p) : MemObject(p) @@ -39,7 +38,7 @@ RubyPort::RubyPort(const Params *p) assert(m_version != -1); physmem = p->physmem; - + m_controller = NULL; m_mandatory_q_ptr = NULL; @@ -48,7 +47,8 @@ RubyPort::RubyPort(const Params *p) physMemPort = NULL; } -void RubyPort::init() +void +RubyPort::init() { assert(m_controller != NULL); m_mandatory_q_ptr = m_controller->getMandatoryQueue(); @@ -59,38 +59,38 @@ RubyPort::getPort(const std::string &if_name, int idx) { if (if_name == "port") { return new M5Port(csprintf("%s-port%d", name(), idx), this); - } else if (if_name == "pio_port") { - // + } + + if (if_name == "pio_port") { // ensure there is only one pio port - // assert(pio_port == NULL); - pio_port = new PioPort(csprintf("%s-pio-port%d", name(), idx), - this); + pio_port = new PioPort(csprintf("%s-pio-port%d", name(), idx), this); return pio_port; - } else if (if_name == "physMemPort") { - // + } + + if (if_name == "physMemPort") { // RubyPort should only have one port to physical memory - // assert (physMemPort == NULL); - physMemPort = new M5Port(csprintf("%s-physMemPort", name()), - this); - + physMemPort = new M5Port(csprintf("%s-physMemPort", name()), this); + return physMemPort; - } else if (if_name == "functional") { - // - // Calls for the functional port only want to access functional memory. - // Therefore, directly pass these calls ports to physmem. - // + } + + if (if_name == "functional") { + // Calls for the functional port only want to access + // functional memory. Therefore, directly pass these calls + // ports to physmem. assert(physmem != NULL); return physmem->getPort(if_name, idx); } + return NULL; } -RubyPort::PioPort::PioPort(const std::string &_name, +RubyPort::PioPort::PioPort(const std::string &_name, RubyPort *_port) : SimpleTimingPort(_name, _port) { @@ -98,7 +98,7 @@ RubyPort::PioPort::PioPort(const std::string &_name, ruby_port = _port; } -RubyPort::M5Port::M5Port(const std::string &_name, +RubyPort::M5Port::M5Port(const std::string &_name, RubyPort *_port) : SimpleTimingPort(_name, _port) { @@ -113,7 +113,6 @@ RubyPort::PioPort::recvAtomic(PacketPtr pkt) return 0; } - Tick RubyPort::M5Port::recvAtomic(PacketPtr pkt) { @@ -125,48 +124,39 @@ RubyPort::M5Port::recvAtomic(PacketPtr pkt) bool RubyPort::PioPort::recvTiming(PacketPtr pkt) { - // - // In FS mode, ruby memory will receive pio responses from devices and - // it must forward these responses back to the particular CPU. - // - DPRINTF(MemoryAccess, - "Pio response for address %#x\n", - pkt->getAddr()); + // In FS mode, ruby memory will receive pio responses from devices + // and it must forward these responses back to the particular CPU. + DPRINTF(MemoryAccess, "Pio response for address %#x\n", pkt->getAddr()); assert(pkt->isResponse()); - // // First we must retrieve the request port from the sender State - // - RubyPort::SenderState *senderState = + RubyPort::SenderState *senderState = safe_cast<RubyPort::SenderState *>(pkt->senderState); M5Port *port = senderState->port; assert(port != NULL); - + // pop the sender state from the packet pkt->senderState = senderState->saved; delete senderState; - + port->sendTiming(pkt); - + return true; } bool RubyPort::M5Port::recvTiming(PacketPtr pkt) { - DPRINTF(MemoryAccess, - "Timing access caught for address %#x\n", - pkt->getAddr()); + DPRINTF(MemoryAccess, + "Timing access caught for address %#x\n", pkt->getAddr()); //dsm: based on SimpleTimingPort::recvTiming(pkt); - // - // The received packets should only be M5 requests, which should never - // get nacked. There used to be code to hanldle nacks here, but - // I'm pretty sure it didn't work correctly with the drain code, + // The received packets should only be M5 requests, which should never + // get nacked. There used to be code to hanldle nacks here, but + // I'm pretty sure it didn't work correctly with the drain code, // so that would need to be fixed if we ever added it back. - // assert(pkt->isRequest()); if (pkt->memInhibitAsserted()) { @@ -177,34 +167,26 @@ RubyPort::M5Port::recvTiming(PacketPtr pkt) return true; } - // // Save the port in the sender state object to be used later to // route the response - // pkt->senderState = new SenderState(this, pkt->senderState); - // // Check for pio requests and directly send them to the dedicated // pio port. - // if (!isPhysMemAddress(pkt->getAddr())) { assert(ruby_port->pio_port != NULL); - DPRINTF(MemoryAccess, + DPRINTF(MemoryAccess, "Request for address 0x%#x is assumed to be a pio request\n", pkt->getAddr()); return ruby_port->pio_port->sendTiming(pkt); } - // // For DMA and CPU requests, translate them to ruby requests before // sending them to our assigned ruby port. - // RubyRequestType type = RubyRequestType_NULL; - // // If valid, copy the pc to the ruby request - // Addr pc = 0; if (pkt->req->hasPC()) { pc = pkt->req->getPC(); @@ -224,47 +206,38 @@ RubyPort::M5Port::recvTiming(PacketPtr pkt) if (pkt->req->isInstFetch()) { type = RubyRequestType_IFETCH; } else { - type = RubyRequestType_LD; + type = RubyRequestType_LD; } } else if (pkt->isWrite()) { type = RubyRequestType_ST; } else if (pkt->isReadWrite()) { - // - // Fix me. This conditional will never be executed because - // isReadWrite() is just an OR of isRead() and isWrite(). - // Furthermore, just because the packet is a read/write request does - // not necessary mean it is a read-modify-write atomic operation. - // + // Fix me. This conditional will never be executed + // because isReadWrite() is just an OR of isRead() and + // isWrite(). Furthermore, just because the packet is a + // read/write request does not necessary mean it is a + // read-modify-write atomic operation. type = RubyRequestType_RMW_Write; } else { panic("Unsupported ruby packet type\n"); } } - RubyRequest ruby_request(pkt->getAddr(), - pkt->getPtr<uint8_t>(), - pkt->getSize(), - pc, - type, - RubyAccessMode_Supervisor, - pkt); + RubyRequest ruby_request(pkt->getAddr(), pkt->getPtr<uint8_t>(), + pkt->getSize(), pc, type, + RubyAccessMode_Supervisor, pkt); // Submit the ruby request RequestStatus requestStatus = ruby_port->makeRequest(ruby_request); - // // If the request successfully issued or the SC request completed because // exclusive permission was lost, then we should return true. // Otherwise, we need to delete the senderStatus we just created and return // false. - // if ((requestStatus == RequestStatus_Issued) || (requestStatus == RequestStatus_LlscFailed)) { - // // The communicate to M5 whether the SC command succeeded by seting the // packet's extra data. - // if (pkt->isLLSC() && pkt->isWrite()) { if (requestStatus == RequestStatus_LlscFailed) { DPRINTF(MemoryAccess, "SC failed and request completed\n"); @@ -276,11 +249,10 @@ RubyPort::M5Port::recvTiming(PacketPtr pkt) return true; } - DPRINTF(MemoryAccess, + DPRINTF(MemoryAccess, "Request for address #x did not issue because %s\n", - pkt->getAddr(), - RequestStatus_to_string(requestStatus)); - + pkt->getAddr(), RequestStatus_to_string(requestStatus)); + SenderState* senderState = safe_cast<SenderState*>(pkt->senderState); pkt->senderState = senderState->saved; delete senderState; @@ -290,14 +262,12 @@ RubyPort::M5Port::recvTiming(PacketPtr pkt) void RubyPort::ruby_hit_callback(PacketPtr pkt) { - // // Retrieve the request port from the sender State - // - RubyPort::SenderState *senderState = + RubyPort::SenderState *senderState = safe_cast<RubyPort::SenderState *>(pkt->senderState); M5Port *port = senderState->port; assert(port != NULL); - + // pop the sender state from the packet pkt->senderState = senderState->saved; delete senderState; @@ -308,11 +278,9 @@ RubyPort::ruby_hit_callback(PacketPtr pkt) void RubyPort::M5Port::hitCallback(PacketPtr pkt) { - bool needsResponse = pkt->needsResponse(); - DPRINTF(MemoryAccess, "Hit callback needs response %d\n", - needsResponse); + DPRINTF(MemoryAccess, "Hit callback needs response %d\n", needsResponse); ruby_port->physMemPort->sendAtomic(pkt); @@ -349,9 +317,9 @@ RubyPort::M5Port::isPhysMemAddress(Addr addr) AddrRangeList physMemAddrList; bool snoop = false; ruby_port->physMemPort->getPeerAddressRanges(physMemAddrList, snoop); - for(AddrRangeIter iter = physMemAddrList.begin(); - iter != physMemAddrList.end(); - iter++) { + for (AddrRangeIter iter = physMemAddrList.begin(); + iter != physMemAddrList.end(); + iter++) { if (addr >= iter->start && addr <= iter->end) { DPRINTF(MemoryAccess, "Request found in %#llx - %#llx range\n", iter->start, iter->end); diff --git a/src/mem/ruby/system/RubyPort.hh b/src/mem/ruby/system/RubyPort.hh index 3a862e068..4038c6007 100644 --- a/src/mem/ruby/system/RubyPort.hh +++ b/src/mem/ruby/system/RubyPort.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 2009 Advanced Micro Devices, Inc. * All rights reserved. @@ -27,18 +26,17 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef RUBYPORT_H -#define RUBYPORT_H +#ifndef __MEM_RUBY_SYSTEM_RUBYPORT_HH__ +#define __MEM_RUBY_SYSTEM_RUBYPORT_HH__ -#include "mem/ruby/libruby.hh" +#include <cassert> #include <string> -#include <assert.h> #include "mem/mem_object.hh" -#include "mem/tport.hh" #include "mem/physical.hh" #include "mem/protocol/RequestStatus.hh" - +#include "mem/ruby/libruby.hh" +#include "mem/tport.hh" #include "params/RubyPort.hh" using namespace std; @@ -46,17 +44,16 @@ using namespace std; class MessageBuffer; class AbstractController; -class RubyPort : public MemObject { -public: - +class RubyPort : public MemObject +{ + public: class M5Port : public SimpleTimingPort { - + private: RubyPort *ruby_port; public: - M5Port(const std::string &_name, - RubyPort *_port); + M5Port(const std::string &_name, RubyPort *_port); bool sendTiming(PacketPtr pkt); void hitCallback(PacketPtr pkt); @@ -72,12 +69,11 @@ public: class PioPort : public SimpleTimingPort { - + private: RubyPort *ruby_port; public: - PioPort(const std::string &_name, - RubyPort *_port); + PioPort(const std::string &_name, RubyPort *_port); bool sendTiming(PacketPtr pkt); protected: @@ -92,8 +88,7 @@ public: M5Port* port; Packet::SenderState *saved; - SenderState(M5Port* _port, - Packet::SenderState *sender_state = NULL) + SenderState(M5Port* _port, Packet::SenderState *sender_state = NULL) : port(_port), saved(sender_state) {} }; @@ -114,17 +109,17 @@ public: // void setController(AbstractController* _cntrl) { m_controller = _cntrl; } -protected: - const string m_name; - void ruby_hit_callback(PacketPtr pkt); - void hit(PacketPtr pkt); + protected: + const string m_name; + void ruby_hit_callback(PacketPtr pkt); + void hit(PacketPtr pkt); - int m_version; - AbstractController* m_controller; - MessageBuffer* m_mandatory_q_ptr; + int m_version; + AbstractController* m_controller; + MessageBuffer* m_mandatory_q_ptr; PioPort* pio_port; -private: + private: uint16_t m_port_id; uint64_t m_request_cnt; @@ -133,4 +128,4 @@ private: PhysicalMemory* physmem; }; -#endif +#endif // __MEM_RUBY_SYSTEM_RUBYPORT_HH__ diff --git a/src/mem/ruby/system/Sequencer.cc b/src/mem/ruby/system/Sequencer.cc index d6dba08f9..a473ccf44 100644 --- a/src/mem/ruby/system/Sequencer.cc +++ b/src/mem/ruby/system/Sequencer.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,22 +26,21 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "mem/ruby/libruby.hh" -#include "mem/ruby/common/Global.hh" -#include "mem/ruby/system/Sequencer.hh" -#include "mem/ruby/system/System.hh" -#include "mem/protocol/Protocol.hh" -#include "mem/ruby/profiler/Profiler.hh" -#include "mem/ruby/system/CacheMemory.hh" +#include "cpu/rubytest/RubyTester.hh" +#include "mem/gems_common/Map.hh" #include "mem/protocol/CacheMsg.hh" -#include "mem/ruby/recorder/Tracer.hh" -#include "mem/ruby/common/SubBlock.hh" #include "mem/protocol/Protocol.hh" -#include "mem/gems_common/Map.hh" +#include "mem/protocol/Protocol.hh" #include "mem/ruby/buffers/MessageBuffer.hh" +#include "mem/ruby/common/Global.hh" +#include "mem/ruby/common/SubBlock.hh" +#include "mem/ruby/libruby.hh" +#include "mem/ruby/profiler/Profiler.hh" +#include "mem/ruby/recorder/Tracer.hh" #include "mem/ruby/slicc_interface/AbstractController.hh" -#include "cpu/rubytest/RubyTester.hh" - +#include "mem/ruby/system/CacheMemory.hh" +#include "mem/ruby/system/Sequencer.hh" +#include "mem/ruby/system/System.hh" #include "params/RubySequencer.hh" Sequencer * @@ -50,7 +48,7 @@ RubySequencerParams::create() { return new Sequencer(this); } - + Sequencer::Sequencer(const Params *p) : RubyPort(p), deadlockCheckEvent(this) { @@ -58,7 +56,7 @@ Sequencer::Sequencer(const Params *p) m_store_waiting_on_store_cycles = 0; m_load_waiting_on_store_cycles = 0; m_load_waiting_on_load_cycles = 0; - + m_outstanding_count = 0; m_max_outstanding_requests = 0; @@ -78,478 +76,524 @@ Sequencer::Sequencer(const Params *p) assert(m_dataCache_ptr != NULL); } -Sequencer::~Sequencer() { - +Sequencer::~Sequencer() +{ } -void Sequencer::wakeup() { - // Check for deadlock of any of the requests - Time current_time = g_eventQueue_ptr->getTime(); - - // Check across all outstanding requests - int total_outstanding = 0; - - Vector<Address> keys = m_readRequestTable.keys(); - for (int i=0; i<keys.size(); i++) { - SequencerRequest* request = m_readRequestTable.lookup(keys[i]); - if (current_time - request->issue_time >= m_deadlock_threshold) { - WARN_MSG("Possible Deadlock detected"); - WARN_EXPR(request); - WARN_EXPR(m_version); - WARN_EXPR(request->ruby_request.paddr); - WARN_EXPR(keys.size()); - WARN_EXPR(current_time); - WARN_EXPR(request->issue_time); - WARN_EXPR(current_time - request->issue_time); - ERROR_MSG("Aborting"); +void +Sequencer::wakeup() +{ + // Check for deadlock of any of the requests + Time current_time = g_eventQueue_ptr->getTime(); + + // Check across all outstanding requests + int total_outstanding = 0; + + Vector<Address> keys = m_readRequestTable.keys(); + for (int i = 0; i < keys.size(); i++) { + SequencerRequest* request = m_readRequestTable.lookup(keys[i]); + if (current_time - request->issue_time >= m_deadlock_threshold) { + WARN_MSG("Possible Deadlock detected"); + WARN_EXPR(request); + WARN_EXPR(m_version); + WARN_EXPR(request->ruby_request.paddr); + WARN_EXPR(keys.size()); + WARN_EXPR(current_time); + WARN_EXPR(request->issue_time); + WARN_EXPR(current_time - request->issue_time); + ERROR_MSG("Aborting"); + } } - } - - keys = m_writeRequestTable.keys(); - for (int i=0; i<keys.size(); i++) { - SequencerRequest* request = m_writeRequestTable.lookup(keys[i]); - if (current_time - request->issue_time >= m_deadlock_threshold) { - WARN_MSG("Possible Deadlock detected"); - WARN_EXPR(request); - WARN_EXPR(m_version); - WARN_EXPR(current_time); - WARN_EXPR(request->issue_time); - WARN_EXPR(current_time - request->issue_time); - WARN_EXPR(keys.size()); - ERROR_MSG("Aborting"); + + keys = m_writeRequestTable.keys(); + for (int i = 0; i < keys.size(); i++) { + SequencerRequest* request = m_writeRequestTable.lookup(keys[i]); + if (current_time - request->issue_time >= m_deadlock_threshold) { + WARN_MSG("Possible Deadlock detected"); + WARN_EXPR(request); + WARN_EXPR(m_version); + WARN_EXPR(current_time); + WARN_EXPR(request->issue_time); + WARN_EXPR(current_time - request->issue_time); + WARN_EXPR(keys.size()); + ERROR_MSG("Aborting"); + } } - } - total_outstanding += m_writeRequestTable.size() + m_readRequestTable.size(); - assert(m_outstanding_count == total_outstanding); + total_outstanding += m_writeRequestTable.size(); + total_outstanding += m_readRequestTable.size(); - if (m_outstanding_count > 0) { // If there are still outstanding requests, keep checking - schedule(deadlockCheckEvent, - (m_deadlock_threshold * g_eventQueue_ptr->getClock()) + curTick); - } + assert(m_outstanding_count == total_outstanding); + + if (m_outstanding_count > 0) { + // If there are still outstanding requests, keep checking + schedule(deadlockCheckEvent, + m_deadlock_threshold * g_eventQueue_ptr->getClock() + + curTick); + } } -void Sequencer::printStats(ostream & out) const { - out << "Sequencer: " << m_name << endl; - out << " store_waiting_on_load_cycles: " << m_store_waiting_on_load_cycles << endl; - out << " store_waiting_on_store_cycles: " << m_store_waiting_on_store_cycles << endl; - out << " load_waiting_on_load_cycles: " << m_load_waiting_on_load_cycles << endl; - out << " load_waiting_on_store_cycles: " << m_load_waiting_on_store_cycles << endl; +void +Sequencer::printStats(ostream & out) const +{ + out << "Sequencer: " << m_name << endl + << " store_waiting_on_load_cycles: " + << m_store_waiting_on_load_cycles << endl + << " store_waiting_on_store_cycles: " + << m_store_waiting_on_store_cycles << endl + << " load_waiting_on_load_cycles: " + << m_load_waiting_on_load_cycles << endl + << " load_waiting_on_store_cycles: " + << m_load_waiting_on_store_cycles << endl; } -void Sequencer::printProgress(ostream& out) const{ - /* - int total_demand = 0; - out << "Sequencer Stats Version " << m_version << endl; - out << "Current time = " << g_eventQueue_ptr->getTime() << endl; - out << "---------------" << endl; - out << "outstanding requests" << endl; - - Vector<Address> rkeys = m_readRequestTable.keys(); - int read_size = rkeys.size(); - out << "proc " << m_version << " Read Requests = " << read_size << endl; - // print the request table - for(int i=0; i < read_size; ++i){ - SequencerRequest * request = m_readRequestTable.lookup(rkeys[i]); - out << "\tRequest[ " << i << " ] = " << request->type << " Address " << rkeys[i] << " Posted " << request->issue_time << " PF " << PrefetchBit_No << endl; - total_demand++; - } - - Vector<Address> wkeys = m_writeRequestTable.keys(); - int write_size = wkeys.size(); - out << "proc " << m_version << " Write Requests = " << write_size << endl; - // print the request table - for(int i=0; i < write_size; ++i){ - CacheMsg & request = m_writeRequestTable.lookup(wkeys[i]); - out << "\tRequest[ " << i << " ] = " << request.getType() << " Address " << wkeys[i] << " Posted " << request.getTime() << " PF " << request.getPrefetch() << endl; - if( request.getPrefetch() == PrefetchBit_No ){ +void +Sequencer::printProgress(ostream& out) const +{ +#if 0 + int total_demand = 0; + out << "Sequencer Stats Version " << m_version << endl; + out << "Current time = " << g_eventQueue_ptr->getTime() << endl; + out << "---------------" << endl; + out << "outstanding requests" << endl; + + Vector<Address> rkeys = m_readRequestTable.keys(); + int read_size = rkeys.size(); + out << "proc " << m_version << " Read Requests = " << read_size << endl; + + // print the request table + for (int i = 0; i < read_size; ++i) { + SequencerRequest *request = m_readRequestTable.lookup(rkeys[i]); + out << "\tRequest[ " << i << " ] = " << request->type + << " Address " << rkeys[i] + << " Posted " << request->issue_time + << " PF " << PrefetchBit_No << endl; total_demand++; - } - } + } - out << endl; + Vector<Address> wkeys = m_writeRequestTable.keys(); + int write_size = wkeys.size(); + out << "proc " << m_version << " Write Requests = " << write_size << endl; + + // print the request table + for (int i = 0; i < write_size; ++i){ + CacheMsg &request = m_writeRequestTable.lookup(wkeys[i]); + out << "\tRequest[ " << i << " ] = " << request.getType() + << " Address " << wkeys[i] + << " Posted " << request.getTime() + << " PF " << request.getPrefetch() << endl; + if (request.getPrefetch() == PrefetchBit_No) { + total_demand++; + } + } - out << "Total Number Outstanding: " << m_outstanding_count << endl; - out << "Total Number Demand : " << total_demand << endl; - out << "Total Number Prefetches : " << m_outstanding_count - total_demand << endl; - out << endl; - out << endl; - */ + out << endl; + + out << "Total Number Outstanding: " << m_outstanding_count << endl + << "Total Number Demand : " << total_demand << endl + << "Total Number Prefetches : " << m_outstanding_count - total_demand + << endl << endl << endl; +#endif } -void Sequencer::printConfig(ostream& out) const { - out << "Seqeuncer config: " << m_name << endl; - out << " controller: " << m_controller->getName() << endl; - out << " version: " << m_version << endl; - out << " max_outstanding_requests: " << m_max_outstanding_requests << endl; - out << " deadlock_threshold: " << m_deadlock_threshold << endl; +void +Sequencer::printConfig(ostream& out) const +{ + out << "Seqeuncer config: " << m_name << endl + << " controller: " << m_controller->getName() << endl + << " version: " << m_version << endl + << " max_outstanding_requests: " << m_max_outstanding_requests << endl + << " deadlock_threshold: " << m_deadlock_threshold << endl; } // Insert the request on the correct request table. Return true if // the entry was already present. -bool Sequencer::insertRequest(SequencerRequest* request) { - int total_outstanding = m_writeRequestTable.size() + m_readRequestTable.size(); - - assert(m_outstanding_count == total_outstanding); - - // See if we should schedule a deadlock check - if (deadlockCheckEvent.scheduled() == false) { - schedule(deadlockCheckEvent, m_deadlock_threshold + curTick); - } - - Address line_addr(request->ruby_request.paddr); - line_addr.makeLineAddress(); - if ((request->ruby_request.type == RubyRequestType_ST) || - (request->ruby_request.type == RubyRequestType_RMW_Read) || - (request->ruby_request.type == RubyRequestType_RMW_Write) || - (request->ruby_request.type == RubyRequestType_Locked_Read) || - (request->ruby_request.type == RubyRequestType_Locked_Write)) { - if (m_writeRequestTable.exist(line_addr)) { - m_writeRequestTable.lookup(line_addr) = request; - // return true; - assert(0); // drh5: isn't this an error? do you lose the initial request? +bool +Sequencer::insertRequest(SequencerRequest* request) +{ + int total_outstanding = + m_writeRequestTable.size() + m_readRequestTable.size(); + + assert(m_outstanding_count == total_outstanding); + + // See if we should schedule a deadlock check + if (deadlockCheckEvent.scheduled() == false) { + schedule(deadlockCheckEvent, m_deadlock_threshold + curTick); } - m_writeRequestTable.allocate(line_addr); - m_writeRequestTable.lookup(line_addr) = request; - m_outstanding_count++; - } else { - if (m_readRequestTable.exist(line_addr)) { - m_readRequestTable.lookup(line_addr) = request; - // return true; - assert(0); // drh5: isn't this an error? do you lose the initial request? + + Address line_addr(request->ruby_request.paddr); + line_addr.makeLineAddress(); + if ((request->ruby_request.type == RubyRequestType_ST) || + (request->ruby_request.type == RubyRequestType_RMW_Read) || + (request->ruby_request.type == RubyRequestType_RMW_Write) || + (request->ruby_request.type == RubyRequestType_Locked_Read) || + (request->ruby_request.type == RubyRequestType_Locked_Write)) { + if (m_writeRequestTable.exist(line_addr)) { + m_writeRequestTable.lookup(line_addr) = request; + // return true; + + // drh5: isn't this an error? do you lose the initial request? + assert(0); + } + m_writeRequestTable.allocate(line_addr); + m_writeRequestTable.lookup(line_addr) = request; + m_outstanding_count++; + } else { + if (m_readRequestTable.exist(line_addr)) { + m_readRequestTable.lookup(line_addr) = request; + // return true; + + // drh5: isn't this an error? do you lose the initial request? + assert(0); + } + m_readRequestTable.allocate(line_addr); + m_readRequestTable.lookup(line_addr) = request; + m_outstanding_count++; } - m_readRequestTable.allocate(line_addr); - m_readRequestTable.lookup(line_addr) = request; - m_outstanding_count++; - } - g_system_ptr->getProfiler()->sequencerRequests(m_outstanding_count); + g_system_ptr->getProfiler()->sequencerRequests(m_outstanding_count); - total_outstanding = m_writeRequestTable.size() + m_readRequestTable.size(); - assert(m_outstanding_count == total_outstanding); + total_outstanding = m_writeRequestTable.size() + m_readRequestTable.size(); + assert(m_outstanding_count == total_outstanding); - return false; + return false; } -void Sequencer::removeRequest(SequencerRequest* srequest) { - - assert(m_outstanding_count == m_writeRequestTable.size() + m_readRequestTable.size()); - - const RubyRequest & ruby_request = srequest->ruby_request; - Address line_addr(ruby_request.paddr); - line_addr.makeLineAddress(); - if ((ruby_request.type == RubyRequestType_ST) || - (ruby_request.type == RubyRequestType_RMW_Read) || - (ruby_request.type == RubyRequestType_RMW_Write) || - (ruby_request.type == RubyRequestType_Locked_Read) || - (ruby_request.type == RubyRequestType_Locked_Write)) { - m_writeRequestTable.deallocate(line_addr); - } else { - m_readRequestTable.deallocate(line_addr); - } - m_outstanding_count--; - - assert(m_outstanding_count == m_writeRequestTable.size() + m_readRequestTable.size()); -} +void +Sequencer::removeRequest(SequencerRequest* srequest) +{ + assert(m_outstanding_count == + m_writeRequestTable.size() + m_readRequestTable.size()); + + const RubyRequest & ruby_request = srequest->ruby_request; + Address line_addr(ruby_request.paddr); + line_addr.makeLineAddress(); + if ((ruby_request.type == RubyRequestType_ST) || + (ruby_request.type == RubyRequestType_RMW_Read) || + (ruby_request.type == RubyRequestType_RMW_Write) || + (ruby_request.type == RubyRequestType_Locked_Read) || + (ruby_request.type == RubyRequestType_Locked_Write)) { + m_writeRequestTable.deallocate(line_addr); + } else { + m_readRequestTable.deallocate(line_addr); + } + m_outstanding_count--; -void Sequencer::writeCallback(const Address& address, DataBlock& data) { + assert(m_outstanding_count == m_writeRequestTable.size() + m_readRequestTable.size()); +} - assert(address == line_address(address)); - assert(m_writeRequestTable.exist(line_address(address))); +void +Sequencer::writeCallback(const Address& address, DataBlock& data) +{ + assert(address == line_address(address)); + assert(m_writeRequestTable.exist(line_address(address))); - SequencerRequest* request = m_writeRequestTable.lookup(address); + SequencerRequest* request = m_writeRequestTable.lookup(address); - removeRequest(request); + removeRequest(request); - assert((request->ruby_request.type == RubyRequestType_ST) || - (request->ruby_request.type == RubyRequestType_RMW_Read) || - (request->ruby_request.type == RubyRequestType_RMW_Write) || - (request->ruby_request.type == RubyRequestType_Locked_Read) || - (request->ruby_request.type == RubyRequestType_Locked_Write)); + assert((request->ruby_request.type == RubyRequestType_ST) || + (request->ruby_request.type == RubyRequestType_RMW_Read) || + (request->ruby_request.type == RubyRequestType_RMW_Write) || + (request->ruby_request.type == RubyRequestType_Locked_Read) || + (request->ruby_request.type == RubyRequestType_Locked_Write)); - if (request->ruby_request.type == RubyRequestType_Locked_Read) { - m_dataCache_ptr->setLocked(address, m_version); - } - else if (request->ruby_request.type == RubyRequestType_RMW_Read) { - m_controller->blockOnQueue(address, m_mandatory_q_ptr); - } - else if (request->ruby_request.type == RubyRequestType_RMW_Write) { - m_controller->unblock(address); - } + if (request->ruby_request.type == RubyRequestType_Locked_Read) { + m_dataCache_ptr->setLocked(address, m_version); + } else if (request->ruby_request.type == RubyRequestType_RMW_Read) { + m_controller->blockOnQueue(address, m_mandatory_q_ptr); + } else if (request->ruby_request.type == RubyRequestType_RMW_Write) { + m_controller->unblock(address); + } - hitCallback(request, data); + hitCallback(request, data); } -void Sequencer::readCallback(const Address& address, DataBlock& data) { - - assert(address == line_address(address)); - assert(m_readRequestTable.exist(line_address(address))); +void +Sequencer::readCallback(const Address& address, DataBlock& data) +{ + assert(address == line_address(address)); + assert(m_readRequestTable.exist(line_address(address))); - SequencerRequest* request = m_readRequestTable.lookup(address); - removeRequest(request); + SequencerRequest* request = m_readRequestTable.lookup(address); + removeRequest(request); - assert((request->ruby_request.type == RubyRequestType_LD) || - (request->ruby_request.type == RubyRequestType_RMW_Read) || - (request->ruby_request.type == RubyRequestType_IFETCH)); + assert((request->ruby_request.type == RubyRequestType_LD) || + (request->ruby_request.type == RubyRequestType_RMW_Read) || + (request->ruby_request.type == RubyRequestType_IFETCH)); - hitCallback(request, data); + hitCallback(request, data); } -void Sequencer::hitCallback(SequencerRequest* srequest, DataBlock& data) { - const RubyRequest & ruby_request = srequest->ruby_request; - Address request_address(ruby_request.paddr); - Address request_line_address(ruby_request.paddr); - request_line_address.makeLineAddress(); - RubyRequestType type = ruby_request.type; - Time issued_time = srequest->issue_time; - - // Set this cache entry to the most recently used - if (type == RubyRequestType_IFETCH) { - if (m_instCache_ptr->isTagPresent(request_line_address) ) - m_instCache_ptr->setMRU(request_line_address); - } else { - if (m_dataCache_ptr->isTagPresent(request_line_address) ) - m_dataCache_ptr->setMRU(request_line_address); - } - - assert(g_eventQueue_ptr->getTime() >= issued_time); - Time miss_latency = g_eventQueue_ptr->getTime() - issued_time; - - // Profile the miss latency for all non-zero demand misses - if (miss_latency != 0) { - g_system_ptr->getProfiler()->missLatency(miss_latency, type); +void +Sequencer::hitCallback(SequencerRequest* srequest, DataBlock& data) +{ + const RubyRequest & ruby_request = srequest->ruby_request; + Address request_address(ruby_request.paddr); + Address request_line_address(ruby_request.paddr); + request_line_address.makeLineAddress(); + RubyRequestType type = ruby_request.type; + Time issued_time = srequest->issue_time; + + // Set this cache entry to the most recently used + if (type == RubyRequestType_IFETCH) { + if (m_instCache_ptr->isTagPresent(request_line_address)) + m_instCache_ptr->setMRU(request_line_address); + } else { + if (m_dataCache_ptr->isTagPresent(request_line_address)) + m_dataCache_ptr->setMRU(request_line_address); + } + + assert(g_eventQueue_ptr->getTime() >= issued_time); + Time miss_latency = g_eventQueue_ptr->getTime() - issued_time; - if (Debug::getProtocolTrace()) { - g_system_ptr->getProfiler()->profileTransition("Seq", m_version, Address(ruby_request.paddr), - "", "Done", "", int_to_string(miss_latency)+" cycles"); + // Profile the miss latency for all non-zero demand misses + if (miss_latency != 0) { + g_system_ptr->getProfiler()->missLatency(miss_latency, type); + + if (Debug::getProtocolTrace()) { + g_system_ptr->getProfiler()-> + profileTransition("Seq", m_version, + Address(ruby_request.paddr), "", "Done", "", + csprintf("%d cycles", miss_latency)); + } } - } - /* - if (request.getPrefetch() == PrefetchBit_Yes) { - return; // Ignore the prefetch - } - */ - - // update the data - if (ruby_request.data != NULL) { - if ((type == RubyRequestType_LD) || - (type == RubyRequestType_IFETCH) || - (type == RubyRequestType_RMW_Read) || - (type == RubyRequestType_Locked_Read)) { - - memcpy(ruby_request.data, - data.getData(request_address.getOffset(), ruby_request.len), - ruby_request.len); - - } else { +#if 0 + if (request.getPrefetch() == PrefetchBit_Yes) { + return; // Ignore the prefetch + } +#endif - data.setData(ruby_request.data, - request_address.getOffset(), - ruby_request.len); + // update the data + if (ruby_request.data != NULL) { + if ((type == RubyRequestType_LD) || + (type == RubyRequestType_IFETCH) || + (type == RubyRequestType_RMW_Read) || + (type == RubyRequestType_Locked_Read)) { + + memcpy(ruby_request.data, + data.getData(request_address.getOffset(), ruby_request.len), + ruby_request.len); + } else { + data.setData(ruby_request.data, request_address.getOffset(), + ruby_request.len); + } + } else { + DPRINTF(MemoryAccess, + "WARNING. Data not transfered from Ruby to M5 for type %s\n", + RubyRequestType_to_string(type)); + } + // If using the RubyTester, update the RubyTester sender state's + // subBlock with the recieved data. The tester will later access + // this state. + // Note: RubyPort will access it's sender state before the + // RubyTester. + if (m_usingRubyTester) { + RubyPort::SenderState *requestSenderState = + safe_cast<RubyPort::SenderState*>(ruby_request.pkt->senderState); + RubyTester::SenderState* testerSenderState = + safe_cast<RubyTester::SenderState*>(requestSenderState->saved); + testerSenderState->subBlock->mergeFrom(data); } - } else { - DPRINTF(MemoryAccess, - "WARNING. Data not transfered from Ruby to M5 for type %s\n", - RubyRequestType_to_string(type)); - } - - // - // If using the RubyTester, update the RubyTester sender state's subBlock - // with the recieved data. The tester will later access this state. - // Note: RubyPort will access it's sender state before the RubyTester. - // - if (m_usingRubyTester) { - RubyTester::SenderState* testerSenderState; - testerSenderState = safe_cast<RubyTester::SenderState*>( \ - safe_cast<RubyPort::SenderState*>(ruby_request.pkt->senderState)->saved); - testerSenderState->subBlock->mergeFrom(data); - } - - ruby_hit_callback(ruby_request.pkt); - delete srequest; + + ruby_hit_callback(ruby_request.pkt); + delete srequest; } // Returns true if the sequencer already has a load or store outstanding -RequestStatus Sequencer::getRequestStatus(const RubyRequest& request) { - bool is_outstanding_store = m_writeRequestTable.exist(line_address(Address(request.paddr))); - bool is_outstanding_load = m_readRequestTable.exist(line_address(Address(request.paddr))); - if ( is_outstanding_store ) { - if ((request.type == RubyRequestType_LD) || - (request.type == RubyRequestType_IFETCH) || - (request.type == RubyRequestType_RMW_Read)) { - m_store_waiting_on_load_cycles++; - } else { - m_store_waiting_on_store_cycles++; +RequestStatus +Sequencer::getRequestStatus(const RubyRequest& request) +{ + bool is_outstanding_store = + m_writeRequestTable.exist(line_address(Address(request.paddr))); + bool is_outstanding_load = + m_readRequestTable.exist(line_address(Address(request.paddr))); + if (is_outstanding_store) { + if ((request.type == RubyRequestType_LD) || + (request.type == RubyRequestType_IFETCH) || + (request.type == RubyRequestType_RMW_Read)) { + m_store_waiting_on_load_cycles++; + } else { + m_store_waiting_on_store_cycles++; + } + return RequestStatus_Aliased; + } else if (is_outstanding_load) { + if ((request.type == RubyRequestType_ST) || + (request.type == RubyRequestType_RMW_Write)) { + m_load_waiting_on_store_cycles++; + } else { + m_load_waiting_on_load_cycles++; + } + return RequestStatus_Aliased; } - return RequestStatus_Aliased; - } else if ( is_outstanding_load ) { - if ((request.type == RubyRequestType_ST) || - (request.type == RubyRequestType_RMW_Write) ) { - m_load_waiting_on_store_cycles++; - } else { - m_load_waiting_on_load_cycles++; + + if (m_outstanding_count >= m_max_outstanding_requests) { + return RequestStatus_BufferFull; } - return RequestStatus_Aliased; - } - - if (m_outstanding_count >= m_max_outstanding_requests) { - return RequestStatus_BufferFull; - } - - return RequestStatus_Ready; -} -bool Sequencer::empty() const { - return (m_writeRequestTable.size() == 0) && (m_readRequestTable.size() == 0); + return RequestStatus_Ready; } +bool +Sequencer::empty() const +{ + return m_writeRequestTable.size() == 0 && m_readRequestTable.size() == 0; +} -RequestStatus Sequencer::makeRequest(const RubyRequest & request) +RequestStatus +Sequencer::makeRequest(const RubyRequest &request) { - assert(Address(request.paddr).getOffset() + request.len <= - RubySystem::getBlockSizeBytes()); - RequestStatus status = getRequestStatus(request); - if (status == RequestStatus_Ready) { - SequencerRequest *srequest = new SequencerRequest(request, - g_eventQueue_ptr->getTime()); + assert(Address(request.paddr).getOffset() + request.len <= + RubySystem::getBlockSizeBytes()); + RequestStatus status = getRequestStatus(request); + if (status != RequestStatus_Ready) + return status; + + SequencerRequest *srequest = + new SequencerRequest(request, g_eventQueue_ptr->getTime()); bool found = insertRequest(srequest); - if (!found) { - if (request.type == RubyRequestType_Locked_Write) { - // - // NOTE: it is OK to check the locked flag here as the mandatory queue - // will be checked first ensuring that nothing comes between checking - // the flag and servicing the store. - // - if (!m_dataCache_ptr->isLocked(line_address(Address(request.paddr)), - m_version)) { - removeRequest(srequest); - if (Debug::getProtocolTrace()) { - - g_system_ptr->getProfiler()->profileTransition("Seq", - m_version, - Address(request.paddr), - "", - "SC Fail", - "", - RubyRequestType_to_string(request.type)); + if (found) { + panic("Sequencer::makeRequest should never be called if the " + "request is already outstanding\n"); + return RequestStatus_NULL; + } + if (request.type == RubyRequestType_Locked_Write) { + // NOTE: it is OK to check the locked flag here as the + // mandatory queue will be checked first ensuring that nothing + // comes between checking the flag and servicing the store. + + Address line_addr = line_address(Address(request.paddr)); + if (!m_dataCache_ptr->isLocked(line_addr, m_version)) { + removeRequest(srequest); + if (Debug::getProtocolTrace()) { + g_system_ptr->getProfiler()-> + profileTransition("Seq", m_version, + Address(request.paddr), + "", "SC Fail", "", + RubyRequestType_to_string(request.type)); } return RequestStatus_LlscFailed; - } - else { - m_dataCache_ptr->clearLocked(line_address(Address(request.paddr))); + } else { + m_dataCache_ptr->clearLocked(line_addr); } - } - issueRequest(request); + } + issueRequest(request); - // TODO: issue hardware prefetches here - return RequestStatus_Issued; + // TODO: issue hardware prefetches here + return RequestStatus_Issued; +} + +void +Sequencer::issueRequest(const RubyRequest& request) +{ + // TODO: get rid of CacheMsg, CacheRequestType, and + // AccessModeTYpe, & have SLICC use RubyRequest and subtypes + // natively + CacheRequestType ctype; + switch(request.type) { + case RubyRequestType_IFETCH: + ctype = CacheRequestType_IFETCH; + break; + case RubyRequestType_LD: + ctype = CacheRequestType_LD; + break; + case RubyRequestType_ST: + ctype = CacheRequestType_ST; + break; + case RubyRequestType_Locked_Read: + case RubyRequestType_Locked_Write: + ctype = CacheRequestType_ATOMIC; + break; + case RubyRequestType_RMW_Read: + ctype = CacheRequestType_ATOMIC; + break; + case RubyRequestType_RMW_Write: + ctype = CacheRequestType_ATOMIC; + break; + default: + assert(0); } - else { - panic("Sequencer::makeRequest should never be called if the request"\ - "is already outstanding\n"); - return RequestStatus_NULL; + + AccessModeType amtype; + switch(request.access_mode){ + case RubyAccessMode_User: + amtype = AccessModeType_UserMode; + break; + case RubyAccessMode_Supervisor: + amtype = AccessModeType_SupervisorMode; + break; + case RubyAccessMode_Device: + amtype = AccessModeType_UserMode; + break; + default: + assert(0); } - } else { - return status; - } -} -void Sequencer::issueRequest(const RubyRequest& request) { - - // TODO: get rid of CacheMsg, CacheRequestType, and AccessModeTYpe, & have SLICC use RubyRequest and subtypes natively - CacheRequestType ctype; - switch(request.type) { - case RubyRequestType_IFETCH: - ctype = CacheRequestType_IFETCH; - break; - case RubyRequestType_LD: - ctype = CacheRequestType_LD; - break; - case RubyRequestType_ST: - ctype = CacheRequestType_ST; - break; - case RubyRequestType_Locked_Read: - case RubyRequestType_Locked_Write: - ctype = CacheRequestType_ATOMIC; - break; - case RubyRequestType_RMW_Read: - ctype = CacheRequestType_ATOMIC; - break; - case RubyRequestType_RMW_Write: - ctype = CacheRequestType_ATOMIC; - break; - default: - assert(0); - } - AccessModeType amtype; - switch(request.access_mode){ - case RubyAccessMode_User: - amtype = AccessModeType_UserMode; - break; - case RubyAccessMode_Supervisor: - amtype = AccessModeType_SupervisorMode; - break; - case RubyAccessMode_Device: - amtype = AccessModeType_UserMode; - break; - default: - assert(0); - } - 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); - - if (Debug::getProtocolTrace()) { - g_system_ptr->getProfiler()->profileTransition("Seq", m_version, Address(request.paddr), - "", "Begin", "", RubyRequestType_to_string(request.type)); - } - - if (g_system_ptr->getTracer()->traceEnabled()) { - g_system_ptr->getTracer()->traceRequest(this, line_addr, Address(request.pc), - request.type, g_eventQueue_ptr->getTime()); - } - - Time latency = 0; // initialzed to an null value - - if (request.type == RubyRequestType_IFETCH) - latency = m_instCache_ptr->getLatency(); - else - latency = m_dataCache_ptr->getLatency(); - - // Send the message to the cache controller - assert(latency > 0); - - assert(m_mandatory_q_ptr != NULL); - m_mandatory_q_ptr->enqueue(msg, latency); -} -/* -bool Sequencer::tryCacheAccess(const Address& addr, CacheRequestType type, - AccessModeType access_mode, - int size, DataBlock*& data_ptr) { - if (type == CacheRequestType_IFETCH) { - return m_instCache_ptr->tryCacheAccess(line_address(addr), type, data_ptr); - } else { - return m_dataCache_ptr->tryCacheAccess(line_address(addr), type, data_ptr); - } + 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); + + if (Debug::getProtocolTrace()) { + g_system_ptr->getProfiler()-> + profileTransition("Seq", m_version, Address(request.paddr), + "", "Begin", "", + RubyRequestType_to_string(request.type)); + } + + if (g_system_ptr->getTracer()->traceEnabled()) { + g_system_ptr->getTracer()-> + traceRequest(this, line_addr, Address(request.pc), + request.type, g_eventQueue_ptr->getTime()); + } + + Time latency = 0; // initialzed to an null value + + if (request.type == RubyRequestType_IFETCH) + latency = m_instCache_ptr->getLatency(); + else + latency = m_dataCache_ptr->getLatency(); + + // Send the message to the cache controller + assert(latency > 0); + + assert(m_mandatory_q_ptr != NULL); + m_mandatory_q_ptr->enqueue(msg, latency); } -*/ -void Sequencer::print(ostream& out) const { - out << "[Sequencer: " << m_version - << ", outstanding requests: " << m_outstanding_count; +#if 0 +bool +Sequencer::tryCacheAccess(const Address& addr, CacheRequestType type, + AccessModeType access_mode, + int size, DataBlock*& data_ptr) +{ + CacheMemory *cache = + (type == CacheRequestType_IFETCH) ? m_instCache_ptr : m_dataCache_ptr; - out << ", read request table: " << m_readRequestTable - << ", write request table: " << m_writeRequestTable; - out << "]"; + return cache->tryCacheAccess(line_address(addr), type, data_ptr); +} +#endif + +void +Sequencer::print(ostream& out) const +{ + out << "[Sequencer: " << m_version + << ", outstanding requests: " << m_outstanding_count + << ", read request table: " << m_readRequestTable + << ", write request table: " << m_writeRequestTable + << "]"; } -// this can be called from setState whenever coherence permissions are upgraded -// when invoked, coherence violations will be checked for the given block -void Sequencer::checkCoherence(const Address& addr) { +// this can be called from setState whenever coherence permissions are +// upgraded when invoked, coherence violations will be checked for the +// given block +void +Sequencer::checkCoherence(const Address& addr) +{ #ifdef CHECK_COHERENCE - g_system_ptr->checkGlobalCoherenceInvariant(addr); + g_system_ptr->checkGlobalCoherenceInvariant(addr); #endif } - diff --git a/src/mem/ruby/system/Sequencer.hh b/src/mem/ruby/system/Sequencer.hh index 333ca5f24..69fd3b771 100644 --- a/src/mem/ruby/system/Sequencer.hh +++ b/src/mem/ruby/system/Sequencer.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,25 +26,18 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id: Sequencer.hh 1.70 2006/09/27 14:56:41-05:00 bobba@s1-01.cs.wisc.edu $ - * - * Description: - * - */ - -#ifndef SEQUENCER_H -#define SEQUENCER_H +#ifndef __MEM_RUBY_SYSTEM_SEQUENCER_HH__ +#define __MEM_RUBY_SYSTEM_SEQUENCER_HH__ -#include "mem/ruby/common/Global.hh" -#include "mem/ruby/common/Consumer.hh" -#include "mem/protocol/CacheRequestType.hh" +#include "mem/gems_common/Map.hh" #include "mem/protocol/AccessModeType.hh" +#include "mem/protocol/CacheRequestType.hh" #include "mem/protocol/GenericMachineType.hh" #include "mem/protocol/PrefetchBit.hh" -#include "mem/ruby/system/RubyPort.hh" -#include "mem/gems_common/Map.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Consumer.hh" +#include "mem/ruby/common/Global.hh" +#include "mem/ruby/system/RubyPort.hh" class DataBlock; class CacheMsg; @@ -54,109 +46,100 @@ class CacheMemory; class RubySequencerParams; -struct SequencerRequest { - RubyRequest ruby_request; - Time issue_time; +struct SequencerRequest +{ + RubyRequest ruby_request; + Time issue_time; - SequencerRequest(const RubyRequest & _ruby_request, - Time _issue_time) - : ruby_request(_ruby_request), - issue_time(_issue_time) - {} + SequencerRequest(const RubyRequest & _ruby_request, Time _issue_time) + : ruby_request(_ruby_request), issue_time(_issue_time) + {} }; std::ostream& operator<<(std::ostream& out, const SequencerRequest& obj); -class Sequencer : public RubyPort, public Consumer { -public: +class Sequencer : public RubyPort, public Consumer +{ + public: typedef RubySequencerParams Params; - // Constructors - Sequencer(const Params *); - - // Destructor - ~Sequencer(); + Sequencer(const Params *); + ~Sequencer(); - // Public Methods - void wakeup(); // Used only for deadlock detection + // Public Methods + void wakeup(); // Used only for deadlock detection - void printConfig(ostream& out) const; + void printConfig(ostream& out) const; - void printProgress(ostream& out) const; + void printProgress(ostream& out) const; - void writeCallback(const Address& address, DataBlock& data); - void readCallback(const Address& address, DataBlock& data); + void writeCallback(const Address& address, DataBlock& data); + void readCallback(const Address& address, DataBlock& data); - RequestStatus makeRequest(const RubyRequest & request); - RequestStatus getRequestStatus(const RubyRequest& request); - bool empty() const; + RequestStatus makeRequest(const RubyRequest & request); + RequestStatus getRequestStatus(const RubyRequest& request); + bool empty() const; - void print(ostream& out) const; - void printStats(ostream & out) const; - void checkCoherence(const Address& address); + void print(ostream& out) const; + void printStats(ostream & out) const; + void checkCoherence(const Address& address); - // bool getRubyMemoryValue(const Address& addr, char* value, unsigned int size_in_bytes); - // bool setRubyMemoryValue(const Address& addr, char *value, unsigned int size_in_bytes); + void removeRequest(SequencerRequest* request); - void removeRequest(SequencerRequest* request); -private: - // Private Methods - bool tryCacheAccess(const Address& addr, CacheRequestType type, const Address& pc, AccessModeType access_mode, int size, DataBlock*& data_ptr); - void issueRequest(const RubyRequest& request); + private: + bool tryCacheAccess(const Address& addr, CacheRequestType type, + const Address& pc, AccessModeType access_mode, + int size, DataBlock*& data_ptr); + void issueRequest(const RubyRequest& request); - void hitCallback(SequencerRequest* request, DataBlock& data); - bool insertRequest(SequencerRequest* request); + void hitCallback(SequencerRequest* request, DataBlock& data); + bool insertRequest(SequencerRequest* request); - // Private copy constructor and assignment operator - Sequencer(const Sequencer& obj); - Sequencer& operator=(const Sequencer& obj); + // Private copy constructor and assignment operator + Sequencer(const Sequencer& obj); + Sequencer& operator=(const Sequencer& obj); -private: - int m_max_outstanding_requests; - int m_deadlock_threshold; + private: + int m_max_outstanding_requests; + int m_deadlock_threshold; - CacheMemory* m_dataCache_ptr; - CacheMemory* m_instCache_ptr; + CacheMemory* m_dataCache_ptr; + CacheMemory* m_instCache_ptr; - Map<Address, SequencerRequest*> m_writeRequestTable; - Map<Address, SequencerRequest*> m_readRequestTable; - // Global outstanding request count, across all request tables - int m_outstanding_count; - bool m_deadlock_check_scheduled; + Map<Address, SequencerRequest*> m_writeRequestTable; + Map<Address, SequencerRequest*> m_readRequestTable; + // Global outstanding request count, across all request tables + int m_outstanding_count; + bool m_deadlock_check_scheduled; - int m_store_waiting_on_load_cycles; - int m_store_waiting_on_store_cycles; - int m_load_waiting_on_store_cycles; - int m_load_waiting_on_load_cycles; + int m_store_waiting_on_load_cycles; + int m_store_waiting_on_store_cycles; + int m_load_waiting_on_store_cycles; + int m_load_waiting_on_load_cycles; - bool m_usingRubyTester; + bool m_usingRubyTester; - class SequencerWakeupEvent : public Event - { - Sequencer *m_sequencer_ptr; + class SequencerWakeupEvent : public Event + { + private: + Sequencer *m_sequencer_ptr; - public: - SequencerWakeupEvent(Sequencer *_seq) : m_sequencer_ptr(_seq) {} - void process() { m_sequencer_ptr->wakeup(); } - const char *description() const { return "Sequencer deadlock check"; } - }; + public: + SequencerWakeupEvent(Sequencer *_seq) : m_sequencer_ptr(_seq) {} + void process() { m_sequencer_ptr->wakeup(); } + const char *description() const { return "Sequencer deadlock check"; } + }; - SequencerWakeupEvent deadlockCheckEvent; + SequencerWakeupEvent deadlockCheckEvent; }; -// Output operator declaration -ostream& operator<<(ostream& out, const Sequencer& obj); - -// ******************* Definitions ******************* - -// Output operator definition -extern inline -ostream& operator<<(ostream& out, const Sequencer& obj) +inline ostream& +operator<<(ostream& out, const Sequencer& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } -#endif //SEQUENCER_H +#endif // __MEM_RUBY_SYSTEM_SEQUENCER_HH__ diff --git a/src/mem/ruby/system/SparseMemory.cc b/src/mem/ruby/system/SparseMemory.cc index c351f9e60..6271d24c3 100644 --- a/src/mem/ruby/system/SparseMemory.cc +++ b/src/mem/ruby/system/SparseMemory.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 2009 Advanced Micro Devices, Inc. * All rights reserved. @@ -29,10 +28,6 @@ #include "mem/ruby/system/SparseMemory.hh" - -// **************************************************************** - - SparseMemory::SparseMemory(int number_of_bits, int number_of_levels) { int even_level_bits; @@ -81,22 +76,16 @@ SparseMemory::recursivelyRemoveTables(SparseMapType* curTable, int curLevel) SparseMapType::iterator iter; for (iter = curTable->begin(); iter != curTable->end(); iter++) { - SparseMemEntry_t* entryStruct = &((*iter).second); + SparseMemEntry* entryStruct = &((*iter).second); if (curLevel != (m_number_of_levels - 1)) { - // - // If the not at the last level, analyze those lower level tables first, - // then delete those next tables - // - SparseMapType* nextTable; - nextTable = (SparseMapType*)(entryStruct->entry); + // If the not at the last level, analyze those lower level + // tables first, then delete those next tables + SparseMapType* nextTable = (SparseMapType*)(entryStruct->entry); recursivelyRemoveTables(nextTable, (curLevel + 1)); delete nextTable; - } else { - // // If at the last level, delete the directory entry - // Directory_Entry* dirEntry; dirEntry = (Directory_Entry*)(entryStruct->entry); delete dirEntry; @@ -104,15 +93,10 @@ SparseMemory::recursivelyRemoveTables(SparseMapType* curTable, int curLevel) entryStruct->entry = NULL; } - // // Once all entries have been deleted, erase the entries - // curTable->erase(curTable->begin(), curTable->end()); } - -// PUBLIC METHODS - // tests to see if an address is present in the memory bool SparseMemory::exist(const Address& address) const @@ -120,22 +104,19 @@ SparseMemory::exist(const Address& address) const SparseMapType* curTable = m_map_head; Address curAddress; - // - // Initiallize the high bit to be the total number of bits plus the block - // offset. However the highest bit index is one less than this value. - // + // Initiallize the high bit to be the total number of bits plus + // the block offset. However the highest bit index is one less + // than this value. int highBit = m_total_number_of_bits + RubySystem::getBlockSizeBits(); int lowBit; assert(address == line_address(address)); DEBUG_EXPR(CACHE_COMP, HighPrio, address); for (int level = 0; level < m_number_of_levels; level++) { - // // Create the appropriate sub address for this level - // Note: that set Address is inclusive of the specified range, thus the - // high bit is one less than the total number of bits used to create the - // address. - // + // Note: that set Address is inclusive of the specified range, + // thus the high bit is one less than the total number of bits + // used to create the address. lowBit = highBit - m_number_of_bits_per_level[level]; curAddress.setAddress(address.bitSelect(lowBit, highBit - 1)); @@ -144,15 +125,11 @@ SparseMemory::exist(const Address& address) const DEBUG_EXPR(CACHE_COMP, HighPrio, highBit - 1); DEBUG_EXPR(CACHE_COMP, HighPrio, curAddress); - // // Adjust the highBit value for the next level - // highBit -= m_number_of_bits_per_level[level]; - // - // If the address is found, move on to the next level. Otherwise, - // return not found - // + // If the address is found, move on to the next level. + // Otherwise, return not found if (curTable->count(curAddress) != 0) { curTable = (SparseMapType*)(((*curTable)[curAddress]).entry); } else { @@ -176,43 +153,34 @@ SparseMemory::add(const Address& address) Address curAddress; SparseMapType* curTable = m_map_head; - SparseMemEntry_t* entryStruct = NULL; + SparseMemEntry* entryStruct = NULL; - // - // Initiallize the high bit to be the total number of bits plus the block - // offset. However the highest bit index is one less than this value. - // + // Initiallize the high bit to be the total number of bits plus + // the block offset. However the highest bit index is one less + // than this value. int highBit = m_total_number_of_bits + RubySystem::getBlockSizeBits(); int lowBit; void* newEntry = NULL; for (int level = 0; level < m_number_of_levels; level++) { - // // create the appropriate address for this level - // Note: that set Address is inclusive of the specified range, thus the - // high bit is one less than the total number of bits used to create the - // address. - // + // Note: that set Address is inclusive of the specified range, + // thus the high bit is one less than the total number of bits + // used to create the address. lowBit = highBit - m_number_of_bits_per_level[level]; curAddress.setAddress(address.bitSelect(lowBit, highBit - 1)); - // // Adjust the highBit value for the next level - // highBit -= m_number_of_bits_per_level[level]; - // // if the address exists in the cur table, move on. Otherwise // create a new table. - // if (curTable->count(curAddress) != 0) { curTable = (SparseMapType*)(((*curTable)[curAddress]).entry); - } else { - + } else { m_adds_per_level[level]++; - // + // if the last level, add a directory entry. Otherwise add a map. - // if (level == (m_number_of_levels - 1)) { Directory_Entry* tempDirEntry = new Directory_Entry(); tempDirEntry->getDataBlk().clear(); @@ -222,17 +190,13 @@ SparseMemory::add(const Address& address) newEntry = (void*)(tempMap); } - // - // Create the pointer container SparseMemEntry_t and add it to the - // table. - // - entryStruct = new SparseMemEntry_t; + // Create the pointer container SparseMemEntry and add it + // to the table. + entryStruct = new SparseMemEntry; entryStruct->entry = newEntry; (*curTable)[curAddress] = *entryStruct; - // // Move to the next level of the heirarchy - // curTable = (SparseMapType*)newEntry; } } @@ -244,20 +208,17 @@ SparseMemory::add(const Address& address) // recursively search table hierarchy for the lowest level table. // remove the lowest entry and any empty tables above it. int -SparseMemory::recursivelyRemoveLevels( - const Address& address, - curNextInfo& curInfo) +SparseMemory::recursivelyRemoveLevels(const Address& address, + CurNextInfo& curInfo) { Address curAddress; - curNextInfo nextInfo; - SparseMemEntry_t* entryStruct; + CurNextInfo nextInfo; + SparseMemEntry* entryStruct; - // // create the appropriate address for this level - // Note: that set Address is inclusive of the specified range, thus the - // high bit is one less than the total number of bits used to create the - // address. - // + // Note: that set Address is inclusive of the specified range, + // thus the high bit is one less than the total number of bits + // used to create the address. curAddress.setAddress(address.bitSelect(curInfo.lowBit, curInfo.highBit - 1)); @@ -272,9 +233,7 @@ SparseMemory::recursivelyRemoveLevels( entryStruct = &((*(curInfo.curTable))[curAddress]); if (curInfo.level < (m_number_of_levels - 1)) { - // // set up next level's info - // nextInfo.curTable = (SparseMapType*)(entryStruct->entry); nextInfo.level = curInfo.level + 1; @@ -284,15 +243,11 @@ SparseMemory::recursivelyRemoveLevels( nextInfo.lowBit = curInfo.lowBit - m_number_of_bits_per_level[curInfo.level + 1]; - // // recursively search the table hierarchy - // int tableSize = recursivelyRemoveLevels(address, nextInfo); - // - // If this table below is now empty, we must delete it and erase it from - // our table. - // + // If this table below is now empty, we must delete it and + // erase it from our table. if (tableSize == 0) { m_removes_per_level[curInfo.level]++; delete nextInfo.curTable; @@ -300,10 +255,9 @@ SparseMemory::recursivelyRemoveLevels( curInfo.curTable->erase(curAddress); } } else { - // - // if this is the last level, we have reached the Directory Entry and thus - // we should delete it including the SparseMemEntry container struct. - // + // if this is the last level, we have reached the Directory + // Entry and thus we should delete it including the + // SparseMemEntry container struct. Directory_Entry* dirEntry; dirEntry = (Directory_Entry*)(entryStruct->entry); entryStruct->entry = NULL; @@ -323,26 +277,21 @@ SparseMemory::remove(const Address& address) m_total_removes++; - curNextInfo nextInfo; + CurNextInfo nextInfo; - // // Initialize table pointer and level value - // nextInfo.curTable = m_map_head; nextInfo.level = 0; - // - // Initiallize the high bit to be the total number of bits plus the block - // offset. However the highest bit index is one less than this value. - // + // Initiallize the high bit to be the total number of bits plus + // the block offset. However the highest bit index is one less + // than this value. nextInfo.highBit = m_total_number_of_bits + RubySystem::getBlockSizeBits(); nextInfo.lowBit = nextInfo.highBit - m_number_of_bits_per_level[0];; - // - // recursively search the table hierarchy for empty tables starting from the - // level 0. Note we do not check the return value because the head table is - // never deleted; - // + // recursively search the table hierarchy for empty tables + // starting from the level 0. Note we do not check the return + // value because the head table is never deleted; recursivelyRemoveLevels(address, nextInfo); assert(!exist(address)); @@ -362,20 +311,17 @@ SparseMemory::lookup(const Address& address) SparseMapType* curTable = m_map_head; Directory_Entry* entry = NULL; - // - // Initiallize the high bit to be the total number of bits plus the block - // offset. However the highest bit index is one less than this value. - // + // Initiallize the high bit to be the total number of bits plus + // the block offset. However the highest bit index is one less + // than this value. int highBit = m_total_number_of_bits + RubySystem::getBlockSizeBits(); int lowBit; for (int level = 0; level < m_number_of_levels; level++) { - // // create the appropriate address for this level - // Note: that set Address is inclusive of the specified range, thus the - // high bit is one less than the total number of bits used to create the - // address. - // + // Note: that set Address is inclusive of the specified range, + // thus the high bit is one less than the total number of bits + // used to create the address. lowBit = highBit - m_number_of_bits_per_level[level]; curAddress.setAddress(address.bitSelect(lowBit, highBit - 1)); @@ -384,21 +330,15 @@ SparseMemory::lookup(const Address& address) DEBUG_EXPR(CACHE_COMP, HighPrio, highBit - 1); DEBUG_EXPR(CACHE_COMP, HighPrio, curAddress); - // // Adjust the highBit value for the next level - // highBit -= m_number_of_bits_per_level[level]; - // // The entry should be in the table and valid - // curTable = (SparseMapType*)(((*curTable)[curAddress]).entry); assert(curTable != NULL); } - // // The last entry actually points to the Directory entry not a table - // entry = (Directory_Entry*)curTable; return entry; diff --git a/src/mem/ruby/system/SparseMemory.hh b/src/mem/ruby/system/SparseMemory.hh index 4a7ac98c2..6e3c8f926 100644 --- a/src/mem/ruby/system/SparseMemory.hh +++ b/src/mem/ruby/system/SparseMemory.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 2009 Advanced Micro Devices, Inc. * All rights reserved. @@ -27,39 +26,35 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#ifndef __MEM_RUBY_SYSTEM_SPARSEMEMORY_HH__ +#define __MEM_RUBY_SYSTEM_SPARSEMEMORY_HH__ -#ifndef SPARSEMEMORY_H -#define SPARSEMEMORY_H - -#include "mem/ruby/common/Global.hh" #include "base/hashmap.hh" -#include "mem/ruby/common/Address.hh" #include "mem/protocol/Directory_Entry.hh" +#include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" -typedef struct SparseMemEntry { +struct SparseMemEntry +{ void* entry; -} SparseMemEntry_t; +}; -typedef m5::hash_map<Address, SparseMemEntry_t> SparseMapType; +typedef m5::hash_map<Address, SparseMemEntry> SparseMapType; -typedef struct curNextInfo { +struct CurNextInfo +{ SparseMapType* curTable; int level; int highBit; int lowBit; }; -class SparseMemory { +class SparseMemory +{ public: - - // Constructors SparseMemory(int number_of_bits, int number_of_levels); - - // Destructor ~SparseMemory(); - // Public Methods - void printConfig(ostream& out) { } bool exist(const Address& address) const; @@ -83,7 +78,7 @@ class SparseMemory { void recursivelyRemoveTables(SparseMapType* currentTable, int level); // recursive search for address and remove associated entries - int recursivelyRemoveLevels(const Address& address, curNextInfo& curInfo); + int recursivelyRemoveLevels(const Address& address, CurNextInfo& curInfo); // Data Members (m_prefix) SparseMapType* m_map_head; @@ -98,17 +93,12 @@ class SparseMemory { uint64_t* m_removes_per_level; }; -// Output operator declaration -ostream& operator<<(ostream& out, const SparseMemEntry& obj); - -// Output operator definition -extern inline -ostream& operator<<(ostream& out, const SparseMemEntry& obj) +inline ostream& +operator<<(ostream& out, const SparseMemEntry& obj) { out << "SparseMemEntry"; out << flush; return out; } - -#endif //SPARSEMEMORY_H +#endif // __MEM_RUBY_SYSTEM_SPARSEMEMORY_HH__ diff --git a/src/mem/ruby/system/System.cc b/src/mem/ruby/system/System.cc index 69dbf69c4..ef4b66290 100644 --- a/src/mem/ruby/system/System.cc +++ b/src/mem/ruby/system/System.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,25 +26,15 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * RubySystem.cc - * - * Description: See System.hh - * - * $Id$ - * - */ - - -#include "mem/ruby/system/System.hh" +#include "base/output.hh" +#include "mem/ruby/buffers/MessageBuffer.hh" #include "mem/ruby/common/Address.hh" -#include "mem/ruby/profiler/Profiler.hh" #include "mem/ruby/network/Network.hh" +#include "mem/ruby/profiler/Profiler.hh" #include "mem/ruby/recorder/Tracer.hh" -#include "mem/ruby/buffers/MessageBuffer.hh" -#include "mem/ruby/system/MemoryVector.hh" #include "mem/ruby/slicc_interface/AbstractController.hh" -#include "base/output.hh" +#include "mem/ruby/system/MemoryVector.hh" +#include "mem/ruby/system/System.hh" int RubySystem::m_random_seed; bool RubySystem::m_randomization; @@ -103,68 +92,68 @@ RubySystem::RubySystem(const Params *p) registerExitCallback(rubyExitCB); } - -void RubySystem::init() +void +RubySystem::init() { - m_profiler_ptr->clearStats(); + m_profiler_ptr->clearStats(); } - RubySystem::~RubySystem() { - delete m_network_ptr; - delete m_profiler_ptr; - delete m_tracer_ptr; - if (m_mem_vec_ptr != NULL) { - delete m_mem_vec_ptr; - } + delete m_network_ptr; + delete m_profiler_ptr; + delete m_tracer_ptr; + if (m_mem_vec_ptr) + delete m_mem_vec_ptr; } -void RubySystem::printSystemConfig(ostream & out) +void +RubySystem::printSystemConfig(ostream & out) { - out << "RubySystem config:" << endl; - out << " random_seed: " << m_random_seed << endl; - out << " randomization: " << m_randomization << endl; - out << " cycle_period: " << m_clock << endl; - out << " block_size_bytes: " << m_block_size_bytes << endl; - out << " block_size_bits: " << m_block_size_bits << endl; - out << " memory_size_bytes: " << m_memory_size_bytes << endl; - out << " memory_size_bits: " << m_memory_size_bits << endl; - + out << "RubySystem config:" << endl + << " random_seed: " << m_random_seed << endl + << " randomization: " << m_randomization << endl + << " cycle_period: " << m_clock << endl + << " block_size_bytes: " << m_block_size_bytes << endl + << " block_size_bits: " << m_block_size_bits << endl + << " memory_size_bytes: " << m_memory_size_bytes << endl + << " memory_size_bits: " << m_memory_size_bits << endl; } -void RubySystem::printConfig(ostream& out) +void +RubySystem::printConfig(ostream& out) { - out << "\n================ Begin RubySystem Configuration Print ================\n\n"; - printSystemConfig(out); - m_network_ptr->printConfig(out); - m_profiler_ptr->printConfig(out); - out << "\n================ End RubySystem Configuration Print ================\n\n"; + out << "\n================ Begin RubySystem Configuration Print ================\n\n"; + printSystemConfig(out); + m_network_ptr->printConfig(out); + m_profiler_ptr->printConfig(out); + out << "\n================ End RubySystem Configuration Print ================\n\n"; } -void RubySystem::printStats(ostream& out) +void +RubySystem::printStats(ostream& out) { + const time_t T = time(NULL); + tm *localTime = localtime(&T); + char buf[100]; + strftime(buf, 100, "%b/%d/%Y %H:%M:%S", localTime); - const time_t T = time(NULL); - tm *localTime = localtime(&T); - char buf[100]; - strftime(buf, 100, "%b/%d/%Y %H:%M:%S", localTime); - - out << "Real time: " << buf << endl; + out << "Real time: " << buf << endl; - m_profiler_ptr->printStats(out); - m_network_ptr->printStats(out); + m_profiler_ptr->printStats(out); + m_network_ptr->printStats(out); } -void RubySystem::clearStats() const +void +RubySystem::clearStats() const { - m_profiler_ptr->clearStats(); - m_network_ptr->clearStats(); + m_profiler_ptr->clearStats(); + m_network_ptr->clearStats(); } -void RubySystem::recordCacheContents(CacheRecorder& tr) const +void +RubySystem::recordCacheContents(CacheRecorder& tr) const { - } #ifdef CHECK_COHERENCE @@ -176,48 +165,46 @@ void RubySystem::recordCacheContents(CacheRecorder& tr) const // in setState. The SLICC spec must also define methods "isBlockShared" // and "isBlockExclusive" that are specific to that protocol // -void RubySystem::checkGlobalCoherenceInvariant(const Address& addr ) { - /* - NodeID exclusive = -1; - bool sharedDetected = false; - NodeID lastShared = -1; - - for (int i = 0; i < m_chip_vector.size(); i++) { - - if (m_chip_vector[i]->isBlockExclusive(addr)) { - if (exclusive != -1) { - // coherence violation - WARN_EXPR(exclusive); - WARN_EXPR(m_chip_vector[i]->getID()); - WARN_EXPR(addr); - WARN_EXPR(g_eventQueue_ptr->getTime()); - ERROR_MSG("Coherence Violation Detected -- 2 exclusive chips"); - } - else if (sharedDetected) { - WARN_EXPR(lastShared); - WARN_EXPR(m_chip_vector[i]->getID()); - WARN_EXPR(addr); - WARN_EXPR(g_eventQueue_ptr->getTime()); - ERROR_MSG("Coherence Violation Detected -- exclusive chip with >=1 shared"); - } - else { - exclusive = m_chip_vector[i]->getID(); - } - } - else if (m_chip_vector[i]->isBlockShared(addr)) { - sharedDetected = true; - lastShared = m_chip_vector[i]->getID(); - - if (exclusive != -1) { - WARN_EXPR(lastShared); - WARN_EXPR(exclusive); - WARN_EXPR(addr); - WARN_EXPR(g_eventQueue_ptr->getTime()); - ERROR_MSG("Coherence Violation Detected -- exclusive chip with >=1 shared"); - } +void +RubySystem::checkGlobalCoherenceInvariant(const Address& addr) +{ +#if 0 + NodeID exclusive = -1; + bool sharedDetected = false; + NodeID lastShared = -1; + + for (int i = 0; i < m_chip_vector.size(); i++) { + if (m_chip_vector[i]->isBlockExclusive(addr)) { + if (exclusive != -1) { + // coherence violation + WARN_EXPR(exclusive); + WARN_EXPR(m_chip_vector[i]->getID()); + WARN_EXPR(addr); + WARN_EXPR(g_eventQueue_ptr->getTime()); + ERROR_MSG("Coherence Violation Detected -- 2 exclusive chips"); + } else if (sharedDetected) { + WARN_EXPR(lastShared); + WARN_EXPR(m_chip_vector[i]->getID()); + WARN_EXPR(addr); + WARN_EXPR(g_eventQueue_ptr->getTime()); + ERROR_MSG("Coherence Violation Detected -- exclusive chip with >=1 shared"); + } else { + exclusive = m_chip_vector[i]->getID(); + } + } else if (m_chip_vector[i]->isBlockShared(addr)) { + sharedDetected = true; + lastShared = m_chip_vector[i]->getID(); + + if (exclusive != -1) { + WARN_EXPR(lastShared); + WARN_EXPR(exclusive); + WARN_EXPR(addr); + WARN_EXPR(g_eventQueue_ptr->getTime()); + ERROR_MSG("Coherence Violation Detected -- exclusive chip with >=1 shared"); + } + } } - } - */ +#endif } #endif @@ -231,7 +218,8 @@ RubySystemParams::create() * virtual process function that is invoked when the callback * queue is executed. */ -void RubyExitCallback::process() +void +RubyExitCallback::process() { std::ostream *os = simout.create(stats_filename); RubySystem::printConfig(*os); diff --git a/src/mem/ruby/system/System.hh b/src/mem/ruby/system/System.hh index 7868da4b6..ccec2d61c 100644 --- a/src/mem/ruby/system/System.hh +++ b/src/mem/ruby/system/System.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -28,32 +27,27 @@ */ /* - * System.hh - * - * Description: Contains all of the various parts of the system we are - * simulating. Performs allocation, deallocation, and setup of all - * the major components of the system - * - * $Id$ - * + * Contains all of the various parts of the system we are simulating. + * Performs allocation, deallocation, and setup of all the major + * components of the system */ -#ifndef SYSTEM_H -#define SYSTEM_H +#ifndef __MEM_RUBY_SYSTEM_SYSTEM_HH__ +#define __MEM_RUBY_SYSTEM_SYSTEM_HH__ -#include "mem/ruby/system/RubyPort.hh" -#include "mem/ruby/common/Global.hh" +#include "base/callback.hh" #include "mem/gems_common/Vector.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/eventqueue/RubyEventQueue.hh" -#include "sim/sim_object.hh" +#include "mem/ruby/system/RubyPort.hh" #include "params/RubySystem.hh" -#include "base/callback.hh" +#include "sim/sim_object.hh" -class Profiler; -class Network; class CacheRecorder; -class Tracer; class MemoryVector; +class Network; +class Profiler; +class Tracer; /* * This defines the number of longs (32-bits on 32 bit machines, @@ -68,83 +62,103 @@ class MemoryVector; */ const int NUMBER_WORDS_PER_SET = 1; -class RubySystem : public SimObject { -public: +class RubySystem : public SimObject +{ + public: typedef RubySystemParams Params; RubySystem(const Params *p); - // Destructor - ~RubySystem(); - - // config accessors - static int getRandomSeed() { return m_random_seed; } - static int getRandomization() { return m_randomization; } - static int getBlockSizeBytes() { return m_block_size_bytes; } - static int getBlockSizeBits() { return m_block_size_bits; } - static uint64 getMemorySizeBytes() { return m_memory_size_bytes; } - static int getMemorySizeBits() { return m_memory_size_bits; } - - // Public Methods - static Network* getNetwork() { assert(m_network_ptr != NULL); return m_network_ptr; } - static RubyEventQueue* getEventQueue() { return g_eventQueue_ptr; } - Profiler* getProfiler() {assert(m_profiler_ptr != NULL); return m_profiler_ptr; } - static Tracer* getTracer() { assert(m_tracer_ptr != NULL); return m_tracer_ptr; } - static MemoryVector* getMemoryVector() { assert(m_mem_vec_ptr != NULL); return m_mem_vec_ptr;} - - void recordCacheContents(CacheRecorder& tr) const; - static void printConfig(ostream& out); - static void printStats(ostream& out); - void clearStats() const; - - uint64 getInstructionCount(int thread) { return 1; } - static uint64 getCycleCount(int thread) { return g_eventQueue_ptr->getTime(); } - - void print(ostream& out) const; - /* -#ifdef CHECK_COHERENCE - void checkGlobalCoherenceInvariant(const Address& addr); -#endif - */ - -private: - // Private copy constructor and assignment operator - RubySystem(const RubySystem& obj); - RubySystem& operator=(const RubySystem& obj); - - void init(); - - static void printSystemConfig(ostream& out); - -private: - // configuration parameters - static int m_random_seed; - static bool m_randomization; - static Tick m_clock; - static int m_block_size_bytes; - static int m_block_size_bits; - static uint64 m_memory_size_bytes; - static int m_memory_size_bits; - - // Data Members (m_ prefix) - static Network* m_network_ptr; - -public: - static Profiler* m_profiler_ptr; - static Tracer* m_tracer_ptr; - static MemoryVector* m_mem_vec_ptr; -}; + ~RubySystem(); + + // config accessors + static int getRandomSeed() { return m_random_seed; } + static int getRandomization() { return m_randomization; } + static int getBlockSizeBytes() { return m_block_size_bytes; } + static int getBlockSizeBits() { return m_block_size_bits; } + static uint64 getMemorySizeBytes() { return m_memory_size_bytes; } + static int getMemorySizeBits() { return m_memory_size_bits; } + + // Public Methods + static Network* + getNetwork() + { + assert(m_network_ptr != NULL); + return m_network_ptr; + } -// Output operator declaration -ostream& operator<<(ostream& out, const RubySystem& obj); + static RubyEventQueue* + getEventQueue() + { + return g_eventQueue_ptr; + } -// ******************* Definitions ******************* + Profiler* + getProfiler() + { + assert(m_profiler_ptr != NULL); + return m_profiler_ptr; + } + + static Tracer* + getTracer() + { + assert(m_tracer_ptr != NULL); + return m_tracer_ptr; + } + + static MemoryVector* + getMemoryVector() + { + assert(m_mem_vec_ptr != NULL); + return m_mem_vec_ptr; + } + + void recordCacheContents(CacheRecorder& tr) const; + static void printConfig(ostream& out); + static void printStats(ostream& out); + void clearStats() const; + + uint64 getInstructionCount(int thread) { return 1; } + static uint64 + getCycleCount(int thread) + { + return g_eventQueue_ptr->getTime(); + } -// Output operator definition -inline -ostream& operator<<(ostream& out, const RubySystem& obj) + void print(ostream& out) const; + + private: + // Private copy constructor and assignment operator + RubySystem(const RubySystem& obj); + RubySystem& operator=(const RubySystem& obj); + + void init(); + + static void printSystemConfig(ostream& out); + + private: + // configuration parameters + static int m_random_seed; + static bool m_randomization; + static Tick m_clock; + static int m_block_size_bytes; + static int m_block_size_bits; + static uint64 m_memory_size_bytes; + static int m_memory_size_bits; + + static Network* m_network_ptr; + + public: + static Profiler* m_profiler_ptr; + static Tracer* m_tracer_ptr; + static MemoryVector* m_mem_vec_ptr; +}; + +inline ostream& +operator<<(ostream& out, const RubySystem& obj) { -// obj.print(out); - out << flush; - return out; + //obj.print(out); + out << flush; + return out; } class RubyExitCallback : public Callback @@ -153,22 +167,17 @@ class RubyExitCallback : public Callback string stats_filename; public: - /** - * virtualize the destructor to make sure that the correct one - * gets called. - */ - virtual ~RubyExitCallback() {} RubyExitCallback(const string& _stats_filename) { - stats_filename = _stats_filename; + stats_filename = _stats_filename; } virtual void process(); }; -#endif //SYSTEM_H +#endif // __MEM_RUBY_SYSTEM_SYSTEM_HH__ diff --git a/src/mem/ruby/system/TBETable.hh b/src/mem/ruby/system/TBETable.hh index 2b00f7a06..d21946abd 100644 --- a/src/mem/ruby/system/TBETable.hh +++ b/src/mem/ruby/system/TBETable.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,141 +26,115 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * TBETable.hh - * - * Description: - * - * $Id$ - * - */ - -#ifndef TBETABLE_H -#define TBETABLE_H +#ifndef __MEM_RUBY_SYSTEM_TBETABLE_HH__ +#define __MEM_RUBY_SYSTEM_TBETABLE_HH__ -#include "mem/ruby/common/Global.hh" #include "mem/gems_common/Map.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" #include "mem/ruby/profiler/Profiler.hh" #include "mem/ruby/system/System.hh" template<class ENTRY> -class TBETable { -public: - - // Constructors - TBETable(int number_of_TBEs); - - - // Destructor - //~TBETable(); - - // Public Methods - - void printConfig(ostream& out) { out << "TBEs_per_TBETable: " << m_number_of_TBEs << endl; } - - bool isPresent(const Address& address) const; - void allocate(const Address& address); - void deallocate(const Address& address); - bool areNSlotsAvailable(int n) const { return (m_number_of_TBEs - m_map.size()) >= n; } - - ENTRY& lookup(const Address& address); - const ENTRY& lookup(const Address& address) const; - - // Print cache contents - void print(ostream& out) const; -private: - // Private Methods - - // Private copy constructor and assignment operator - TBETable(const TBETable& obj); - TBETable& operator=(const TBETable& obj); - - // Data Members (m_prefix) - Map<Address, ENTRY> m_map; - -private: - int m_number_of_TBEs; -}; - -// Output operator declaration -//ostream& operator<<(ostream& out, const TBETable<ENTRY>& obj); - -// ******************* Definitions ******************* - -// Output operator definition -template<class ENTRY> -extern inline -ostream& operator<<(ostream& out, const TBETable<ENTRY>& obj) +class TBETable { - obj.print(out); - out << flush; - return out; -} - - -// **************************************************************** - + public: + TBETable(int number_of_TBEs) + : m_number_of_TBEs(number_of_TBEs) + { + } + + void + printConfig(ostream& out) + { + out << "TBEs_per_TBETable: " << m_number_of_TBEs << endl; + } + + bool isPresent(const Address& address) const; + void allocate(const Address& address); + void deallocate(const Address& address); + bool + areNSlotsAvailable(int n) const + { + return (m_number_of_TBEs - m_map.size()) >= n; + } + + ENTRY& lookup(const Address& address); + const ENTRY& lookup(const Address& address) const; + + // Print cache contents + void print(ostream& out) const; + + private: + // Private copy constructor and assignment operator + TBETable(const TBETable& obj); + TBETable& operator=(const TBETable& obj); + + // Data Members (m_prefix) + Map<Address, ENTRY> m_map; + + private: + int m_number_of_TBEs; +}; template<class ENTRY> -extern inline -TBETable<ENTRY>::TBETable(int number_of_TBEs) +inline ostream& +operator<<(ostream& out, const TBETable<ENTRY>& obj) { - m_number_of_TBEs = number_of_TBEs; + obj.print(out); + out << flush; + return out; } -// PUBLIC METHODS - -// tests to see if an address is present in the cache template<class ENTRY> -extern inline -bool TBETable<ENTRY>::isPresent(const Address& address) const +inline bool +TBETable<ENTRY>::isPresent(const Address& address) const { - assert(address == line_address(address)); - assert(m_map.size() <= m_number_of_TBEs); - return m_map.exist(address); + assert(address == line_address(address)); + assert(m_map.size() <= m_number_of_TBEs); + return m_map.exist(address); } template<class ENTRY> -extern inline -void TBETable<ENTRY>::allocate(const Address& address) +inline void +TBETable<ENTRY>::allocate(const Address& address) { - assert(isPresent(address) == false); - assert(m_map.size() < m_number_of_TBEs); - m_map.add(address, ENTRY()); + assert(isPresent(address) == false); + assert(m_map.size() < m_number_of_TBEs); + m_map.add(address, ENTRY()); } template<class ENTRY> -extern inline -void TBETable<ENTRY>::deallocate(const Address& address) +inline void +TBETable<ENTRY>::deallocate(const Address& address) { - assert(isPresent(address) == true); - assert(m_map.size() > 0); - m_map.erase(address); + assert(isPresent(address) == true); + assert(m_map.size() > 0); + m_map.erase(address); } // looks an address up in the cache template<class ENTRY> -extern inline -ENTRY& TBETable<ENTRY>::lookup(const Address& address) +inline ENTRY& +TBETable<ENTRY>::lookup(const Address& address) { - assert(isPresent(address) == true); - return m_map.lookup(address); + assert(isPresent(address) == true); + return m_map.lookup(address); } // looks an address up in the cache template<class ENTRY> -extern inline -const ENTRY& TBETable<ENTRY>::lookup(const Address& address) const +inline const ENTRY& +TBETable<ENTRY>::lookup(const Address& address) const { - assert(isPresent(address) == true); - return m_map.lookup(address); + assert(isPresent(address) == true); + return m_map.lookup(address); } template<class ENTRY> -extern inline -void TBETable<ENTRY>::print(ostream& out) const +inline void +TBETable<ENTRY>::print(ostream& out) const { } -#endif //TBETABLE_H +#endif // __MEM_RUBY_SYSTEM_TBETABLE_HH__ diff --git a/src/mem/ruby/system/TimerTable.cc b/src/mem/ruby/system/TimerTable.cc index 5d496da04..eba04e3e3 100644 --- a/src/mem/ruby/system/TimerTable.cc +++ b/src/mem/ruby/system/TimerTable.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,101 +26,101 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * $Id$ - */ - #include "mem/ruby/common/Global.hh" -#include "mem/ruby/system/TimerTable.hh" #include "mem/ruby/eventqueue/RubyEventQueue.hh" +#include "mem/ruby/system/TimerTable.hh" TimerTable::TimerTable() { - m_consumer_ptr = NULL; - m_next_valid = false; - m_next_address = Address(0); - m_next_time = 0; + m_consumer_ptr = NULL; + m_next_valid = false; + m_next_address = Address(0); + m_next_time = 0; } - -bool TimerTable::isReady() const +bool +TimerTable::isReady() const { - if (m_map.size() == 0) { - return false; - } + if (m_map.size() == 0) { + return false; + } - if (!m_next_valid) { - updateNext(); - } - assert(m_next_valid); - return (g_eventQueue_ptr->getTime() >= m_next_time); + if (!m_next_valid) { + updateNext(); + } + assert(m_next_valid); + return (g_eventQueue_ptr->getTime() >= m_next_time); } -const Address& TimerTable::readyAddress() const +const Address& +TimerTable::readyAddress() const { - assert(isReady()); + assert(isReady()); - if (!m_next_valid) { - updateNext(); - } - assert(m_next_valid); - return m_next_address; + if (!m_next_valid) { + updateNext(); + } + assert(m_next_valid); + return m_next_address; } -void TimerTable::set(const Address& address, Time relative_latency) +void +TimerTable::set(const Address& address, Time relative_latency) { - assert(address == line_address(address)); - assert(relative_latency > 0); - assert(m_map.exist(address) == false); - Time ready_time = g_eventQueue_ptr->getTime() + relative_latency; - m_map.add(address, ready_time); - assert(m_consumer_ptr != NULL); - g_eventQueue_ptr->scheduleEventAbsolute(m_consumer_ptr, ready_time); - m_next_valid = false; - - // Don't always recalculate the next ready address - if (ready_time <= m_next_time) { + assert(address == line_address(address)); + assert(relative_latency > 0); + assert(m_map.exist(address) == false); + Time ready_time = g_eventQueue_ptr->getTime() + relative_latency; + m_map.add(address, ready_time); + assert(m_consumer_ptr != NULL); + g_eventQueue_ptr->scheduleEventAbsolute(m_consumer_ptr, ready_time); m_next_valid = false; - } + + // Don't always recalculate the next ready address + if (ready_time <= m_next_time) { + m_next_valid = false; + } } -void TimerTable::unset(const Address& address) +void +TimerTable::unset(const Address& address) { - assert(address == line_address(address)); - assert(m_map.exist(address) == true); - m_map.remove(address); + assert(address == line_address(address)); + assert(m_map.exist(address) == true); + m_map.remove(address); - // Don't always recalculate the next ready address - if (address == m_next_address) { - m_next_valid = false; - } + // Don't always recalculate the next ready address + if (address == m_next_address) { + m_next_valid = false; + } } -void TimerTable::print(ostream& out) const +void +TimerTable::print(ostream& out) const { } - -void TimerTable::updateNext() const +void +TimerTable::updateNext() const { - if (m_map.size() == 0) { - assert(m_next_valid == false); - return; - } - - Vector<Address> addresses = m_map.keys(); - m_next_address = addresses[0]; - m_next_time = m_map.lookup(m_next_address); + if (m_map.size() == 0) { + assert(m_next_valid == false); + return; + } - // Search for the minimum time - int size = addresses.size(); - for (int i=1; i<size; i++) { - Address maybe_next_address = addresses[i]; - Time maybe_next_time = m_map.lookup(maybe_next_address); - if (maybe_next_time < m_next_time) { - m_next_time = maybe_next_time; - m_next_address= maybe_next_address; + Vector<Address> addresses = m_map.keys(); + m_next_address = addresses[0]; + m_next_time = m_map.lookup(m_next_address); + + // Search for the minimum time + int size = addresses.size(); + for (int i=1; i<size; i++) { + Address maybe_next_address = addresses[i]; + Time maybe_next_time = m_map.lookup(maybe_next_address); + if (maybe_next_time < m_next_time) { + m_next_time = maybe_next_time; + m_next_address= maybe_next_address; + } } - } - m_next_valid = true; + m_next_valid = true; } diff --git a/src/mem/ruby/system/TimerTable.hh b/src/mem/ruby/system/TimerTable.hh index eda84069d..96b4b0b15 100644 --- a/src/mem/ruby/system/TimerTable.hh +++ b/src/mem/ruby/system/TimerTable.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,70 +26,69 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * TimerTable.hh - * - * Description: - * - * $Id$ - * - */ +#ifndef __MEM_RUBY_SYSTEM_TIMERTABLE_HH__ +#define __MEM_RUBY_SYSTEM_TIMERTABLE_HH__ -#ifndef TIMERTABLE_H -#define TIMERTABLE_H +#include <cassert> -#include "mem/ruby/common/Global.hh" #include "mem/gems_common/Map.hh" #include "mem/ruby/common/Address.hh" +#include "mem/ruby/common/Global.hh" + class Consumer; -class TimerTable { -public: +class TimerTable +{ + public: + TimerTable(); - // Constructors - TimerTable(); + static void printConfig(ostream& out) {} - // Destructor - //~TimerTable(); + void + setConsumer(Consumer* consumer_ptr) + { + assert(m_consumer_ptr == NULL); + m_consumer_ptr = consumer_ptr; + } - // Class Methods - static void printConfig(ostream& out) {} + void + setDescription(const string& name) + { + m_name = name; + } - // Public Methods - void setConsumer(Consumer* consumer_ptr) { ASSERT(m_consumer_ptr==NULL); m_consumer_ptr = consumer_ptr; } - void setDescription(const string& name) { m_name = name; } + bool isReady() const; + const Address& readyAddress() const; + bool isSet(const Address& address) const { return m_map.exist(address); } + void set(const Address& address, Time relative_latency); + void unset(const Address& address); + void print(ostream& out) const; - bool isReady() const; - const Address& readyAddress() const; - bool isSet(const Address& address) const { return m_map.exist(address); } - void set(const Address& address, Time relative_latency); - void unset(const Address& address); - void print(ostream& out) const; -private: - // Private Methods - void updateNext() const; + private: + void updateNext() const; - // Private copy constructor and assignment operator - TimerTable(const TimerTable& obj); - TimerTable& operator=(const TimerTable& obj); + // Private copy constructor and assignment operator + TimerTable(const TimerTable& obj); + TimerTable& operator=(const TimerTable& obj); - // Data Members (m_prefix) - Map<Address, Time> m_map; - mutable bool m_next_valid; - mutable Time m_next_time; // Only valid if m_next_valid is true - mutable Address m_next_address; // Only valid if m_next_valid is true - Consumer* m_consumer_ptr; // Consumer to signal a wakeup() - string m_name; + // Data Members (m_prefix) + Map<Address, Time> m_map; + mutable bool m_next_valid; + mutable Time m_next_time; // Only valid if m_next_valid is true + mutable Address m_next_address; // Only valid if m_next_valid is true + Consumer* m_consumer_ptr; // Consumer to signal a wakeup() + string m_name; }; // ******************* Definitions ******************* // Output operator definition -extern inline -ostream& operator<<(ostream& out, const TimerTable& obj) +inline ostream& +operator<<(ostream& out, const TimerTable& obj) { - obj.print(out); - out << flush; - return out; + obj.print(out); + out << flush; + return out; } -#endif //TIMERTABLE_H + +#endif // __MEM_RUBY_SYSTEM_TIMERTABLE_HH__ |