From 47c8cb72fc0b400326c7b9b1f82542d4b72295bd Mon Sep 17 00:00:00 2001 From: Nilay Vaish Date: Fri, 22 Mar 2013 15:53:27 -0500 Subject: ruby: message buffer: remove _ptr from some variables The names were getting too long. --- src/mem/ruby/buffers/MessageBuffer.cc | 83 +++++++++++++++++------------------ src/mem/ruby/buffers/MessageBuffer.hh | 22 +++++----- 2 files changed, 52 insertions(+), 53 deletions(-) (limited to 'src') diff --git a/src/mem/ruby/buffers/MessageBuffer.cc b/src/mem/ruby/buffers/MessageBuffer.cc index c0a5cbb48..57ce73292 100644 --- a/src/mem/ruby/buffers/MessageBuffer.cc +++ b/src/mem/ruby/buffers/MessageBuffer.cc @@ -43,9 +43,9 @@ MessageBuffer::MessageBuffer(const string &name) m_time_last_time_pop(0), m_last_arrival_time(0) { m_msg_counter = 0; - m_consumer_ptr = NULL; - m_sender_ptr = NULL; - m_receiver_ptr = NULL; + m_consumer = NULL; + m_sender = NULL; + m_receiver = NULL; m_ordering_set = false; m_strict_fifo = true; @@ -67,10 +67,10 @@ MessageBuffer::MessageBuffer(const string &name) int MessageBuffer::getSize() { - if (m_time_last_time_size_checked == m_receiver_ptr->curCycle()) { + if (m_time_last_time_size_checked == m_receiver->curCycle()) { return m_size_last_time_size_checked; } else { - m_time_last_time_size_checked = m_receiver_ptr->curCycle(); + m_time_last_time_size_checked = m_receiver->curCycle(); m_size_last_time_size_checked = m_size; return m_size; } @@ -90,11 +90,11 @@ MessageBuffer::areNSlotsAvailable(int n) // 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 < m_receiver_ptr->curCycle()) { + if (m_time_last_time_pop < m_receiver->curCycle()) { // no pops this cycle - m_size is correct current_size = m_size; } else { - if (m_time_last_time_enqueue < m_receiver_ptr->curCycle()) { + if (m_time_last_time_enqueue < m_receiver->curCycle()) { // no enqueues this cycle - m_size_at_cycle_start is correct current_size = m_size_at_cycle_start; } else { @@ -156,9 +156,9 @@ MessageBuffer::enqueue(MsgPtr message, Cycles delay) m_size++; // record current time incase we have a pop that also adjusts my size - if (m_time_last_time_enqueue < m_receiver_ptr->curCycle()) { + if (m_time_last_time_enqueue < m_receiver->curCycle()) { m_msgs_this_cycle = 0; // first msg this cycle - m_time_last_time_enqueue = m_receiver_ptr->curCycle(); + m_time_last_time_enqueue = m_receiver->curCycle(); } m_msgs_this_cycle++; @@ -169,10 +169,9 @@ MessageBuffer::enqueue(MsgPtr message, Cycles delay) // Calculate the arrival time of the message, that is, the first // cycle the message can be dequeued. assert(delay > 0); - Cycles delta = m_receiver_ptr->ticksToCycles(delay * - m_sender_ptr->clockPeriod()); + Cycles delta = m_receiver->ticksToCycles(delay * m_sender->clockPeriod()); - Cycles current_time(m_receiver_ptr->curCycle()); + Cycles current_time(m_receiver->curCycle()); Cycles arrival_time(0); if (!RubySystem::getRandomization() || (m_randomization == false)) { @@ -196,10 +195,10 @@ MessageBuffer::enqueue(MsgPtr message, Cycles delay) if (arrival_time < m_last_arrival_time) { panic("FIFO ordering violated: %s name: %s current time: %d " "delta: %d arrival_time: %d last arrival_time: %d\n", - *this, m_name, current_time * m_receiver_ptr->clockPeriod(), - delta * m_receiver_ptr->clockPeriod(), - arrival_time * m_receiver_ptr->clockPeriod(), - m_last_arrival_time * m_receiver_ptr->clockPeriod()); + *this, m_name, current_time * m_receiver->clockPeriod(), + delta * m_receiver->clockPeriod(), + arrival_time * m_receiver->clockPeriod(), + m_last_arrival_time * m_receiver->clockPeriod()); } } @@ -212,29 +211,29 @@ MessageBuffer::enqueue(MsgPtr message, Cycles delay) Message* msg_ptr = message.get(); assert(msg_ptr != NULL); - assert(m_receiver_ptr->clockEdge() >= msg_ptr->getLastEnqueueTime() && + assert(m_receiver->clockEdge() >= msg_ptr->getLastEnqueueTime() && "ensure we aren't dequeued early"); - msg_ptr->setDelayedTicks(m_receiver_ptr->clockEdge() - + msg_ptr->setDelayedTicks(m_receiver->clockEdge() - msg_ptr->getLastEnqueueTime() + msg_ptr->getDelayedTicks()); - msg_ptr->setLastEnqueueTime(arrival_time * m_receiver_ptr->clockPeriod()); + msg_ptr->setLastEnqueueTime(arrival_time * m_receiver->clockPeriod()); // Insert the message into the priority heap - MessageBufferNode thisNode(arrival_time * m_receiver_ptr->clockPeriod(), + MessageBufferNode thisNode(arrival_time * m_receiver->clockPeriod(), m_msg_counter, message); m_prio_heap.push_back(thisNode); push_heap(m_prio_heap.begin(), m_prio_heap.end(), greater()); DPRINTF(RubyQueue, "Enqueue arrival_time: %lld, Message: %s\n", - arrival_time * m_receiver_ptr->clockPeriod(), *(message.get())); + arrival_time * m_receiver->clockPeriod(), *(message.get())); // Schedule the wakeup - if (m_consumer_ptr != NULL) { - m_consumer_ptr->scheduleEventAbsolute( - arrival_time * m_receiver_ptr->clockPeriod()); - m_consumer_ptr->storeEventInfo(m_vnet_id); + if (m_consumer != NULL) { + m_consumer->scheduleEventAbsolute( + arrival_time * m_receiver->clockPeriod()); + m_consumer->storeEventInfo(m_vnet_id); } else { panic("No consumer: %s name: %s\n", *this, m_name); } @@ -281,9 +280,9 @@ MessageBuffer::pop() // record previous size and time so the current buffer size isn't // adjusted until next cycle - if (m_time_last_time_pop < m_receiver_ptr->curCycle()) { + if (m_time_last_time_pop < m_receiver->curCycle()) { m_size_at_cycle_start = m_size; - m_time_last_time_pop = m_receiver_ptr->curCycle(); + m_time_last_time_pop = m_receiver->curCycle(); } m_size--; } @@ -310,13 +309,13 @@ MessageBuffer::recycle() pop_heap(m_prio_heap.begin(), m_prio_heap.end(), greater()); - node.m_time = (m_receiver_ptr->curCycle() + m_recycle_latency) * - m_receiver_ptr->clockPeriod(); + node.m_time = (m_receiver->curCycle() + m_recycle_latency) * + m_receiver->clockPeriod(); m_prio_heap.back() = node; push_heap(m_prio_heap.begin(), m_prio_heap.end(), greater()); - m_consumer_ptr-> - scheduleEventAbsolute(m_receiver_ptr->clockEdge(m_recycle_latency)); + m_consumer-> + scheduleEventAbsolute(m_receiver->clockEdge(m_recycle_latency)); } void @@ -324,7 +323,7 @@ MessageBuffer::reanalyzeMessages(const Address& addr) { DPRINTF(RubyQueue, "ReanalyzeMessages\n"); assert(m_stall_msg_map.count(addr) > 0); - Tick nextTick = m_receiver_ptr->clockEdge(Cycles(1)); + Tick nextTick = m_receiver->clockEdge(Cycles(1)); // // Put all stalled messages associated with this address back on the @@ -339,7 +338,7 @@ MessageBuffer::reanalyzeMessages(const Address& addr) push_heap(m_prio_heap.begin(), m_prio_heap.end(), greater()); - m_consumer_ptr->scheduleEventAbsolute(nextTick); + m_consumer->scheduleEventAbsolute(nextTick); m_stall_msg_map[addr].pop_front(); } m_stall_msg_map.erase(addr); @@ -349,7 +348,7 @@ void MessageBuffer::reanalyzeAllMessages() { DPRINTF(RubyQueue, "ReanalyzeAllMessages %s\n"); - Tick nextTick = m_receiver_ptr->clockEdge(Cycles(1)); + Tick nextTick = m_receiver->clockEdge(Cycles(1)); // // Put all stalled messages associated with this address back on the @@ -368,7 +367,7 @@ MessageBuffer::reanalyzeAllMessages() push_heap(m_prio_heap.begin(), m_prio_heap.end(), greater()); - m_consumer_ptr->scheduleEventAbsolute(nextTick); + m_consumer->scheduleEventAbsolute(nextTick); (map_iter->second).pop_front(); } } @@ -400,20 +399,20 @@ MessageBuffer::setAndReturnDelayCycles(MsgPtr msg_ptr) // this function should only be called on dequeue // ensure the msg hasn't been enqueued - assert(msg_ptr->getLastEnqueueTime() <= m_receiver_ptr->clockEdge()); + assert(msg_ptr->getLastEnqueueTime() <= m_receiver->clockEdge()); - msg_ptr->setDelayedTicks(m_receiver_ptr->clockEdge() - - msg_ptr->getLastEnqueueTime() + - msg_ptr->getDelayedTicks()); + msg_ptr->setDelayedTicks(m_receiver->clockEdge() - + msg_ptr->getLastEnqueueTime() + + msg_ptr->getDelayedTicks()); - return m_receiver_ptr->ticksToCycles(msg_ptr->getDelayedTicks()); + return m_receiver->ticksToCycles(msg_ptr->getDelayedTicks()); } void MessageBuffer::print(ostream& out) const { ccprintf(out, "[MessageBuffer: "); - if (m_consumer_ptr != NULL) { + if (m_consumer != NULL) { ccprintf(out, " consumer-yes "); } @@ -433,7 +432,7 @@ bool MessageBuffer::isReady() const { return ((m_prio_heap.size() > 0) && - (m_prio_heap.front().m_time <= m_receiver_ptr->clockEdge())); + (m_prio_heap.front().m_time <= m_receiver->clockEdge())); } bool diff --git a/src/mem/ruby/buffers/MessageBuffer.hh b/src/mem/ruby/buffers/MessageBuffer.hh index 2a52d2a2e..01bbcb525 100644 --- a/src/mem/ruby/buffers/MessageBuffer.hh +++ b/src/mem/ruby/buffers/MessageBuffer.hh @@ -77,28 +77,28 @@ class MessageBuffer bool areNSlotsAvailable(int n); int getPriority() { return m_priority_rank; } void setPriority(int rank) { m_priority_rank = rank; } - void setConsumer(Consumer* consumer_ptr) + void setConsumer(Consumer* consumer) { - assert(m_consumer_ptr == NULL); - m_consumer_ptr = consumer_ptr; + assert(m_consumer == NULL); + m_consumer = consumer; } void setSender(ClockedObject* obj) { - assert(m_sender_ptr == NULL || m_sender_ptr == obj); - m_sender_ptr = obj; + assert(m_sender == NULL || m_sender == obj); + m_sender = obj; } void setReceiver(ClockedObject* obj) { - assert(m_receiver_ptr == NULL || m_receiver_ptr == obj); - m_receiver_ptr = obj; + assert(m_receiver == NULL || m_receiver == obj); + m_receiver = obj; } void setDescription(const std::string& name) { m_name = name; } std::string getDescription() { return m_name;} - Consumer* getConsumer() { return m_consumer_ptr; } + Consumer* getConsumer() { return m_consumer; } const Message* peekAtHeadOfQueue() const; const Message* peek() const { return peekAtHeadOfQueue(); } @@ -174,11 +174,11 @@ class MessageBuffer // Data Members (m_ prefix) //! The two ends of the buffer. - ClockedObject* m_sender_ptr; - ClockedObject* m_receiver_ptr; + ClockedObject* m_sender; + ClockedObject* m_receiver; //! Consumer to signal a wakeup(), can be NULL - Consumer* m_consumer_ptr; + Consumer* m_consumer; std::vector m_prio_heap; // use a std::map for the stalled messages as this container is -- cgit v1.2.3