gem5  v21.1.0.2
AbstractController.hh
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017,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) 2009-2014 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 #ifndef __MEM_RUBY_SLICC_INTERFACE_ABSTRACTCONTROLLER_HH__
42 #define __MEM_RUBY_SLICC_INTERFACE_ABSTRACTCONTROLLER_HH__
43 
44 #include <exception>
45 #include <iostream>
46 #include <string>
47 #include <unordered_map>
48 
49 #include "base/addr_range.hh"
50 #include "base/addr_range_map.hh"
51 #include "base/callback.hh"
52 #include "mem/packet.hh"
53 #include "mem/qport.hh"
60 #include "mem/ruby/protocol/AccessPermission.hh"
62 #include "params/RubyController.hh"
63 #include "sim/clocked_object.hh"
64 
65 namespace gem5
66 {
67 
68 namespace ruby
69 {
70 
71 class Network;
72 class GPUCoalescer;
73 class DMASequencer;
74 
75 // used to communicate that an in_port peeked the wrong message type
76 class RejectException: public std::exception
77 {
78  virtual const char* what() const throw()
79  { return "Port rejected message based on type"; }
80 };
81 
83 {
84  public:
85  PARAMS(RubyController);
86  AbstractController(const Params &p);
87  void init();
88 
89  NodeID getVersion() const { return m_machineID.getNum(); }
90  MachineType getType() const { return m_machineID.getType(); }
91 
92  void initNetworkPtr(Network* net_ptr) { m_net_ptr = net_ptr; }
93 
94  // return instance name
96  bool isBlocked(Addr) const;
97  void unblock(Addr);
98  bool isBlocked(Addr);
99 
100  virtual MessageBuffer* getMandatoryQueue() const = 0;
101  virtual MessageBuffer* getMemReqQueue() const = 0;
102  virtual MessageBuffer* getMemRespQueue() const = 0;
103  virtual AccessPermission getAccessPermission(const Addr &addr) = 0;
104 
105  virtual void print(std::ostream & out) const = 0;
106  virtual void wakeup() = 0;
107  virtual void resetStats() = 0;
108  virtual void regStats();
109 
110  virtual void recordCacheTrace(int cntrl, CacheRecorder* tr) = 0;
111  virtual Sequencer* getCPUSequencer() const = 0;
112  virtual DMASequencer* getDMASequencer() const = 0;
113  virtual GPUCoalescer* getGPUCoalescer() const = 0;
114 
115  // This latency is used by the sequencer when enqueueing requests.
116  // Different latencies may be used depending on the request type.
117  // This is the hit latency unless the top-level cache controller
118  // introduces additional cycles in the response path.
119  virtual Cycles mandatoryQueueLatency(const RubyRequestType& param_type)
120  { return m_mandatory_queue_latency; }
121 
124  virtual bool functionalReadBuffers(PacketPtr&) = 0;
125  virtual void functionalRead(const Addr &addr, PacketPtr)
126  { panic("functionalRead(Addr,PacketPtr) not implemented"); }
127 
130  virtual bool functionalReadBuffers(PacketPtr&, WriteMask &mask) = 0;
131  virtual void functionalRead(const Addr &addr, PacketPtr pkt,
132  WriteMask &mask)
133  { panic("functionalRead(Addr,PacketPtr,WriteMask) not implemented"); }
134 
138  virtual int functionalWriteBuffers(PacketPtr&) = 0;
139  virtual int functionalWrite(const Addr &addr, PacketPtr) = 0;
141 
143  virtual void enqueuePrefetch(const Addr &, const RubyRequestType&)
144  { fatal("Prefetches not implemented!");}
145 
148  virtual void notifyCoalesced(const Addr& addr,
149  const RubyRequestType& type,
150  const RequestPtr& req,
151  const DataBlock& data_blk,
152  const bool& was_miss)
153  { }
154 
158  virtual void collateStats()
159  {fatal("collateStats() should be overridden!");}
160 
162  virtual void initNetQueues() = 0;
163 
165  Port &getPort(const std::string &if_name,
166  PortID idx=InvalidPortID);
167 
168  void recvTimingResp(PacketPtr pkt);
170 
171  const AddrRangeList &getAddrRanges() const { return addrRanges; }
172 
173  public:
174  MachineID getMachineID() const { return m_machineID; }
175  RequestorID getRequestorId() const { return m_id; }
176 
179  { return *(stats.delayVCHistogram[index]); }
180 
182  {
183  for (auto &range: addrRanges)
184  if (range.contains(addr)) return true;
185  return false;
186  }
187 
201  MachineID mapAddressToMachine(Addr addr, MachineType mtype) const;
202 
215  MachineType mtype = MachineType_NUM) const;
216 
218 
219  protected:
221  void profileRequest(const std::string &request);
223  void profileMsgDelay(uint32_t virtualNetwork, Cycles delay);
224 
225  // Tracks outstanding transactions for latency profiling
226  struct TransMapPair { unsigned transaction; unsigned state; Tick time; };
227  std::unordered_map<Addr, TransMapPair> m_inTrans;
228  std::unordered_map<Addr, TransMapPair> m_outTrans;
229 
240  template<typename EventType, typename StateType>
242  EventType type, StateType initialState, bool retried)
243  {
244  assert(m_inTrans.find(addr) == m_inTrans.end());
245  m_inTrans[addr] = {type, initialState, curTick()};
246  if (retried)
248  }
249 
256  template<typename StateType>
257  void incomingTransactionEnd(Addr addr, StateType finalState)
258  {
259  auto iter = m_inTrans.find(addr);
260  assert(iter != m_inTrans.end());
261  stats.inTransLatHist[iter->second.transaction]
262  [iter->second.state]
263  [(unsigned)finalState]->sample(
264  ticksToCycles(curTick() - iter->second.time));
265  ++(*stats.inTransLatTotal[iter->second.transaction]);
266  m_inTrans.erase(iter);
267  }
268 
276  template<typename EventType>
278  {
279  assert(m_outTrans.find(addr) == m_outTrans.end());
280  m_outTrans[addr] = {type, 0, curTick()};
281  }
282 
289  void outgoingTransactionEnd(Addr addr, bool retried)
290  {
291  auto iter = m_outTrans.find(addr);
292  assert(iter != m_outTrans.end());
293  stats.outTransLatHist[iter->second.transaction]->sample(
294  ticksToCycles(curTick() - iter->second.time));
295  if (retried)
296  ++(*stats.outTransLatHistRetries[iter->second.transaction]);
297  m_outTrans.erase(iter);
298  }
299 
300  void stallBuffer(MessageBuffer* buf, Addr addr);
301  void wakeUpBuffer(MessageBuffer* buf, Addr addr);
302  void wakeUpBuffers(Addr addr);
303  void wakeUpAllBuffers(Addr addr);
304  void wakeUpAllBuffers();
305  bool serviceMemoryQueue();
306 
307  protected:
311 
312  // RequestorID used by some components of gem5.
314 
317  std::map<Addr, MessageBuffer*> m_block_map;
318 
320  typedef std::set<MessageBuffer*> MsgBufType;
321  typedef std::map<Addr, MsgVecType* > WaitingBufType;
323 
324  unsigned int m_in_ports;
325  unsigned int m_cur_in_port;
326  const int m_number_of_TBEs;
328  const unsigned int m_buffer_size;
331 
336  class MemoryPort : public RequestPort
337  {
338  private:
339  // Controller that operates this port.
341 
342  public:
343  MemoryPort(const std::string &_name, AbstractController *_controller,
344  PortID id = InvalidPortID);
345 
346  protected:
347  // Function for receiving a timing response from the peer port.
348  // Currently the pkt is handed to the coherence controller
349  // associated with this port.
350  bool recvTimingResp(PacketPtr pkt);
351 
352  void recvReqRetry();
353  };
354 
355  /* Request port to the memory controller. */
357 
358  // State that is stored in packets sent to the memory controller.
360  {
361  // Id of the machine from which the request originated.
363 
365  {}
366  };
367 
368  private:
371 
372  typedef std::unordered_map<MachineType, MachineID> AddrMapEntry;
373 
375 
377 
378  public:
380  {
382 
383  // Initialized by the SLICC compiler for all combinations of event and
384  // states. Only histograms with samples will appear in the stats
389 
390  // Initialized by the SLICC compiler for all events.
391  // Only histograms with samples will appear in the stats.
394 
398 
403  } stats;
404 
405 };
406 
407 } // namespace ruby
408 } // namespace gem5
409 
410 #endif // __MEM_RUBY_SLICC_INTERFACE_ABSTRACTCONTROLLER_HH__
gem5::statistics::Scalar
This is a simple scalar statistic, like a counter.
Definition: statistics.hh:1927
MachineID.hh
gem5::curTick
Tick curTick()
The universal simulation clock.
Definition: cur_tick.hh:46
fatal
#define fatal(...)
This implements a cprintf based fatal() function.
Definition: logging.hh:189
gem5::ruby::MachineID::getType
MachineType getType() const
Definition: MachineID.hh:66
gem5::PortID
int16_t PortID
Port index/ID type, and a symbolic name for an invalid port id.
Definition: types.hh:252
gem5::ruby::AbstractController::MsgBufType
std::set< MessageBuffer * > MsgBufType
Definition: AbstractController.hh:320
gem5::ruby::AbstractController::getVersion
NodeID getVersion() const
Definition: AbstractController.hh:89
gem5::ruby::Sequencer
Definition: Sequencer.hh:86
gem5::ruby::WriteMask
Definition: WriteMask.hh:59
gem5::ruby::AbstractController::ControllerStats::fullyBusyCycles
statistics::Scalar fullyBusyCycles
Counter for the number of cycles when the transitions carried out were equal to the maximum allowed.
Definition: AbstractController.hh:397
gem5::ruby::AbstractController::ControllerStats::outTransLatHist
std::vector< statistics::Histogram * > outTransLatHist
Definition: AbstractController.hh:392
gem5::ruby::AbstractController::m_number_of_TBEs
const int m_number_of_TBEs
Definition: AbstractController.hh:326
gem5::AddrRangeMap< AddrMapEntry, 3 >
gem5::ruby::AbstractController::getMemReqQueue
virtual MessageBuffer * getMemReqQueue() const =0
gem5::ruby::AbstractController::incomingTransactionStart
void incomingTransactionStart(Addr addr, EventType type, StateType initialState, bool retried)
Profiles an event that initiates a protocol transactions for a specific line (e.g.
Definition: AbstractController.hh:241
Histogram.hh
gem5::ruby::AbstractController::recordCacheTrace
virtual void recordCacheTrace(int cntrl, CacheRecorder *tr)=0
gem5::ruby::AbstractController::profileMsgDelay
void profileMsgDelay(uint32_t virtualNetwork, Cycles delay)
Profiles the delay associated with messages.
Definition: AbstractController.cc:130
gem5::MipsISA::index
Bitfield< 30, 0 > index
Definition: pra_constants.hh:47
gem5::ruby::AbstractController::getType
MachineType getType() const
Definition: AbstractController.hh:90
gem5::ruby::AbstractController::getMachineID
MachineID getMachineID() const
Definition: AbstractController.hh:174
gem5::ruby::AbstractController::profileRequest
void profileRequest(const std::string &request)
Profiles original cache requests including PUTs.
gem5::ruby::AbstractController::SenderState::SenderState
SenderState(MachineID _id)
Definition: AbstractController.hh:364
gem5::ruby::AbstractController::TransMapPair::state
unsigned state
Definition: AbstractController.hh:226
gem5::ruby::AbstractController::ControllerStats::inTransLatHist
std::vector< std::vector< std::vector< statistics::Histogram * > > > inTransLatHist
Definition: AbstractController.hh:386
gem5::ruby::AbstractController::getGPUCoalescer
virtual GPUCoalescer * getGPUCoalescer() const =0
gem5::ruby::AbstractController::serviceMemoryQueue
bool serviceMemoryQueue()
Definition: AbstractController.cc:254
gem5::ruby::Network
Definition: Network.hh:82
gem5::ruby::AbstractController::WaitingBufType
std::map< Addr, MsgVecType * > WaitingBufType
Definition: AbstractController.hh:321
gem5::ruby::AbstractController::getDelayHist
statistics::Histogram & getDelayHist()
Definition: AbstractController.hh:177
gem5::ruby::AbstractController::wakeUpBuffers
void wakeUpBuffers(Addr addr)
Definition: AbstractController.cc:174
gem5::ruby::AbstractController::resetStats
virtual void resetStats()=0
Callback to reset stats.
Definition: AbstractController.cc:114
gem5::ruby::AbstractController::MemoryPort
Port that forwards requests and receives responses from the memory controller.
Definition: AbstractController.hh:336
gem5::ruby::AbstractController::m_recycle_latency
Cycles m_recycle_latency
Definition: AbstractController.hh:329
gem5::ruby::AbstractController::mapAddressToDownstreamMachine
MachineID mapAddressToDownstreamMachine(Addr addr, MachineType mtype=MachineType_NUM) const
Maps an address to the correct dowstream MachineID (i.e.
Definition: AbstractController.cc:411
std::vector
STL vector class.
Definition: stl.hh:37
gem5::ruby::AbstractController::m_block_map
std::map< Addr, MessageBuffer * > m_block_map
Definition: AbstractController.hh:317
gem5::ruby::AbstractController::m_outTrans
std::unordered_map< Addr, TransMapPair > m_outTrans
Definition: AbstractController.hh:228
gem5::ruby::AbstractController::isBlocked
bool isBlocked(Addr) const
Definition: AbstractController.cc:319
gem5::ruby::AbstractController::m_clusterID
const NodeID m_clusterID
Definition: AbstractController.hh:310
gem5::ruby::AbstractController::PARAMS
PARAMS(RubyController)
gem5::ruby::Consumer
Definition: Consumer.hh:61
gem5::ruby::AbstractController::wakeup
virtual void wakeup()=0
gem5::ruby::AbstractController::getPort
Port & getPort(const std::string &if_name, PortID idx=InvalidPortID)
A function used to return the port associated with this bus object.
Definition: AbstractController.cc:340
gem5::InvalidPortID
const PortID InvalidPortID
Definition: types.hh:253
gem5::ruby::AbstractController::MsgVecType
std::vector< MessageBuffer * > MsgVecType
Definition: AbstractController.hh:319
gem5::ruby::AbstractController::m_inTrans
std::unordered_map< Addr, TransMapPair > m_inTrans
Definition: AbstractController.hh:227
gem5::ruby::AbstractController::m_is_blocking
bool m_is_blocking
Definition: AbstractController.hh:316
gem5::ruby::AbstractController
Definition: AbstractController.hh:82
gem5::ruby::AbstractController::enqueuePrefetch
virtual void enqueuePrefetch(const Addr &, const RubyRequestType &)
Function for enqueuing a prefetch request.
Definition: AbstractController.hh:143
gem5::ruby::AbstractController::initNetQueues
virtual void initNetQueues()=0
Initialize the message buffers.
gem5::ruby::AbstractController::functionalRead
virtual void functionalRead(const Addr &addr, PacketPtr pkt, WriteMask &mask)
Definition: AbstractController.hh:131
gem5::mask
constexpr uint64_t mask(unsigned nbits)
Generate a 64-bit mask of 'nbits' 1s, right justified.
Definition: bitfield.hh:63
packet.hh
gem5::ruby::AbstractController::ControllerStats::delayHistogram
statistics::Histogram delayHistogram
Histogram for profiling delay for the messages this controller cares for.
Definition: AbstractController.hh:401
gem5::RequestPort
A RequestPort is a specialisation of a Port, which implements the default protocol for the three diff...
Definition: port.hh:77
gem5::Cycles
Cycles is a wrapper class for representing cycle counts, i.e.
Definition: types.hh:78
gem5::ruby::AbstractController::m_transitions_per_cycle
const int m_transitions_per_cycle
Definition: AbstractController.hh:327
gem5::ruby::DMASequencer
Definition: DMASequencer.hh:62
gem5::ruby::AbstractController::getDelayVCHist
statistics::Histogram & getDelayVCHist(uint32_t index)
Definition: AbstractController.hh:178
gem5::ruby::AbstractController::outgoingTransactionStart
void outgoingTransactionStart(Addr addr, EventType type)
Profiles an event that initiates a transaction in a peer controller (e.g.
Definition: AbstractController.hh:277
gem5::ruby::AbstractController::addrRanges
const AddrRangeList addrRanges
The address range to which the controller responds on the CPU side.
Definition: AbstractController.hh:370
gem5::ruby::AbstractController::ControllerStats::delayVCHistogram
std::vector< statistics::Histogram * > delayVCHistogram
Definition: AbstractController.hh:402
gem5::statistics::Histogram
A simple histogram stat.
Definition: statistics.hh:2123
gem5::ruby::AbstractController::MemoryPort::recvReqRetry
void recvReqRetry()
Called by the peer if sendTimingReq was called on this peer (causing recvTimingReq to be called on th...
Definition: AbstractController.cc:442
gem5::ruby::AbstractController::getAddrRanges
const AddrRangeList & getAddrRanges() const
Definition: AbstractController.hh:171
gem5::ruby::AbstractController::collateStats
virtual void collateStats()
Function for collating statistics from all the controllers of this particular type.
Definition: AbstractController.hh:158
gem5::ruby::AbstractController::functionalMemoryWrite
int functionalMemoryWrite(PacketPtr)
Definition: AbstractController.cc:355
gem5::ruby::AbstractController::initNetworkPtr
void initNetworkPtr(Network *net_ptr)
Definition: AbstractController.hh:92
addr_range_map.hh
gem5::ruby::RejectException
Definition: AbstractController.hh:76
gem5::ruby::AbstractController::ControllerStats::inTransLatTotal
std::vector< statistics::Scalar * > inTransLatTotal
Definition: AbstractController.hh:388
gem5::Packet
A Packet is used to encapsulate a transfer between two objects in the memory system (e....
Definition: packet.hh:283
DataBlock.hh
gem5::MipsISA::p
Bitfield< 0 > p
Definition: pra_constants.hh:326
gem5::ruby::AbstractController::mapAddressToMachine
MachineID mapAddressToMachine(Addr addr, MachineType mtype) const
Map an address to the correct MachineID.
Definition: AbstractController.cc:403
gem5::ruby::AbstractController::ControllerStats::outTransLatHistRetries
std::vector< statistics::Scalar * > outTransLatHistRetries
Definition: AbstractController.hh:393
gem5::Tick
uint64_t Tick
Tick count type.
Definition: types.hh:58
gem5::X86ISA::type
type
Definition: misc.hh:733
gem5::RequestPtr
std::shared_ptr< Request > RequestPtr
Definition: request.hh:92
gem5::ruby::AbstractController::recvAtomic
Tick recvAtomic(PacketPtr pkt)
Definition: AbstractController.cc:397
gem5::ruby::AbstractController::m_buffer_size
const unsigned int m_buffer_size
Definition: AbstractController.hh:328
gem5::ruby::RejectException::what
virtual const char * what() const
Definition: AbstractController.hh:78
gem5::ruby::AbstractController::ControllerStats::ControllerStats
ControllerStats(statistics::Group *parent)
Definition: AbstractController.cc:455
gem5::ruby::AbstractController::m_cur_in_port
unsigned int m_cur_in_port
Definition: AbstractController.hh:325
gem5::ruby::AbstractController::downstreamDestinations
NetDest downstreamDestinations
Definition: AbstractController.hh:376
gem5::ruby::AbstractController::ControllerStats
Definition: AbstractController.hh:379
gem5::ruby::AbstractController::MemoryPort::MemoryPort
MemoryPort(const std::string &_name, AbstractController *_controller, PortID id=InvalidPortID)
Definition: AbstractController.cc:447
gem5::ruby::AbstractController::AbstractController
AbstractController(const Params &p)
Definition: AbstractController.cc:56
gem5::Packet::SenderState
A virtual base opaque structure used to hold state associated with the packet (e.g....
Definition: packet.hh:457
gem5::ruby::AbstractController::notifyCoalesced
virtual void notifyCoalesced(const Addr &addr, const RubyRequestType &type, const RequestPtr &req, const DataBlock &data_blk, const bool &was_miss)
Notifies controller of a request coalesced at the sequencer.
Definition: AbstractController.hh:148
gem5::ruby::MachineID::getNum
NodeID getNum() const
Definition: MachineID.hh:67
gem5::Addr
uint64_t Addr
Address type This will probably be moved somewhere else in the near future.
Definition: types.hh:147
gem5::ruby::AbstractController::SenderState::id
MachineID id
Definition: AbstractController.hh:362
gem5::ruby::AbstractController::SenderState
Definition: AbstractController.hh:359
gem5::ruby::AbstractController::m_waiting_buffers
WaitingBufType m_waiting_buffers
Definition: AbstractController.hh:322
gem5::ruby::AbstractController::m_machineID
MachineID m_machineID
Definition: AbstractController.hh:309
gem5::ruby::AbstractController::m_version
const NodeID m_version
Definition: AbstractController.hh:308
gem5::ClockedObject
The ClockedObject class extends the SimObject with a clock and accessor functions to relate ticks to ...
Definition: clocked_object.hh:234
gem5::ruby::AbstractController::init
void init()
init() is called after all C++ SimObjects have been created and all ports are connected.
Definition: AbstractController.cc:76
addr_range.hh
gem5::ruby::NetDest
Definition: NetDest.hh:45
gem5::ruby::AbstractController::unblock
void unblock(Addr)
Definition: AbstractController.cc:325
gem5::ruby::AbstractController::stats
gem5::ruby::AbstractController::ControllerStats stats
gem5::ruby::AbstractController::mandatoryQueueLatency
virtual Cycles mandatoryQueueLatency(const RubyRequestType &param_type)
Definition: AbstractController.hh:119
gem5::ruby::AbstractController::TransMapPair
Definition: AbstractController.hh:226
MessageBuffer.hh
gem5::ruby::AbstractController::getRequestorId
RequestorID getRequestorId() const
Definition: AbstractController.hh:175
gem5::ruby::AbstractController::wakeUpAllBuffers
void wakeUpAllBuffers()
Definition: AbstractController.cc:215
gem5::ruby::AbstractController::functionalReadBuffers
virtual bool functionalReadBuffers(PacketPtr &)=0
These functions are used by ruby system to read/write the data blocks that exist with in the controll...
gem5::ruby::AbstractController::functionalWriteBuffers
virtual int functionalWriteBuffers(PacketPtr &)=0
The return value indicates the number of messages written with the data from the packet.
gem5::ruby::AbstractController::TransMapPair::transaction
unsigned transaction
Definition: AbstractController.hh:226
gem5::Port
Ports are used to interface objects to each other.
Definition: port.hh:61
gem5::ruby::AbstractController::m_in_ports
unsigned int m_in_ports
Definition: AbstractController.hh:324
gem5::ruby::AbstractController::MemoryPort::recvTimingResp
bool recvTimingResp(PacketPtr pkt)
Receive a timing response from the peer.
Definition: AbstractController.cc:435
Consumer.hh
Address.hh
gem5::ruby::AbstractController::m_net_ptr
Network * m_net_ptr
Definition: AbstractController.hh:315
gem5::ruby::AbstractController::functionalMemoryRead
void functionalMemoryRead(PacketPtr)
Definition: AbstractController.cc:346
qport.hh
gem5::ruby::AbstractController::getDMASequencer
virtual DMASequencer * getDMASequencer() const =0
clocked_object.hh
gem5::ruby::AbstractController::ControllerStats::inTransLatRetries
std::vector< statistics::Scalar * > inTransLatRetries
Definition: AbstractController.hh:387
gem5::ruby::AbstractController::m_mandatory_queue_latency
const Cycles m_mandatory_queue_latency
Definition: AbstractController.hh:330
gem5::statistics::Group
Statistics container.
Definition: group.hh:93
gem5::ruby::AbstractController::outgoingTransactionEnd
void outgoingTransactionEnd(Addr addr, bool retried)
Profiles the end of an outgoing transaction.
Definition: AbstractController.hh:289
gem5::ruby::AbstractController::m_id
const RequestorID m_id
Definition: AbstractController.hh:313
gem5::ruby::NodeID
unsigned int NodeID
Definition: TypeDefines.hh:40
gem5::ruby::AbstractController::AddrMapEntry
std::unordered_map< MachineType, MachineID > AddrMapEntry
Definition: AbstractController.hh:372
gem5::ruby::AbstractController::print
virtual void print(std::ostream &out) const =0
gem5::ruby::AbstractController::regStats
virtual void regStats()
Callback to set stat parameters.
Definition: AbstractController.cc:124
gem5::ruby::AbstractController::MemoryPort::controller
AbstractController * controller
Definition: AbstractController.hh:340
gem5::RequestorID
uint16_t RequestorID
Definition: request.hh:95
gem5::ClockedObject::Params
ClockedObjectParams Params
Parameters of ClockedObject.
Definition: clocked_object.hh:240
gem5::ruby::AbstractController::functionalWrite
virtual int functionalWrite(const Addr &addr, PacketPtr)=0
gem5::ruby::AbstractController::downstreamAddrMap
AddrRangeMap< AddrMapEntry, 3 > downstreamAddrMap
Definition: AbstractController.hh:374
gem5::Clocked::ticksToCycles
Cycles ticksToCycles(Tick t) const
Definition: clocked_object.hh:222
gem5::ruby::AbstractController::getAccessPermission
virtual AccessPermission getAccessPermission(const Addr &addr)=0
gem5::ruby::AbstractController::memoryPort
MemoryPort memoryPort
Definition: AbstractController.hh:356
gem5::ruby::AbstractController::getMandatoryQueue
virtual MessageBuffer * getMandatoryQueue() const =0
gem5::ruby::DataBlock
Definition: DataBlock.hh:60
gem5::ruby::MessageBuffer
Definition: MessageBuffer.hh:74
std::list< AddrRange >
CacheRecorder.hh
gem5
Reference material can be found at the JEDEC website: UFS standard http://www.jedec....
Definition: decoder.cc:40
gem5::ruby::AbstractController::getMemRespQueue
virtual MessageBuffer * getMemRespQueue() const =0
gem5::ruby::AbstractController::TransMapPair::time
Tick time
Definition: AbstractController.hh:226
gem5::ruby::MachineID
Definition: MachineID.hh:56
gem5::ruby::AbstractController::blockOnQueue
void blockOnQueue(Addr, MessageBuffer *)
Definition: AbstractController.cc:312
gem5::ruby::AbstractController::recvTimingResp
void recvTimingResp(PacketPtr pkt)
Definition: AbstractController.cc:365
gem5::ruby::CacheRecorder
Definition: CacheRecorder.hh:73
gem5::ruby::AbstractController::functionalRead
virtual void functionalRead(const Addr &addr, PacketPtr)
Definition: AbstractController.hh:125
callback.hh
gem5::ruby::GPUCoalescer
Definition: GPUCoalescer.hh:215
gem5::Named::_name
const std::string _name
Definition: named.hh:41
gem5::ruby::AbstractController::respondsTo
bool respondsTo(Addr addr)
Definition: AbstractController.hh:181
gem5::ruby::AbstractController::incomingTransactionEnd
void incomingTransactionEnd(Addr addr, StateType finalState)
Profiles an event that ends a transaction.
Definition: AbstractController.hh:257
gem5::ruby::AbstractController::wakeUpBuffer
void wakeUpBuffer(MessageBuffer *buf, Addr addr)
Definition: AbstractController.cc:152
gem5::ruby::AbstractController::allDownstreamDest
const NetDest & allDownstreamDest() const
Definition: AbstractController.hh:217
panic
#define panic(...)
This implements a cprintf based panic() function.
Definition: logging.hh:177
gem5::X86ISA::addr
Bitfield< 3 > addr
Definition: types.hh:84
gem5::ruby::AbstractController::stallBuffer
void stallBuffer(MessageBuffer *buf, Addr addr)
Definition: AbstractController.cc:138
gem5::ruby::AbstractController::getCPUSequencer
virtual Sequencer * getCPUSequencer() const =0

Generated on Tue Sep 21 2021 12:25:41 for gem5 by doxygen 1.8.17