2 * Copyright (c) 2012-2014 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 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.
41 * Authors: Ron Dreslinski
49 * Declaration of the Packet class.
52 #ifndef __MEM_PACKET_HH__
53 #define __MEM_PACKET_HH__
59 #include "base/cast.hh"
60 #include "base/compiler.hh"
61 #include "base/flags.hh"
62 #include "base/misc.hh"
63 #include "base/printable.hh"
64 #include "base/types.hh"
65 #include "mem/request.hh"
66 #include "sim/core.hh"
69 typedef Packet *PacketPtr;
70 typedef uint8_t* PacketDataPtr;
71 typedef std::list<PacketPtr> PacketList;
79 * List of all commands associated with a packet.
86 ReadRespWithInvalidate,
97 SCUpgradeReq, // Special "weak" upgrade for StoreCond
99 SCUpgradeFailReq, // Failed SCUpgradeReq in MSHR (never sent)
100 UpgradeFailResp, // Valid for SCUpgradeReq only
105 StoreCondFailReq, // Failed StoreCondReq in MSHR (never sent)
112 // @TODO these should be classified as responses rather than
113 // requests; coding them as requests initially for backwards
115 InvalidDestError, // packet dest field invalid
116 BadAddressError, // memory address invalid
117 FunctionalReadError, // unable to fulfill functional read
118 FunctionalWriteError, // unable to fulfill functional write
119 // Fake simulator-only commands
120 PrintReq, // Print state matching address
121 FlushReq, //request for a cache flush
122 InvalidationReq, // request for address to be invalidated from lsq
128 * List of command attributes.
132 IsRead, //!< Data flows from responder to requester
133 IsWrite, //!< Data flows from requester to responder
136 NeedsExclusive, //!< Requires exclusive copy to complete in-cache
137 IsRequest, //!< Issued by requester
138 IsResponse, //!< Issue by responder
139 NeedsResponse, //!< Requester needs response from target
142 IsLlsc, //!< Alpha/MIPS LL or SC access
143 HasData, //!< There is an associated payload
144 IsError, //!< Error response
145 IsPrint, //!< Print state matching address (for debugging)
146 IsFlush, //!< Flush the address from caches
147 NUM_COMMAND_ATTRIBUTES
151 * Structure that defines attributes and other data associated
156 /// Set of attribute flags.
157 const std::bitset<NUM_COMMAND_ATTRIBUTES> attributes;
158 /// Corresponding response for requests; InvalidCmd if no
159 /// response is applicable.
160 const Command response;
161 /// String representation (for printing)
162 const std::string str;
165 /// Array to map Command enum to associated info.
166 static const CommandInfo commandInfo[];
173 testCmdAttrib(MemCmd::Attribute attrib) const
175 return commandInfo[cmd].attributes[attrib] != 0;
180 bool isRead() const { return testCmdAttrib(IsRead); }
181 bool isWrite() const { return testCmdAttrib(IsWrite); }
182 bool isUpgrade() const { return testCmdAttrib(IsUpgrade); }
183 bool isRequest() const { return testCmdAttrib(IsRequest); }
184 bool isResponse() const { return testCmdAttrib(IsResponse); }
185 bool needsExclusive() const { return testCmdAttrib(NeedsExclusive); }
186 bool needsResponse() const { return testCmdAttrib(NeedsResponse); }
187 bool isInvalidate() const { return testCmdAttrib(IsInvalidate); }
188 bool isWriteInvalidate() const { return testCmdAttrib(IsWrite) &&
189 testCmdAttrib(IsInvalidate); }
192 * Check if this particular packet type carries payload data. Note
193 * that this does not reflect if the data pointer of the packet is
196 bool hasData() const { return testCmdAttrib(HasData); }
197 bool isLLSC() const { return testCmdAttrib(IsLlsc); }
198 bool isSWPrefetch() const { return testCmdAttrib(IsSWPrefetch); }
199 bool isHWPrefetch() const { return testCmdAttrib(IsHWPrefetch); }
200 bool isPrefetch() const { return testCmdAttrib(IsSWPrefetch) ||
201 testCmdAttrib(IsHWPrefetch); }
202 bool isError() const { return testCmdAttrib(IsError); }
203 bool isPrint() const { return testCmdAttrib(IsPrint); }
204 bool isFlush() const { return testCmdAttrib(IsFlush); }
207 responseCommand() const
209 return commandInfo[cmd].response;
212 /// Return the string to a cmd given by idx.
213 const std::string &toString() const { return commandInfo[cmd].str; }
214 int toInt() const { return (int)cmd; }
216 MemCmd(Command _cmd) : cmd(_cmd) { }
217 MemCmd(int _cmd) : cmd((Command)_cmd) { }
218 MemCmd() : cmd(InvalidCmd) { }
220 bool operator==(MemCmd c2) const { return (cmd == c2.cmd); }
221 bool operator!=(MemCmd c2) const { return (cmd != c2.cmd); }
225 * A Packet is used to encapsulate a transfer between two objects in
226 * the memory system (e.g., the L1 and L2 cache). (In contrast, a
227 * single Request travels all the way from the requester to the
228 * ultimate destination and back, possibly being conveyed by several
229 * different Packets along the way.)
231 class Packet : public Printable
234 typedef uint32_t FlagsType;
235 typedef ::Flags<FlagsType> Flags;
238 static const FlagsType PUBLIC_FLAGS = 0x00000000;
239 static const FlagsType PRIVATE_FLAGS = 0x00007F0F;
240 static const FlagsType COPY_FLAGS = 0x0000000F;
242 static const FlagsType SHARED = 0x00000001;
243 // Special control flags
244 /// Special timing-mode atomic snoop for multi-level coherence.
245 static const FlagsType EXPRESS_SNOOP = 0x00000002;
246 /// Does supplier have exclusive copy?
247 /// Useful for multi-level coherence.
248 static const FlagsType SUPPLY_EXCLUSIVE = 0x00000004;
249 // Snoop response flags
250 static const FlagsType MEM_INHIBIT = 0x00000008;
251 /// Are the 'addr' and 'size' fields valid?
252 static const FlagsType VALID_ADDR = 0x00000100;
253 static const FlagsType VALID_SIZE = 0x00000200;
254 /// Is the data pointer set to a value that shouldn't be freed
255 /// when the packet is destroyed?
256 static const FlagsType STATIC_DATA = 0x00001000;
257 /// The data pointer points to a value that should be freed when
258 /// the packet is destroyed. The pointer is assumed to be pointing
259 /// to an array, and delete [] is consequently called
260 static const FlagsType DYNAMIC_DATA = 0x00002000;
261 /// suppress the error if this packet encounters a functional
263 static const FlagsType SUPPRESS_FUNC_ERROR = 0x00008000;
264 // Signal prefetch squash through express snoop flag
265 static const FlagsType PREFETCH_SNOOP_SQUASH = 0x00010000;
270 typedef MemCmd::Command Command;
272 /// The command field of the packet.
275 /// A pointer to the original request.
276 const RequestPtr req;
280 * A pointer to the data being transfered. It can be differnt
281 * sizes at each level of the heirarchy so it belongs in the
282 * packet, not request. This may or may not be populated when a
283 * responder recieves the packet. If not populated it memory should
288 /// The address of the request. This address could be virtual or
289 /// physical, depending on the system configuration.
292 /// True if the request targets the secure memory space.
295 /// The size of the request or transfer.
299 * The original value of the command field. Only valid when the
300 * current command field is an error condition; in that case, the
301 * previous contents of the command field are copied here. This
302 * field is *not* set on non-error responses.
307 * These values specify the range of bytes found that satisfy a
310 uint16_t bytesValidStart;
311 uint16_t bytesValidEnd;
316 * The extra delay from seeing the packet until the first word is
317 * transmitted. This delay is used to communicate the crossbar
318 * forwarding latency to the neighbouring object (e.g. a cache)
319 * that actually makes the packet wait. As the delay is relative,
320 * a 32-bit unsigned should be sufficient.
322 uint32_t firstWordDelay;
325 * The extra pipelining delay from seeing the packet until the
326 * last word is transmitted by the component that provided it (if
327 * any). This includes the first word delay. Similar to the first
328 * word delay, this is used to make up for the fact that the
329 * crossbar does not make the packet wait. As the delay is
330 * relative, a 32-bit unsigned should be sufficient.
332 uint32_t lastWordDelay;
335 * A virtual base opaque structure used to hold state associated
336 * with the packet (e.g., an MSHR), specific to a MemObject that
337 * sees the packet. A pointer to this state is returned in the
338 * packet's response so that the MemObject in question can quickly
339 * look up the state needed to process it. A specific subclass
340 * would be derived from this to carry state specific to a
341 * particular sending device.
343 * As multiple MemObjects may add their SenderState throughout the
344 * memory system, the SenderStates create a stack, where a
345 * MemObject can add a new Senderstate, as long as the
346 * predecessing SenderState is restored when the response comes
347 * back. For this reason, the predecessor should always be
348 * populated with the current SenderState of a packet before
349 * modifying the senderState field in the request packet.
353 SenderState* predecessor;
354 SenderState() : predecessor(NULL) {}
355 virtual ~SenderState() {}
359 * Object used to maintain state of a PrintReq. The senderState
360 * field of a PrintReq should always be of this type.
362 class PrintReqState : public SenderState
366 * An entry in the label stack.
368 struct LabelStackEntry
370 const std::string label;
373 LabelStackEntry(const std::string &_label, std::string *_prefix);
376 typedef std::list<LabelStackEntry> LabelStack;
377 LabelStack labelStack;
379 std::string *curPrefixPtr;
385 PrintReqState(std::ostream &os, int verbosity = 0);
389 * Returns the current line prefix.
391 const std::string &curPrefix() { return *curPrefixPtr; }
394 * Push a label onto the label stack, and prepend the given
395 * prefix string onto the current prefix. Labels will only be
396 * printed if an object within the label's scope is printed.
398 void pushLabel(const std::string &lbl,
399 const std::string &prefix = " ");
402 * Pop a label off the label stack.
407 * Print all of the pending unprinted labels on the
408 * stack. Called by printObj(), so normally not called by
409 * users unless bypassing printObj().
414 * Print a Printable object to os, because it matched the
415 * address on a PrintReq.
417 void printObj(Printable *obj);
421 * This packet's sender state. Devices should use dynamic_cast<>
422 * to cast to the state appropriate to the sender. The intent of
423 * this variable is to allow a device to attach extra information
424 * to a request. A response packet must return the sender state
425 * that was attached to the original request (even if a new packet
428 SenderState *senderState;
431 * Push a new sender state to the packet and make the current
432 * sender state the predecessor of the new one. This should be
433 * prefered over direct manipulation of the senderState member
436 * @param sender_state SenderState to push at the top of the stack
438 void pushSenderState(SenderState *sender_state);
441 * Pop the top of the state stack and return a pointer to it. This
442 * assumes the current sender state is not NULL. This should be
443 * preferred over direct manipulation of the senderState member
446 * @return The current top of the stack
448 SenderState *popSenderState();
451 * Go through the sender state stack and return the first instance
452 * that is of type T (as determined by a dynamic_cast). If there
453 * is no sender state of type T, NULL is returned.
455 * @return The topmost state of type T
457 template <typename T>
458 T * findNextSenderState() const
461 SenderState* sender_state = senderState;
462 while (t == NULL && sender_state != NULL) {
463 t = dynamic_cast<T*>(sender_state);
464 sender_state = sender_state->predecessor;
469 /// Return the string name of the cmd field (for debugging and
471 const std::string &cmdString() const { return cmd.toString(); }
473 /// Return the index of this command.
474 inline int cmdToIndex() const { return cmd.toInt(); }
476 bool isRead() const { return cmd.isRead(); }
477 bool isWrite() const { return cmd.isWrite(); }
478 bool isUpgrade() const { return cmd.isUpgrade(); }
479 bool isRequest() const { return cmd.isRequest(); }
480 bool isResponse() const { return cmd.isResponse(); }
481 bool needsExclusive() const { return cmd.needsExclusive(); }
482 bool needsResponse() const { return cmd.needsResponse(); }
483 bool isInvalidate() const { return cmd.isInvalidate(); }
484 bool isWriteInvalidate() const { return cmd.isWriteInvalidate(); }
485 bool hasData() const { return cmd.hasData(); }
486 bool isLLSC() const { return cmd.isLLSC(); }
487 bool isError() const { return cmd.isError(); }
488 bool isPrint() const { return cmd.isPrint(); }
489 bool isFlush() const { return cmd.isFlush(); }
492 void assertMemInhibit()
495 assert(!flags.isSet(MEM_INHIBIT));
496 flags.set(MEM_INHIBIT);
498 bool memInhibitAsserted() const { return flags.isSet(MEM_INHIBIT); }
499 void assertShared() { flags.set(SHARED); }
500 bool sharedAsserted() const { return flags.isSet(SHARED); }
502 // Special control flags
503 void setExpressSnoop() { flags.set(EXPRESS_SNOOP); }
504 bool isExpressSnoop() const { return flags.isSet(EXPRESS_SNOOP); }
505 void setSupplyExclusive() { flags.set(SUPPLY_EXCLUSIVE); }
506 void clearSupplyExclusive() { flags.clear(SUPPLY_EXCLUSIVE); }
507 bool isSupplyExclusive() const { return flags.isSet(SUPPLY_EXCLUSIVE); }
508 void setSuppressFuncError() { flags.set(SUPPRESS_FUNC_ERROR); }
509 bool suppressFuncError() const { return flags.isSet(SUPPRESS_FUNC_ERROR); }
510 void setPrefetchSquashed() { flags.set(PREFETCH_SNOOP_SQUASH); }
511 bool prefetchSquashed() const { return flags.isSet(PREFETCH_SNOOP_SQUASH); }
513 // Network error conditions... encapsulate them as methods since
514 // their encoding keeps changing (from result field to command
519 assert(isResponse());
520 cmd = MemCmd::BadAddressError;
523 bool hadBadAddress() const { return cmd == MemCmd::BadAddressError; }
524 void copyError(Packet *pkt) { assert(pkt->isError()); cmd = pkt->cmd; }
526 Addr getAddr() const { assert(flags.isSet(VALID_ADDR)); return addr; }
528 * Update the address of this packet mid-transaction. This is used
529 * by the address mapper to change an already set address to a new
530 * one based on the system configuration. It is intended to remap
531 * an existing address, so it asserts that the current address is
534 void setAddr(Addr _addr) { assert(flags.isSet(VALID_ADDR)); addr = _addr; }
536 unsigned getSize() const { assert(flags.isSet(VALID_SIZE)); return size; }
537 Addr getOffset(int blkSize) const { return getAddr() & (Addr)(blkSize - 1); }
539 bool isSecure() const
541 assert(flags.isSet(VALID_ADDR));
546 * It has been determined that the SC packet should successfully update
547 * memory. Therefore, convert this SC packet to a normal write.
554 cmd = MemCmd::WriteReq;
558 * When ruby is in use, Ruby will monitor the cache line and thus M5
559 * phys memory should treat LL ops as normal reads.
566 cmd = MemCmd::ReadReq;
570 * Constructor. Note that a Request object must be constructed
571 * first, but the Requests's physical address and size fields need
572 * not be valid. The command must be supplied.
574 Packet(const RequestPtr _req, MemCmd _cmd)
575 : cmd(_cmd), req(_req), data(nullptr), addr(0), _isSecure(false),
576 size(0), bytesValidStart(0), bytesValidEnd(0),
577 firstWordDelay(0), lastWordDelay(0),
580 if (req->hasPaddr()) {
581 addr = req->getPaddr();
582 flags.set(VALID_ADDR);
583 _isSecure = req->isSecure();
585 if (req->hasSize()) {
586 size = req->getSize();
587 flags.set(VALID_SIZE);
592 * Alternate constructor if you are trying to create a packet with
593 * a request that is for a whole block, not the address from the
594 * req. this allows for overriding the size/addr of the req.
596 Packet(const RequestPtr _req, MemCmd _cmd, int _blkSize)
597 : cmd(_cmd), req(_req), data(nullptr), addr(0), _isSecure(false),
598 bytesValidStart(0), bytesValidEnd(0),
599 firstWordDelay(0), lastWordDelay(0),
602 if (req->hasPaddr()) {
603 addr = req->getPaddr() & ~(_blkSize - 1);
604 flags.set(VALID_ADDR);
605 _isSecure = req->isSecure();
608 flags.set(VALID_SIZE);
612 * Alternate constructor for copying a packet. Copy all fields
613 * *except* if the original packet's data was dynamic, don't copy
614 * that, as we can't guarantee that the new packet's lifetime is
615 * less than that of the original packet. In this case the new
616 * packet should allocate its own data.
618 Packet(PacketPtr pkt, bool clear_flags, bool alloc_data)
619 : cmd(pkt->cmd), req(pkt->req),
621 addr(pkt->addr), _isSecure(pkt->_isSecure), size(pkt->size),
622 bytesValidStart(pkt->bytesValidStart),
623 bytesValidEnd(pkt->bytesValidEnd),
624 firstWordDelay(pkt->firstWordDelay),
625 lastWordDelay(pkt->lastWordDelay),
626 senderState(pkt->senderState)
629 flags.set(pkt->flags & COPY_FLAGS);
631 flags.set(pkt->flags & (VALID_ADDR|VALID_SIZE));
633 // should we allocate space for data, or not, the express
634 // snoops do not need to carry any data as they only serve to
635 // co-ordinate state changes
637 // even if asked to allocate data, if the original packet
638 // holds static data, then the sender will not be doing
639 // any memcpy on receiving the response, thus we simply
640 // carry the pointer forward
641 if (pkt->flags.isSet(STATIC_DATA)) {
643 flags.set(STATIC_DATA);
651 * Change the packet type based on request type.
656 if (cmd == MemCmd::ReadReq) {
658 cmd = MemCmd::LoadLockedReq;
659 } else if (req->isPrefetch()) {
660 cmd = MemCmd::SoftPFReq;
662 } else if (cmd == MemCmd::WriteReq) {
664 cmd = MemCmd::StoreCondReq;
665 } else if (req->isSwap()) {
666 cmd = MemCmd::SwapReq;
672 * Constructor-like methods that return Packets based on Request objects.
673 * Will call refineCommand() to fine-tune the Packet type if it's not a
674 * vanilla read or write.
677 createRead(const RequestPtr req)
679 PacketPtr pkt = new Packet(req, MemCmd::ReadReq);
680 pkt->refineCommand();
685 createWrite(const RequestPtr req)
687 PacketPtr pkt = new Packet(req, MemCmd::WriteReq);
688 pkt->refineCommand();
693 * clean up packet variables
697 // If this is a request packet for which there's no response,
698 // delete the request object here, since the requester will
699 // never get the chance.
700 if (req && isRequest() && !needsResponse())
706 * Take a request packet and modify it in place to be suitable for
707 * returning as a response to that request.
712 assert(needsResponse());
715 cmd = cmd.responseCommand();
717 // responses are never express, even if the snoop that
718 // triggered them was
719 flags.clear(EXPRESS_SNOOP);
735 setFunctionalResponseStatus(bool success)
739 cmd = MemCmd::FunctionalWriteError;
741 cmd = MemCmd::FunctionalReadError;
747 setSize(unsigned size)
749 assert(!flags.isSet(VALID_SIZE));
752 flags.set(VALID_SIZE);
757 * Set the data pointer to the following value that should not be
758 * freed. Static data allows us to do a single memcpy even if
759 * multiple packets are required to get from source to destination
760 * and back. In essence the pointer is set calling dataStatic on
761 * the original packet, and whenever this packet is copied and
762 * forwarded the same pointer is passed on. When a packet
763 * eventually reaches the destination holding the data, it is
764 * copied once into the location originally set. On the way back
765 * to the source, no copies are necessary.
767 template <typename T>
771 assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
772 data = (PacketDataPtr)p;
773 flags.set(STATIC_DATA);
777 * Set the data pointer to the following value that should not be
778 * freed. This version of the function allows the pointer passed
779 * to us to be const. To avoid issues down the line we cast the
780 * constness away, the alternative would be to keep both a const
781 * and non-const data pointer and cleverly choose between
782 * them. Note that this is only allowed for static data.
784 template <typename T>
786 dataStaticConst(const T *p)
788 assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
789 data = const_cast<PacketDataPtr>(p);
790 flags.set(STATIC_DATA);
794 * Set the data pointer to a value that should have delete []
795 * called on it. Dynamic data is local to this packet, and as the
796 * packet travels from source to destination, forwarded packets
797 * will allocate their own data. When a packet reaches the final
798 * destination it will populate the dynamic data of that specific
799 * packet, and on the way back towards the source, memcpy will be
800 * invoked in every step where a new packet was created e.g. in
801 * the caches. Ultimately when the response reaches the source a
802 * final memcpy is needed to extract the data from the packet
803 * before it is deallocated.
805 template <typename T>
809 assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
810 data = (PacketDataPtr)p;
811 flags.set(DYNAMIC_DATA);
815 * get a pointer to the data ptr.
817 template <typename T>
821 assert(flags.isSet(STATIC_DATA|DYNAMIC_DATA));
825 template <typename T>
829 assert(flags.isSet(STATIC_DATA|DYNAMIC_DATA));
830 return (const T*)data;
834 * return the value of what is pointed to in the packet.
836 template <typename T>
840 * set the value in the data pointer to v.
842 template <typename T>
846 * Copy data into the packet from the provided pointer.
849 setData(const uint8_t *p)
851 // we should never be copying data onto itself, which means we
852 // must idenfity packets with static data, as they carry the
853 // same pointer from source to destination and back
854 assert(p != getPtr<uint8_t>() || flags.isSet(STATIC_DATA));
856 if (p != getPtr<uint8_t>())
857 // for packet with allocated dynamic data, we copy data from
858 // one to the other, e.g. a forwarded response to a response
859 std::memcpy(getPtr<uint8_t>(), p, getSize());
863 * Copy data into the packet from the provided block pointer,
864 * which is aligned to the given block size.
867 setDataFromBlock(const uint8_t *blk_data, int blkSize)
869 setData(blk_data + getOffset(blkSize));
873 * Copy data from the packet to the provided block pointer, which
874 * is aligned to the given block size.
877 writeData(uint8_t *p) const
879 std::memcpy(p, getConstPtr<uint8_t>(), getSize());
883 * Copy data from the packet to the memory at the provided pointer.
886 writeDataToBlock(uint8_t *blk_data, int blkSize) const
888 writeData(blk_data + getOffset(blkSize));
892 * delete the data pointed to in the data pointer. Ok to call to
893 * matter how data was allocted.
898 if (flags.isSet(DYNAMIC_DATA))
901 flags.clear(STATIC_DATA|DYNAMIC_DATA);
905 /** Allocate memory for the packet. */
909 assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
910 flags.set(DYNAMIC_DATA);
911 data = new uint8_t[getSize()];
915 * Check a functional request against a memory value stored in
916 * another packet (i.e. an in-transit request or
917 * response). Returns true if the current packet is a read, and
918 * the other packet provides the data, which is then copied to the
919 * current packet. If the current packet is a write, and the other
920 * packet intersects this one, then we update the data
924 checkFunctional(PacketPtr other)
926 // all packets that are carrying a payload should have a valid
928 return checkFunctional(other, other->getAddr(), other->isSecure(),
931 other->getPtr<uint8_t>() : NULL);
935 * Check a functional request against a memory value represented
936 * by a base/size pair and an associated data array. If the
937 * current packet is a read, it may be satisfied by the memory
938 * value. If the current packet is a write, it may update the
942 checkFunctional(Printable *obj, Addr base, bool is_secure, int size,
946 * Push label for PrintReq (safe to call unconditionally).
949 pushLabel(const std::string &lbl)
952 safe_cast<PrintReqState*>(senderState)->pushLabel(lbl);
956 * Pop label for PrintReq (safe to call unconditionally).
962 safe_cast<PrintReqState*>(senderState)->popLabel();
965 void print(std::ostream &o, int verbosity = 0,
966 const std::string &prefix = "") const;
969 * A no-args wrapper of print(std::ostream...)
970 * meant to be invoked from DPRINTFs
971 * avoiding string overheads in fast mode
972 * @return string with the request's type and start<->end addresses
974 std::string print() const;
977 #endif //__MEM_PACKET_HH