2 * Copyright (c) 2012-2019 ARM Limited
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.
14 * Copyright (c) 2006 The Regents of The University of Michigan
15 * Copyright (c) 2010,2015 Advanced Micro Devices, Inc.
16 * All rights reserved.
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions are
20 * met: redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer;
22 * redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution;
25 * neither the name of the copyright holders nor the names of its
26 * contributors may be used to endorse or promote products derived from
27 * this software without specific prior written permission.
29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
30 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
31 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
32 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
33 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
34 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
35 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
36 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
38 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
44 * Declaration of the Packet class.
47 #ifndef __MEM_PACKET_HH__
48 #define __MEM_PACKET_HH__
54 #include "base/addr_range.hh"
55 #include "base/cast.hh"
56 #include "base/compiler.hh"
57 #include "base/flags.hh"
58 #include "base/logging.hh"
59 #include "base/printable.hh"
60 #include "base/types.hh"
61 #include "mem/request.hh"
62 #include "sim/core.hh"
65 typedef Packet *PacketPtr;
66 typedef uint8_t* PacketDataPtr;
67 typedef std::list<PacketPtr> PacketList;
68 typedef uint64_t PacketId;
76 * List of all commands associated with a packet.
83 ReadRespWithInvalidate,
88 WriteClean, // writes dirty data below without evicting
97 SCUpgradeReq, // Special "weak" upgrade for StoreCond
99 SCUpgradeFailReq, // Failed SCUpgradeReq in MSHR (never sent)
100 UpgradeFailResp, // Valid for SCUpgradeReq only
107 StoreCondFailReq, // Failed StoreCondReq in MSHR (never sent)
111 // MessageReq and MessageResp are deprecated.
112 MemFenceReq = SwapResp + 3,
119 // @TODO these should be classified as responses rather than
120 // requests; coding them as requests initially for backwards
122 InvalidDestError, // packet dest field invalid
123 BadAddressError, // memory address invalid
124 FunctionalReadError, // unable to fulfill functional read
125 FunctionalWriteError, // unable to fulfill functional write
126 // Fake simulator-only commands
127 PrintReq, // Print state matching address
128 FlushReq, //request for a cache flush
129 InvalidateReq, // request for address to be invalidated
136 * List of command attributes.
140 IsRead, //!< Data flows from responder to requester
141 IsWrite, //!< Data flows from requester to responder
144 IsClean, //!< Cleans any existing dirty blocks
145 NeedsWritable, //!< Requires writable copy to complete in-cache
146 IsRequest, //!< Issued by requester
147 IsResponse, //!< Issue by responder
148 NeedsResponse, //!< Requester needs response from target
152 IsLlsc, //!< Alpha/MIPS LL or SC access
153 HasData, //!< There is an associated payload
154 IsError, //!< Error response
155 IsPrint, //!< Print state matching address (for debugging)
156 IsFlush, //!< Flush the address from caches
157 FromCache, //!< Request originated from a caching agent
158 NUM_COMMAND_ATTRIBUTES
162 * Structure that defines attributes and other data associated
167 /// Set of attribute flags.
168 const std::bitset<NUM_COMMAND_ATTRIBUTES> attributes;
169 /// Corresponding response for requests; InvalidCmd if no
170 /// response is applicable.
171 const Command response;
172 /// String representation (for printing)
173 const std::string str;
176 /// Array to map Command enum to associated info.
177 static const CommandInfo commandInfo[];
184 testCmdAttrib(MemCmd::Attribute attrib) const
186 return commandInfo[cmd].attributes[attrib] != 0;
191 bool isRead() const { return testCmdAttrib(IsRead); }
192 bool isWrite() const { return testCmdAttrib(IsWrite); }
193 bool isUpgrade() const { return testCmdAttrib(IsUpgrade); }
194 bool isRequest() const { return testCmdAttrib(IsRequest); }
195 bool isResponse() const { return testCmdAttrib(IsResponse); }
196 bool needsWritable() const { return testCmdAttrib(NeedsWritable); }
197 bool needsResponse() const { return testCmdAttrib(NeedsResponse); }
198 bool isInvalidate() const { return testCmdAttrib(IsInvalidate); }
199 bool isEviction() const { return testCmdAttrib(IsEviction); }
200 bool isClean() const { return testCmdAttrib(IsClean); }
201 bool fromCache() const { return testCmdAttrib(FromCache); }
204 * A writeback is an eviction that carries data.
206 bool isWriteback() const { return testCmdAttrib(IsEviction) &&
207 testCmdAttrib(HasData); }
210 * Check if this particular packet type carries payload data. Note
211 * that this does not reflect if the data pointer of the packet is
214 bool hasData() const { return testCmdAttrib(HasData); }
215 bool isLLSC() const { return testCmdAttrib(IsLlsc); }
216 bool isSWPrefetch() const { return testCmdAttrib(IsSWPrefetch); }
217 bool isHWPrefetch() const { return testCmdAttrib(IsHWPrefetch); }
218 bool isPrefetch() const { return testCmdAttrib(IsSWPrefetch) ||
219 testCmdAttrib(IsHWPrefetch); }
220 bool isError() const { return testCmdAttrib(IsError); }
221 bool isPrint() const { return testCmdAttrib(IsPrint); }
222 bool isFlush() const { return testCmdAttrib(IsFlush); }
225 responseCommand() const
227 return commandInfo[cmd].response;
230 /// Return the string to a cmd given by idx.
231 const std::string &toString() const { return commandInfo[cmd].str; }
232 int toInt() const { return (int)cmd; }
234 MemCmd(Command _cmd) : cmd(_cmd) { }
235 MemCmd(int _cmd) : cmd((Command)_cmd) { }
236 MemCmd() : cmd(InvalidCmd) { }
238 bool operator==(MemCmd c2) const { return (cmd == c2.cmd); }
239 bool operator!=(MemCmd c2) const { return (cmd != c2.cmd); }
243 * A Packet is used to encapsulate a transfer between two objects in
244 * the memory system (e.g., the L1 and L2 cache). (In contrast, a
245 * single Request travels all the way from the requester to the
246 * ultimate destination and back, possibly being conveyed by several
247 * different Packets along the way.)
249 class Packet : public Printable
252 typedef uint32_t FlagsType;
253 typedef ::Flags<FlagsType> Flags;
258 // Flags to transfer across when copying a packet
259 COPY_FLAGS = 0x0000003F,
261 // Flags that are used to create reponse packets
262 RESPONDER_FLAGS = 0x00000009,
264 // Does this packet have sharers (which means it should not be
265 // considered writable) or not. See setHasSharers below.
266 HAS_SHARERS = 0x00000001,
268 // Special control flags
269 /// Special timing-mode atomic snoop for multi-level coherence.
270 EXPRESS_SNOOP = 0x00000002,
272 /// Allow a responding cache to inform the cache hierarchy
273 /// that it had a writable copy before responding. See
274 /// setResponderHadWritable below.
275 RESPONDER_HAD_WRITABLE = 0x00000004,
277 // Snoop co-ordination flag to indicate that a cache is
278 // responding to a snoop. See setCacheResponding below.
279 CACHE_RESPONDING = 0x00000008,
281 // The writeback/writeclean should be propagated further
282 // downstream by the receiver
283 WRITE_THROUGH = 0x00000010,
285 // Response co-ordination flag for cache maintenance
287 SATISFIED = 0x00000020,
289 /// Are the 'addr' and 'size' fields valid?
290 VALID_ADDR = 0x00000100,
291 VALID_SIZE = 0x00000200,
293 /// Is the data pointer set to a value that shouldn't be freed
294 /// when the packet is destroyed?
295 STATIC_DATA = 0x00001000,
296 /// The data pointer points to a value that should be freed when
297 /// the packet is destroyed. The pointer is assumed to be pointing
298 /// to an array, and delete [] is consequently called
299 DYNAMIC_DATA = 0x00002000,
301 /// suppress the error if this packet encounters a functional
303 SUPPRESS_FUNC_ERROR = 0x00008000,
305 // Signal block present to squash prefetch and cache evict packets
306 // through express snoop flag
307 BLOCK_CACHED = 0x00010000
313 typedef MemCmd::Command Command;
315 /// The command field of the packet.
320 /// A pointer to the original request.
325 * A pointer to the data being transferred. It can be different
326 * sizes at each level of the hierarchy so it belongs to the
327 * packet, not request. This may or may not be populated when a
328 * responder receives the packet. If not populated memory should
333 /// The address of the request. This address could be virtual or
334 /// physical, depending on the system configuration.
337 /// True if the request targets the secure memory space.
340 /// The size of the request or transfer.
344 * Track the bytes found that satisfy a functional read.
346 std::vector<bool> bytesValid;
348 // Quality of Service priority value
354 * The extra delay from seeing the packet until the header is
355 * transmitted. This delay is used to communicate the crossbar
356 * forwarding latency to the neighbouring object (e.g. a cache)
357 * that actually makes the packet wait. As the delay is relative,
358 * a 32-bit unsigned should be sufficient.
360 uint32_t headerDelay;
363 * Keep track of the extra delay incurred by snooping upwards
364 * before sending a request down the memory system. This is used
365 * by the coherent crossbar to account for the additional request
371 * The extra pipelining delay from seeing the packet until the end of
372 * payload is transmitted by the component that provided it (if
373 * any). This includes the header delay. Similar to the header
374 * delay, this is used to make up for the fact that the
375 * crossbar does not make the packet wait. As the delay is
376 * relative, a 32-bit unsigned should be sufficient.
378 uint32_t payloadDelay;
381 * A virtual base opaque structure used to hold state associated
382 * with the packet (e.g., an MSHR), specific to a SimObject that
383 * sees the packet. A pointer to this state is returned in the
384 * packet's response so that the SimObject in question can quickly
385 * look up the state needed to process it. A specific subclass
386 * would be derived from this to carry state specific to a
387 * particular sending device.
389 * As multiple SimObjects may add their SenderState throughout the
390 * memory system, the SenderStates create a stack, where a
391 * SimObject can add a new Senderstate, as long as the
392 * predecessing SenderState is restored when the response comes
393 * back. For this reason, the predecessor should always be
394 * populated with the current SenderState of a packet before
395 * modifying the senderState field in the request packet.
399 SenderState* predecessor;
400 SenderState() : predecessor(NULL) {}
401 virtual ~SenderState() {}
405 * Object used to maintain state of a PrintReq. The senderState
406 * field of a PrintReq should always be of this type.
408 class PrintReqState : public SenderState
412 * An entry in the label stack.
414 struct LabelStackEntry
416 const std::string label;
419 LabelStackEntry(const std::string &_label, std::string *_prefix);
422 typedef std::list<LabelStackEntry> LabelStack;
423 LabelStack labelStack;
425 std::string *curPrefixPtr;
431 PrintReqState(std::ostream &os, int verbosity = 0);
435 * Returns the current line prefix.
437 const std::string &curPrefix() { return *curPrefixPtr; }
440 * Push a label onto the label stack, and prepend the given
441 * prefix string onto the current prefix. Labels will only be
442 * printed if an object within the label's scope is printed.
444 void pushLabel(const std::string &lbl,
445 const std::string &prefix = " ");
448 * Pop a label off the label stack.
453 * Print all of the pending unprinted labels on the
454 * stack. Called by printObj(), so normally not called by
455 * users unless bypassing printObj().
460 * Print a Printable object to os, because it matched the
461 * address on a PrintReq.
463 void printObj(Printable *obj);
467 * This packet's sender state. Devices should use dynamic_cast<>
468 * to cast to the state appropriate to the sender. The intent of
469 * this variable is to allow a device to attach extra information
470 * to a request. A response packet must return the sender state
471 * that was attached to the original request (even if a new packet
474 SenderState *senderState;
477 * Push a new sender state to the packet and make the current
478 * sender state the predecessor of the new one. This should be
479 * prefered over direct manipulation of the senderState member
482 * @param sender_state SenderState to push at the top of the stack
484 void pushSenderState(SenderState *sender_state);
487 * Pop the top of the state stack and return a pointer to it. This
488 * assumes the current sender state is not NULL. This should be
489 * preferred over direct manipulation of the senderState member
492 * @return The current top of the stack
494 SenderState *popSenderState();
497 * Go through the sender state stack and return the first instance
498 * that is of type T (as determined by a dynamic_cast). If there
499 * is no sender state of type T, NULL is returned.
501 * @return The topmost state of type T
503 template <typename T>
504 T * findNextSenderState() const
507 SenderState* sender_state = senderState;
508 while (t == NULL && sender_state != NULL) {
509 t = dynamic_cast<T*>(sender_state);
510 sender_state = sender_state->predecessor;
515 /// Return the string name of the cmd field (for debugging and
517 const std::string &cmdString() const { return cmd.toString(); }
519 /// Return the index of this command.
520 inline int cmdToIndex() const { return cmd.toInt(); }
522 bool isRead() const { return cmd.isRead(); }
523 bool isWrite() const { return cmd.isWrite(); }
524 bool isUpgrade() const { return cmd.isUpgrade(); }
525 bool isRequest() const { return cmd.isRequest(); }
526 bool isResponse() const { return cmd.isResponse(); }
527 bool needsWritable() const
529 // we should never check if a response needsWritable, the
530 // request has this flag, and for a response we should rather
531 // look at the hasSharers flag (if not set, the response is to
532 // be considered writable)
534 return cmd.needsWritable();
536 bool needsResponse() const { return cmd.needsResponse(); }
537 bool isInvalidate() const { return cmd.isInvalidate(); }
538 bool isEviction() const { return cmd.isEviction(); }
539 bool isClean() const { return cmd.isClean(); }
540 bool fromCache() const { return cmd.fromCache(); }
541 bool isWriteback() const { return cmd.isWriteback(); }
542 bool hasData() const { return cmd.hasData(); }
543 bool hasRespData() const
545 MemCmd resp_cmd = cmd.responseCommand();
546 return resp_cmd.hasData();
548 bool isLLSC() const { return cmd.isLLSC(); }
549 bool isError() const { return cmd.isError(); }
550 bool isPrint() const { return cmd.isPrint(); }
551 bool isFlush() const { return cmd.isFlush(); }
553 bool isWholeLineWrite(unsigned blk_size)
555 return (cmd == MemCmd::WriteReq || cmd == MemCmd::WriteLineReq) &&
556 getOffset(blk_size) == 0 && getSize() == blk_size;
562 * Set the cacheResponding flag. This is used by the caches to
563 * signal another cache that they are responding to a request. A
564 * cache will only respond to snoops if it has the line in either
565 * Modified or Owned state. Note that on snoop hits we always pass
566 * the line as Modified and never Owned. In the case of an Owned
567 * line we proceed to invalidate all other copies.
569 * On a cache fill (see Cache::handleFill), we check hasSharers
570 * first, ignoring the cacheResponding flag if hasSharers is set.
571 * A line is consequently allocated as:
573 * hasSharers cacheResponding state
576 * false false Exclusive
577 * false true Modified
579 void setCacheResponding()
582 assert(!flags.isSet(CACHE_RESPONDING));
583 flags.set(CACHE_RESPONDING);
585 bool cacheResponding() const { return flags.isSet(CACHE_RESPONDING); }
587 * On fills, the hasSharers flag is used by the caches in
588 * combination with the cacheResponding flag, as clarified
589 * above. If the hasSharers flag is not set, the packet is passing
590 * writable. Thus, a response from a memory passes the line as
591 * writable by default.
593 * The hasSharers flag is also used by upstream caches to inform a
594 * downstream cache that they have the block (by calling
595 * setHasSharers on snoop request packets that hit in upstream
596 * cachs tags or MSHRs). If the snoop packet has sharers, a
597 * downstream cache is prevented from passing a dirty line upwards
598 * if it was not explicitly asked for a writable copy. See
599 * Cache::satisfyCpuSideRequest.
601 * The hasSharers flag is also used on writebacks, in
602 * combination with the WritbackClean or WritebackDirty commands,
603 * to allocate the block downstream either as:
605 * command hasSharers state
606 * WritebackDirty false Modified
607 * WritebackDirty true Owned
608 * WritebackClean false Exclusive
609 * WritebackClean true Shared
611 void setHasSharers() { flags.set(HAS_SHARERS); }
612 bool hasSharers() const { return flags.isSet(HAS_SHARERS); }
616 * The express snoop flag is used for two purposes. Firstly, it is
617 * used to bypass flow control for normal (non-snoop) requests
618 * going downstream in the memory system. In cases where a cache
619 * is responding to a snoop from another cache (it had a dirty
620 * line), but the line is not writable (and there are possibly
621 * other copies), the express snoop flag is set by the downstream
622 * cache to invalidate all other copies in zero time. Secondly,
623 * the express snoop flag is also set to be able to distinguish
624 * snoop packets that came from a downstream cache, rather than
625 * snoop packets from neighbouring caches.
627 void setExpressSnoop() { flags.set(EXPRESS_SNOOP); }
628 bool isExpressSnoop() const { return flags.isSet(EXPRESS_SNOOP); }
631 * On responding to a snoop request (which only happens for
632 * Modified or Owned lines), make sure that we can transform an
633 * Owned response to a Modified one. If this flag is not set, the
634 * responding cache had the line in the Owned state, and there are
635 * possibly other Shared copies in the memory system. A downstream
636 * cache helps in orchestrating the invalidation of these copies
637 * by sending out the appropriate express snoops.
639 void setResponderHadWritable()
641 assert(cacheResponding());
642 assert(!responderHadWritable());
643 flags.set(RESPONDER_HAD_WRITABLE);
645 bool responderHadWritable() const
646 { return flags.isSet(RESPONDER_HAD_WRITABLE); }
649 * Copy the reponse flags from an input packet to this packet. The
650 * reponse flags determine whether a responder has been found and
651 * the state at which the block will be at the destination.
653 * @pkt The packet that we will copy flags from
655 void copyResponderFlags(const PacketPtr pkt);
658 * A writeback/writeclean cmd gets propagated further downstream
659 * by the receiver when the flag is set.
661 void setWriteThrough()
663 assert(cmd.isWrite() &&
664 (cmd.isEviction() || cmd == MemCmd::WriteClean));
665 flags.set(WRITE_THROUGH);
667 void clearWriteThrough() { flags.clear(WRITE_THROUGH); }
668 bool writeThrough() const { return flags.isSet(WRITE_THROUGH); }
671 * Set when a request hits in a cache and the cache is not going
672 * to respond. This is used by the crossbar to coordinate
673 * responses for cache maintenance operations.
677 assert(cmd.isClean());
678 assert(!flags.isSet(SATISFIED));
679 flags.set(SATISFIED);
681 bool satisfied() const { return flags.isSet(SATISFIED); }
683 void setSuppressFuncError() { flags.set(SUPPRESS_FUNC_ERROR); }
684 bool suppressFuncError() const { return flags.isSet(SUPPRESS_FUNC_ERROR); }
685 void setBlockCached() { flags.set(BLOCK_CACHED); }
686 bool isBlockCached() const { return flags.isSet(BLOCK_CACHED); }
687 void clearBlockCached() { flags.clear(BLOCK_CACHED); }
691 * Returns 0 if QoS value was never set (constructor default).
693 * @return QoS priority value of the packet
695 inline uint8_t qosValue() const { return _qosValue; }
699 * Interface for setting QoS priority value of the packet.
701 * @param qos_value QoS priority value
703 inline void qosValue(const uint8_t qos_value)
704 { _qosValue = qos_value; }
706 inline MasterID masterId() const { return req->masterId(); }
708 // Network error conditions... encapsulate them as methods since
709 // their encoding keeps changing (from result field to command
714 assert(isResponse());
715 cmd = MemCmd::BadAddressError;
718 void copyError(Packet *pkt) { assert(pkt->isError()); cmd = pkt->cmd; }
720 Addr getAddr() const { assert(flags.isSet(VALID_ADDR)); return addr; }
722 * Update the address of this packet mid-transaction. This is used
723 * by the address mapper to change an already set address to a new
724 * one based on the system configuration. It is intended to remap
725 * an existing address, so it asserts that the current address is
728 void setAddr(Addr _addr) { assert(flags.isSet(VALID_ADDR)); addr = _addr; }
730 unsigned getSize() const { assert(flags.isSet(VALID_SIZE)); return size; }
733 * Get address range to which this packet belongs.
735 * @return Address range of this packet.
737 AddrRange getAddrRange() const;
739 Addr getOffset(unsigned int blk_size) const
741 return getAddr() & Addr(blk_size - 1);
744 Addr getBlockAddr(unsigned int blk_size) const
746 return getAddr() & ~(Addr(blk_size - 1));
749 bool isSecure() const
751 assert(flags.isSet(VALID_ADDR));
756 * Accessor function to atomic op.
758 AtomicOpFunctor *getAtomicOp() const { return req->getAtomicOpFunctor(); }
759 bool isAtomicOp() const { return req->isAtomic(); }
762 * It has been determined that the SC packet should successfully update
763 * memory. Therefore, convert this SC packet to a normal write.
770 cmd = MemCmd::WriteReq;
774 * When ruby is in use, Ruby will monitor the cache line and the
775 * phys memory should treat LL ops as normal reads.
782 cmd = MemCmd::ReadReq;
786 * Constructor. Note that a Request object must be constructed
787 * first, but the Requests's physical address and size fields need
788 * not be valid. The command must be supplied.
790 Packet(const RequestPtr &_req, MemCmd _cmd)
791 : cmd(_cmd), id((PacketId)_req.get()), req(_req),
792 data(nullptr), addr(0), _isSecure(false), size(0),
793 _qosValue(0), headerDelay(0), snoopDelay(0),
794 payloadDelay(0), senderState(NULL)
796 if (req->hasPaddr()) {
797 addr = req->getPaddr();
798 flags.set(VALID_ADDR);
799 _isSecure = req->isSecure();
801 if (req->hasSize()) {
802 size = req->getSize();
803 flags.set(VALID_SIZE);
808 * Alternate constructor if you are trying to create a packet with
809 * a request that is for a whole block, not the address from the
810 * req. this allows for overriding the size/addr of the req.
812 Packet(const RequestPtr &_req, MemCmd _cmd, int _blkSize, PacketId _id = 0)
813 : cmd(_cmd), id(_id ? _id : (PacketId)_req.get()), req(_req),
814 data(nullptr), addr(0), _isSecure(false),
815 _qosValue(0), headerDelay(0),
816 snoopDelay(0), payloadDelay(0), senderState(NULL)
818 if (req->hasPaddr()) {
819 addr = req->getPaddr() & ~(_blkSize - 1);
820 flags.set(VALID_ADDR);
821 _isSecure = req->isSecure();
824 flags.set(VALID_SIZE);
828 * Alternate constructor for copying a packet. Copy all fields
829 * *except* if the original packet's data was dynamic, don't copy
830 * that, as we can't guarantee that the new packet's lifetime is
831 * less than that of the original packet. In this case the new
832 * packet should allocate its own data.
834 Packet(const PacketPtr pkt, bool clear_flags, bool alloc_data)
835 : cmd(pkt->cmd), id(pkt->id), req(pkt->req),
837 addr(pkt->addr), _isSecure(pkt->_isSecure), size(pkt->size),
838 bytesValid(pkt->bytesValid),
839 _qosValue(pkt->qosValue()),
840 headerDelay(pkt->headerDelay),
842 payloadDelay(pkt->payloadDelay),
843 senderState(pkt->senderState)
846 flags.set(pkt->flags & COPY_FLAGS);
848 flags.set(pkt->flags & (VALID_ADDR|VALID_SIZE));
850 // should we allocate space for data, or not, the express
851 // snoops do not need to carry any data as they only serve to
852 // co-ordinate state changes
854 // even if asked to allocate data, if the original packet
855 // holds static data, then the sender will not be doing
856 // any memcpy on receiving the response, thus we simply
857 // carry the pointer forward
858 if (pkt->flags.isSet(STATIC_DATA)) {
860 flags.set(STATIC_DATA);
868 * Generate the appropriate read MemCmd based on the Request flags.
871 makeReadCmd(const RequestPtr &req)
874 return MemCmd::LoadLockedReq;
875 else if (req->isPrefetchEx())
876 return MemCmd::SoftPFExReq;
877 else if (req->isPrefetch())
878 return MemCmd::SoftPFReq;
880 return MemCmd::ReadReq;
884 * Generate the appropriate write MemCmd based on the Request flags.
887 makeWriteCmd(const RequestPtr &req)
890 return MemCmd::StoreCondReq;
891 else if (req->isSwap() || req->isAtomic())
892 return MemCmd::SwapReq;
893 else if (req->isCacheInvalidate()) {
894 return req->isCacheClean() ? MemCmd::CleanInvalidReq :
895 MemCmd::InvalidateReq;
896 } else if (req->isCacheClean()) {
897 return MemCmd::CleanSharedReq;
899 return MemCmd::WriteReq;
903 * Constructor-like methods that return Packets based on Request objects.
904 * Fine-tune the MemCmd type if it's not a vanilla read or write.
907 createRead(const RequestPtr &req)
909 return new Packet(req, makeReadCmd(req));
913 createWrite(const RequestPtr &req)
915 return new Packet(req, makeWriteCmd(req));
919 * clean up packet variables
927 * Take a request packet and modify it in place to be suitable for
928 * returning as a response to that request.
933 assert(needsResponse());
935 cmd = cmd.responseCommand();
937 // responses are never express, even if the snoop that
938 // triggered them was
939 flags.clear(EXPRESS_SNOOP);
955 setFunctionalResponseStatus(bool success)
959 cmd = MemCmd::FunctionalWriteError;
961 cmd = MemCmd::FunctionalReadError;
967 setSize(unsigned size)
969 assert(!flags.isSet(VALID_SIZE));
972 flags.set(VALID_SIZE);
976 * Check if packet corresponds to a given block-aligned address and
979 * @param addr The address to compare against.
980 * @param is_secure Whether addr belongs to the secure address space.
981 * @param blk_size Block size in bytes.
982 * @return Whether packet matches description.
984 bool matchBlockAddr(const Addr addr, const bool is_secure,
985 const int blk_size) const;
988 * Check if this packet refers to the same block-aligned address and
989 * address space as another packet.
991 * @param pkt The packet to compare against.
992 * @param blk_size Block size in bytes.
993 * @return Whether packet matches description.
995 bool matchBlockAddr(const PacketPtr pkt, const int blk_size) const;
998 * Check if packet corresponds to a given address and address space.
1000 * @param addr The address to compare against.
1001 * @param is_secure Whether addr belongs to the secure address space.
1002 * @return Whether packet matches description.
1004 bool matchAddr(const Addr addr, const bool is_secure) const;
1007 * Check if this packet refers to the same address and address space as
1010 * @param pkt The packet to compare against.
1011 * @return Whether packet matches description.
1013 bool matchAddr(const PacketPtr pkt) const;
1018 * @name Data accessor mehtods
1022 * Set the data pointer to the following value that should not be
1023 * freed. Static data allows us to do a single memcpy even if
1024 * multiple packets are required to get from source to destination
1025 * and back. In essence the pointer is set calling dataStatic on
1026 * the original packet, and whenever this packet is copied and
1027 * forwarded the same pointer is passed on. When a packet
1028 * eventually reaches the destination holding the data, it is
1029 * copied once into the location originally set. On the way back
1030 * to the source, no copies are necessary.
1032 template <typename T>
1036 assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
1037 data = (PacketDataPtr)p;
1038 flags.set(STATIC_DATA);
1042 * Set the data pointer to the following value that should not be
1043 * freed. This version of the function allows the pointer passed
1044 * to us to be const. To avoid issues down the line we cast the
1045 * constness away, the alternative would be to keep both a const
1046 * and non-const data pointer and cleverly choose between
1047 * them. Note that this is only allowed for static data.
1049 template <typename T>
1051 dataStaticConst(const T *p)
1053 assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
1054 data = const_cast<PacketDataPtr>(p);
1055 flags.set(STATIC_DATA);
1059 * Set the data pointer to a value that should have delete []
1060 * called on it. Dynamic data is local to this packet, and as the
1061 * packet travels from source to destination, forwarded packets
1062 * will allocate their own data. When a packet reaches the final
1063 * destination it will populate the dynamic data of that specific
1064 * packet, and on the way back towards the source, memcpy will be
1065 * invoked in every step where a new packet was created e.g. in
1066 * the caches. Ultimately when the response reaches the source a
1067 * final memcpy is needed to extract the data from the packet
1068 * before it is deallocated.
1070 template <typename T>
1074 assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
1075 data = (PacketDataPtr)p;
1076 flags.set(DYNAMIC_DATA);
1080 * get a pointer to the data ptr.
1082 template <typename T>
1086 assert(flags.isSet(STATIC_DATA|DYNAMIC_DATA));
1087 assert(!isMaskedWrite());
1091 template <typename T>
1095 assert(flags.isSet(STATIC_DATA|DYNAMIC_DATA));
1096 return (const T*)data;
1100 * Get the data in the packet byte swapped from big endian to
1103 template <typename T>
1107 * Get the data in the packet byte swapped from little endian to
1110 template <typename T>
1114 * Get the data in the packet byte swapped from the specified
1117 template <typename T>
1118 T get(ByteOrder endian) const;
1120 /** Set the value in the data pointer to v as big endian. */
1121 template <typename T>
1124 /** Set the value in the data pointer to v as little endian. */
1125 template <typename T>
1129 * Set the value in the data pointer to v using the specified
1132 template <typename T>
1133 void set(T v, ByteOrder endian);
1136 * Get the data in the packet byte swapped from the specified
1137 * endianness and zero-extended to 64 bits.
1139 uint64_t getUintX(ByteOrder endian) const;
1142 * Set the value in the word w after truncating it to the length
1143 * of the packet and then byteswapping it to the desired
1146 void setUintX(uint64_t w, ByteOrder endian);
1149 * Copy data into the packet from the provided pointer.
1152 setData(const uint8_t *p)
1154 // we should never be copying data onto itself, which means we
1155 // must idenfity packets with static data, as they carry the
1156 // same pointer from source to destination and back
1157 assert(p != getPtr<uint8_t>() || flags.isSet(STATIC_DATA));
1159 if (p != getPtr<uint8_t>()) {
1160 // for packet with allocated dynamic data, we copy data from
1161 // one to the other, e.g. a forwarded response to a response
1162 std::memcpy(getPtr<uint8_t>(), p, getSize());
1167 * Copy data into the packet from the provided block pointer,
1168 * which is aligned to the given block size.
1171 setDataFromBlock(const uint8_t *blk_data, int blkSize)
1173 setData(blk_data + getOffset(blkSize));
1177 * Copy data from the packet to the memory at the provided pointer.
1178 * @param p Pointer to which data will be copied.
1181 writeData(uint8_t *p) const
1183 if (!isMaskedWrite()) {
1184 std::memcpy(p, getConstPtr<uint8_t>(), getSize());
1186 assert(req->getByteEnable().size() == getSize());
1187 // Write only the enabled bytes
1188 const uint8_t *base = getConstPtr<uint8_t>();
1189 for (int i = 0; i < getSize(); i++) {
1190 if (req->getByteEnable()[i]) {
1193 // Disabled bytes stay untouched
1199 * Copy data from the packet to the provided block pointer, which
1200 * is aligned to the given block size.
1201 * @param blk_data Pointer to block to which data will be copied.
1202 * @param blkSize Block size in bytes.
1205 writeDataToBlock(uint8_t *blk_data, int blkSize) const
1207 writeData(blk_data + getOffset(blkSize));
1211 * delete the data pointed to in the data pointer. Ok to call to
1212 * matter how data was allocted.
1217 if (flags.isSet(DYNAMIC_DATA))
1220 flags.clear(STATIC_DATA|DYNAMIC_DATA);
1224 /** Allocate memory for the packet. */
1228 // if either this command or the response command has a data
1229 // payload, actually allocate space
1230 if (hasData() || hasRespData()) {
1231 assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
1232 flags.set(DYNAMIC_DATA);
1233 data = new uint8_t[getSize()];
1239 /** Get the data in the packet without byte swapping. */
1240 template <typename T>
1243 /** Set the value in the data pointer to v without byte swapping. */
1244 template <typename T>
1249 * Check a functional request against a memory value stored in
1250 * another packet (i.e. an in-transit request or
1251 * response). Returns true if the current packet is a read, and
1252 * the other packet provides the data, which is then copied to the
1253 * current packet. If the current packet is a write, and the other
1254 * packet intersects this one, then we update the data
1258 trySatisfyFunctional(PacketPtr other)
1260 if (other->isMaskedWrite()) {
1261 // Do not forward data if overlapping with a masked write
1262 if (_isSecure == other->isSecure() &&
1263 getAddr() <= (other->getAddr() + other->getSize() - 1) &&
1264 other->getAddr() <= (getAddr() + getSize() - 1)) {
1265 warn("Trying to check against a masked write, skipping."
1266 " (addr: 0x%x, other addr: 0x%x)", getAddr(),
1271 // all packets that are carrying a payload should have a valid
1273 return trySatisfyFunctional(other, other->getAddr(), other->isSecure(),
1276 other->getPtr<uint8_t>() : NULL);
1280 * Does the request need to check for cached copies of the same block
1281 * in the memory hierarchy above.
1284 mustCheckAbove() const
1286 return cmd == MemCmd::HardPFReq || isEviction();
1290 * Is this packet a clean eviction, including both actual clean
1291 * evict packets, but also clean writebacks.
1294 isCleanEviction() const
1296 return cmd == MemCmd::CleanEvict || cmd == MemCmd::WritebackClean;
1300 isMaskedWrite() const
1302 return (cmd == MemCmd::WriteReq && req->isMasked());
1306 * Check a functional request against a memory value represented
1307 * by a base/size pair and an associated data array. If the
1308 * current packet is a read, it may be satisfied by the memory
1309 * value. If the current packet is a write, it may update the
1313 trySatisfyFunctional(Printable *obj, Addr base, bool is_secure, int size,
1317 * Push label for PrintReq (safe to call unconditionally).
1320 pushLabel(const std::string &lbl)
1323 safe_cast<PrintReqState*>(senderState)->pushLabel(lbl);
1327 * Pop label for PrintReq (safe to call unconditionally).
1333 safe_cast<PrintReqState*>(senderState)->popLabel();
1336 void print(std::ostream &o, int verbosity = 0,
1337 const std::string &prefix = "") const;
1340 * A no-args wrapper of print(std::ostream...)
1341 * meant to be invoked from DPRINTFs
1342 * avoiding string overheads in fast mode
1343 * @return string with the request's type and start<->end addresses
1345 std::string print() const;
1348 #endif //__MEM_PACKET_HH