gem5  v22.1.0.0
MessageBuffer.hh
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2019-2021 ARM Limited
3  * All rights reserved.
4  *
5  * The license below extends only to copyright in the software and shall
6  * not be construed as granting a license to any other intellectual
7  * property including but not limited to intellectual property relating
8  * to a hardware implementation of the functionality of the software
9  * licensed hereunder. You may use the software subject to the license
10  * terms below provided that you ensure that this notice is replicated
11  * unmodified and in its entirety in all distributions of the software,
12  * modified or unmodified, in source code or in binary form.
13  *
14  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
15  * All rights reserved.
16  *
17  * Redistribution and use in source and binary forms, with or without
18  * modification, are permitted provided that the following conditions are
19  * met: redistributions of source code must retain the above copyright
20  * notice, this list of conditions and the following disclaimer;
21  * redistributions in binary form must reproduce the above copyright
22  * notice, this list of conditions and the following disclaimer in the
23  * documentation and/or other materials provided with the distribution;
24  * neither the name of the copyright holders nor the names of its
25  * contributors may be used to endorse or promote products derived from
26  * this software without specific prior written permission.
27  *
28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39  */
40 
41 /*
42  * Unordered buffer of messages that can be inserted such
43  * that they can be dequeued after a given delta time has expired.
44  */
45 
46 #ifndef __MEM_RUBY_NETWORK_MESSAGEBUFFER_HH__
47 #define __MEM_RUBY_NETWORK_MESSAGEBUFFER_HH__
48 
49 #include <algorithm>
50 #include <cassert>
51 #include <functional>
52 #include <iostream>
53 #include <string>
54 #include <unordered_map>
55 #include <vector>
56 
57 #include "base/trace.hh"
58 #include "debug/RubyQueue.hh"
59 #include "mem/packet.hh"
60 #include "mem/port.hh"
65 #include "params/MessageBuffer.hh"
66 #include "sim/sim_object.hh"
67 
68 namespace gem5
69 {
70 
71 namespace ruby
72 {
73 
74 class MessageBuffer : public SimObject
75 {
76  public:
77  typedef MessageBufferParams Params;
78  MessageBuffer(const Params &p);
79 
80  void reanalyzeMessages(Addr addr, Tick current_time);
81  void reanalyzeAllMessages(Tick current_time);
82  void stallMessage(Addr addr, Tick current_time);
83  // return true if the stall map has a message of this address
84  bool hasStalledMsg(Addr addr) const;
85 
86  // TRUE if head of queue timestamp <= SystemTime
87  bool isReady(Tick current_time) const;
88 
89  // earliest tick the head of queue will be ready, or MaxTick if empty
90  Tick readyTime() const;
91 
92  void
93  delayHead(Tick current_time, Tick delta)
94  {
95  MsgPtr m = m_prio_heap.front();
96  std::pop_heap(m_prio_heap.begin(), m_prio_heap.end(),
97  std::greater<MsgPtr>());
98  m_prio_heap.pop_back();
99  enqueue(m, current_time, delta);
100  }
101 
102  bool areNSlotsAvailable(unsigned int n, Tick curTime);
103  int getPriority() { return m_priority_rank; }
104  void setPriority(int rank) { m_priority_rank = rank; }
105  void setConsumer(Consumer* consumer)
106  {
107  DPRINTF(RubyQueue, "Setting consumer: %s\n", *consumer);
108  if (m_consumer != NULL) {
109  fatal("Trying to connect %s to MessageBuffer %s. \
110  \n%s already connected. Check the cntrl_id's.\n",
111  *consumer, *this, *m_consumer);
112  }
113  m_consumer = consumer;
114  }
115 
117 
118  bool getOrdered() { return m_strict_fifo; }
119 
122  const Message* peek() const;
123 
124  const MsgPtr &peekMsgPtr() const { return m_prio_heap.front(); }
125 
126  void enqueue(MsgPtr message, Tick curTime, Tick delta);
127 
128  // Defer enqueueing a message to a later cycle by putting it aside and not
129  // enqueueing it in this cycle
130  // The corresponding controller will need to explicitly enqueue the
131  // deferred message into the message buffer. Otherwise, the message will
132  // be lost.
133  void deferEnqueueingMessage(Addr addr, MsgPtr message);
134 
135  // enqueue all previously deferred messages that are associated with the
136  // input address
137  void enqueueDeferredMessages(Addr addr, Tick curTime, Tick delay);
138  bool isDeferredMsgMapEmpty(Addr addr) const;
139 
142  Tick dequeue(Tick current_time, bool decrement_messages = true);
143 
144  void registerDequeueCallback(std::function<void()> callback);
146 
147  void recycle(Tick current_time, Tick recycle_latency);
148  bool isEmpty() const { return m_prio_heap.size() == 0; }
149  bool isStallMapEmpty() { return m_stall_msg_map.size() == 0; }
150  unsigned int getStallMapSize() { return m_stall_msg_map.size(); }
151 
152  unsigned int getSize(Tick curTime);
153 
154  void clear();
155  void print(std::ostream& out) const;
157 
158  void setIncomingLink(int link_id) { m_input_link_id = link_id; }
159  void setVnet(int net) { m_vnet_id = net; }
160 
161  int getIncomingLink() const { return m_input_link_id; }
162  int getVnet() const { return m_vnet_id; }
163 
164  Port &
165  getPort(const std::string &, PortID idx=InvalidPortID) override
166  {
167  return RubyDummyPort::instance();
168  }
169 
170  // Function for figuring out if any of the messages in the buffer need
171  // to be updated with the data from the packet.
172  // Return value indicates the number of messages that were updated.
173  uint32_t functionalWrite(Packet *pkt)
174  {
175  return functionalAccess(pkt, false, nullptr);
176  }
177 
178  // Function for figuring if message in the buffer has valid data for
179  // the packet.
180  // Returns true only if a message was found with valid data and the
181  // read was performed.
183  {
184  return functionalAccess(pkt, true, nullptr) == 1;
185  }
186 
187  // Functional read with mask
189  {
190  return functionalAccess(pkt, true, &mask) == 1;
191  }
192 
193  int routingPriority() const { return m_routing_priority; }
194 
195  private:
197 
198  uint32_t functionalAccess(Packet *pkt, bool is_read, WriteMask *mask);
199 
200  private:
201  // Data Members (m_ prefix)
205 
206  std::function<void()> m_dequeue_callback;
207 
208  // use a std::map for the stalled messages as this container is
209  // sorted and ensures a well-defined iteration order
210  typedef std::map<Addr, std::list<MsgPtr> > StallMsgMapType;
211 
226 
232  typedef std::unordered_map<Addr, std::vector<MsgPtr>> DeferredMsgMapType;
234 
242 
249  const unsigned int m_max_size;
250 
255  const unsigned int m_max_dequeue_rate;
256 
257  unsigned int m_dequeues_this_cy;
258 
261 
262  // variables used so enqueues appear to happen immediately, while
263  // pop happen the next cycle
267 
268  unsigned int m_size_at_cycle_start;
270  unsigned int m_msgs_this_cycle;
271 
272  uint64_t m_msg_counter;
274  const bool m_strict_fifo;
275  const MessageRandomization m_randomization;
277 
279 
282 
283  // Count the # of times I didn't have N slots available
291 };
292 
293 Tick random_time();
294 
295 inline std::ostream&
296 operator<<(std::ostream& out, const MessageBuffer& obj)
297 {
298  obj.print(out);
299  out << std::flush;
300  return out;
301 }
302 
303 } // namespace ruby
304 } // namespace gem5
305 
306 #endif //__MEM_RUBY_NETWORK_MESSAGEBUFFER_HH__
#define DPRINTF(x,...)
Definition: trace.hh:186
A Packet is used to encapsulate a transfer between two objects in the memory system (e....
Definition: packet.hh:294
Ports are used to interface objects to each other.
Definition: port.hh:62
Abstract superclass for simulation objects.
Definition: sim_object.hh:148
statistics::Scalar m_stall_count
bool isDeferredMsgMapEmpty(Addr addr) const
void setConsumer(Consumer *consumer)
void recycle(Tick current_time, Tick recycle_latency)
MessageBuffer(const Params &p)
bool areNSlotsAvailable(unsigned int n, Tick curTime)
void setIncomingLink(int link_id)
bool isReady(Tick current_time) const
const Message * peek() const
Function for extracting the message at the head of the message queue.
unsigned int m_size_last_time_size_checked
Port & getPort(const std::string &, PortID idx=InvalidPortID) override
Get a port with a given name and index.
void enqueueDeferredMessages(Addr addr, Tick curTime, Tick delay)
unsigned int getStallMapSize()
std::unordered_map< Addr, std::vector< MsgPtr > > DeferredMsgMapType
A map from line addresses to corresponding vectors of messages that are deferred for enqueueing.
const unsigned int m_max_dequeue_rate
When != 0, isReady returns false once m_max_dequeue_rate messages have been dequeued in the same cycl...
MessageBufferParams Params
bool functionalRead(Packet *pkt)
const unsigned int m_max_size
The maximum capacity.
void reanalyzeAllMessages(Tick current_time)
unsigned int m_stalled_at_cycle_start
const MsgPtr & peekMsgPtr() const
statistics::Formula m_avg_stall_time
Consumer * m_consumer
Consumer to signal a wakeup(), can be NULL.
Tick dequeue(Tick current_time, bool decrement_messages=true)
Updates the delay cycles of the message at the head of the queue, removes it from the queue and retur...
statistics::Average m_buf_msgs
statistics::Scalar m_stall_time
bool hasStalledMsg(Addr addr) const
std::map< Addr, std::list< MsgPtr > > StallMsgMapType
std::vector< MsgPtr > m_prio_heap
void enqueue(MsgPtr message, Tick curTime, Tick delta)
void delayHead(Tick current_time, Tick delta)
void deferEnqueueingMessage(Addr addr, MsgPtr message)
void registerDequeueCallback(std::function< void()> callback)
StallMsgMapType m_stall_msg_map
A map from line addresses to lists of stalled messages for that line.
void stallMessage(Addr addr, Tick current_time)
statistics::Scalar m_msg_count
unsigned int m_size_at_cycle_start
statistics::Formula m_occupancy
void print(std::ostream &out) const
void reanalyzeMessages(Addr addr, Tick current_time)
const MessageRandomization m_randomization
void reanalyzeList(std::list< MsgPtr > &, Tick)
unsigned int getSize(Tick curTime)
int m_stall_map_size
Current size of the stall map.
statistics::Scalar m_not_avail_count
std::function< void()> m_dequeue_callback
uint32_t functionalAccess(Packet *pkt, bool is_read, WriteMask *mask)
uint32_t functionalWrite(Packet *pkt)
DeferredMsgMapType m_deferred_msg_map
bool functionalRead(Packet *pkt, WriteMask &mask)
static RubyDummyPort & instance()
Definition: dummy_port.hh:56
A stat that calculates the per tick average of a value.
Definition: statistics.hh:1959
A formula for statistics that is calculated when printed.
Definition: statistics.hh:2540
This is a simple scalar statistic, like a counter.
Definition: statistics.hh:1931
STL list class.
Definition: stl.hh:51
constexpr uint64_t mask(unsigned nbits)
Generate a 64-bit mask of 'nbits' 1s, right justified.
Definition: bitfield.hh:63
#define fatal(...)
This implements a cprintf based fatal() function.
Definition: logging.hh:190
Port Object Declaration.
Bitfield< 31 > n
Definition: misc_types.hh:462
Bitfield< 54 > p
Definition: pagetable.hh:70
Bitfield< 3 > addr
Definition: types.hh:84
std::shared_ptr< Message > MsgPtr
Definition: Message.hh:59
Tick random_time()
std::ostream & operator<<(std::ostream &os, const BoolVec &myvector)
Definition: BoolVec.cc:49
Reference material can be found at the JEDEC website: UFS standard http://www.jedec....
const PortID InvalidPortID
Definition: types.hh:246
uint64_t Addr
Address type This will probably be moved somewhere else in the near future.
Definition: types.hh:147
int16_t PortID
Port index/ID type, and a symbolic name for an invalid port id.
Definition: types.hh:245
uint64_t Tick
Tick count type.
Definition: types.hh:58
Declaration of the Packet class.

Generated on Wed Dec 21 2022 10:22:38 for gem5 by doxygen 1.9.1