src/mem/packet.hh

   1 /*
   2  * Copyright (c) 2012 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) 2006 The Regents of The University of Michigan
  15  * Copyright (c) 2010 Advanced Micro Devices, Inc.
  16  * All rights reserved.
  17  *
  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.
  28  *
  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.
  40  *
  41  * Authors: Ron Dreslinski
  42  *          Steve Reinhardt
  43  *          Ali Saidi
  44  */
  45
  46 /**
  47  * @file
  48  * Declaration of the Packet class.
  49  */
  50
  51 #ifndef __MEM_PACKET_HH__
  52 #define __MEM_PACKET_HH__
  53
  54 #include <bitset>
  55 #include <cassert>
  56 #include <list>
  57
  58 #include "base/cast.hh"
  59 #include "base/compiler.hh"
  60 #include "base/fast_alloc.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"
  67
  68 class Packet;
  69 typedef Packet *PacketPtr;
  70 typedef uint8_t* PacketDataPtr;
  71 typedef std::list<PacketPtr> PacketList;
  72
  73 class MemCmd
  74 {
  75     friend class Packet;
  76
  77   public:
  78     /**
  79      * List of all commands associated with a packet.
  80      */
  81     enum Command
  82     {
  83         InvalidCmd,
  84         ReadReq,
  85         ReadResp,
  86         ReadRespWithInvalidate,
  87         WriteReq,
  88         WriteResp,
  89         Writeback,
  90         SoftPFReq,
  91         HardPFReq,
  92         SoftPFResp,
  93         HardPFResp,
  94         // WriteInvalidateReq transactions used to be generated by the
  95         // DMA ports when writing full blocks to memory, however, it
  96         // is not used anymore since we put the I/O cache in place to
  97         // deal with partial block writes. Hence, WriteInvalidateReq
  98         // and WriteInvalidateResp are currently unused. The
  99         // implication is that the I/O cache does read-exclusive
 100         // operations on every full-cache-block DMA, and ultimately
 101         // this needs to be fixed.
 102         WriteInvalidateReq,
 103         WriteInvalidateResp,
 104         UpgradeReq,
 105         SCUpgradeReq,           // Special "weak" upgrade for StoreCond
 106         UpgradeResp,
 107         SCUpgradeFailReq,       // Failed SCUpgradeReq in MSHR (never sent)
 108         UpgradeFailResp,        // Valid for SCUpgradeReq only
 109         ReadExReq,
 110         ReadExResp,
 111         LoadLockedReq,
 112         StoreCondReq,
 113         StoreCondFailReq,       // Failed StoreCondReq in MSHR (never sent)
 114         StoreCondResp,
 115         SwapReq,
 116         SwapResp,
 117         MessageReq,
 118         MessageResp,
 119         // Error responses
 120         // @TODO these should be classified as responses rather than
 121         // requests; coding them as requests initially for backwards
 122         // compatibility
 123         NetworkNackError,  // nacked at network layer (not by protocol)
 124         InvalidDestError,  // packet dest field invalid
 125         BadAddressError,   // memory address invalid
 126         FunctionalReadError, // unable to fulfill functional read
 127         FunctionalWriteError, // unable to fulfill functional write
 128         // Fake simulator-only commands
 129         PrintReq,       // Print state matching address
 130         FlushReq,      //request for a cache flush
 131         InvalidationReq,   // request for address to be invalidated from lsq
 132         NUM_MEM_CMDS
 133     };
 134
 135   private:
 136     /**
 137      * List of command attributes.
 138      */
 139     enum Attribute
 140     {
 141         IsRead,         //!< Data flows from responder to requester
 142         IsWrite,        //!< Data flows from requester to responder
 143         IsUpgrade,
 144         IsInvalidate,
 145         NeedsExclusive, //!< Requires exclusive copy to complete in-cache
 146         IsRequest,      //!< Issued by requester
 147         IsResponse,     //!< Issue by responder
 148         NeedsResponse,  //!< Requester needs response from target
 149         IsSWPrefetch,
 150         IsHWPrefetch,
 151         IsLlsc,         //!< Alpha/MIPS LL or SC access
 152         HasData,        //!< There is an associated payload
 153         IsError,        //!< Error response
 154         IsPrint,        //!< Print state matching address (for debugging)
 155         IsFlush,        //!< Flush the address from caches
 156         NUM_COMMAND_ATTRIBUTES
 157     };
 158
 159     /**
 160      * Structure that defines attributes and other data associated
 161      * with a Command.
 162      */
 163     struct CommandInfo
 164     {
 165         /// Set of attribute flags.
 166         const std::bitset<NUM_COMMAND_ATTRIBUTES> attributes;
 167         /// Corresponding response for requests; InvalidCmd if no
 168         /// response is applicable.
 169         const Command response;
 170         /// String representation (for printing)
 171         const std::string str;
 172     };
 173
 174     /// Array to map Command enum to associated info.
 175     static const CommandInfo commandInfo[];
 176
 177   private:
 178
 179     Command cmd;
 180
 181     bool
 182     testCmdAttrib(MemCmd::Attribute attrib) const
 183     {
 184         return commandInfo[cmd].attributes[attrib] != 0;
 185     }
 186
 187   public:
 188
 189     bool isRead() const         { return testCmdAttrib(IsRead); }
 190     bool isWrite() const        { return testCmdAttrib(IsWrite); }
 191     bool isUpgrade() const      { return testCmdAttrib(IsUpgrade); }
 192     bool isRequest() const      { return testCmdAttrib(IsRequest); }
 193     bool isResponse() const     { return testCmdAttrib(IsResponse); }
 194     bool needsExclusive() const { return testCmdAttrib(NeedsExclusive); }
 195     bool needsResponse() const  { return testCmdAttrib(NeedsResponse); }
 196     bool isInvalidate() const   { return testCmdAttrib(IsInvalidate); }
 197     bool hasData() const        { return testCmdAttrib(HasData); }
 198     bool isReadWrite() const    { return isRead() && isWrite(); }
 199     bool isLLSC() const         { return testCmdAttrib(IsLlsc); }
 200     bool isError() const        { return testCmdAttrib(IsError); }
 201     bool isPrint() const        { return testCmdAttrib(IsPrint); }
 202     bool isFlush() const        { return testCmdAttrib(IsFlush); }
 203
 204     const Command
 205     responseCommand() const
 206     {
 207         return commandInfo[cmd].response;
 208     }
 209
 210     /// Return the string to a cmd given by idx.
 211     const std::string &toString() const { return commandInfo[cmd].str; }
 212     int toInt() const { return (int)cmd; }
 213
 214     MemCmd(Command _cmd) : cmd(_cmd) { }
 215     MemCmd(int _cmd) : cmd((Command)_cmd) { }
 216     MemCmd() : cmd(InvalidCmd) { }
 217
 218     bool operator==(MemCmd c2) const { return (cmd == c2.cmd); }
 219     bool operator!=(MemCmd c2) const { return (cmd != c2.cmd); }
 220 };
 221
 222 /**
 223  * A Packet is used to encapsulate a transfer between two objects in
 224  * the memory system (e.g., the L1 and L2 cache).  (In contrast, a
 225  * single Request travels all the way from the requester to the
 226  * ultimate destination and back, possibly being conveyed by several
 227  * different Packets along the way.)
 228  */
 229 class Packet : public FastAlloc, public Printable
 230 {
 231   public:
 232     typedef uint32_t FlagsType;
 233     typedef ::Flags<FlagsType> Flags;
 234     typedef short NodeID;
 235
 236   private:
 237     static const FlagsType PUBLIC_FLAGS           = 0x00000000;
 238     static const FlagsType PRIVATE_FLAGS          = 0x00007F0F;
 239     static const FlagsType COPY_FLAGS             = 0x0000000F;
 240
 241     static const FlagsType SHARED                 = 0x00000001;
 242     // Special control flags
 243     /// Special timing-mode atomic snoop for multi-level coherence.
 244     static const FlagsType EXPRESS_SNOOP          = 0x00000002;
 245     /// Does supplier have exclusive copy?
 246     /// Useful for multi-level coherence.
 247     static const FlagsType SUPPLY_EXCLUSIVE       = 0x00000004;
 248     // Snoop response flags
 249     static const FlagsType MEM_INHIBIT            = 0x00000008;
 250     /// Are the 'addr' and 'size' fields valid?
 251     static const FlagsType VALID_ADDR             = 0x00000100;
 252     static const FlagsType VALID_SIZE             = 0x00000200;
 253     /// Is the 'src' field valid?
 254     static const FlagsType VALID_SRC              = 0x00000400;
 255     static const FlagsType VALID_DST              = 0x00000800;
 256     /// Is the data pointer set to a value that shouldn't be freed
 257     /// when the packet is destroyed?
 258     static const FlagsType STATIC_DATA            = 0x00001000;
 259     /// The data pointer points to a value that should be freed when
 260     /// the packet is destroyed.
 261     static const FlagsType DYNAMIC_DATA           = 0x00002000;
 262     /// the data pointer points to an array (thus delete []) needs to
 263     /// be called on it rather than simply delete.
 264     static const FlagsType ARRAY_DATA             = 0x00004000;
 265     /// suppress the error if this packet encounters a functional
 266     /// access failure.
 267     static const FlagsType SUPPRESS_FUNC_ERROR    = 0x00008000;
 268
 269     Flags flags;
 270
 271   public:
 272     typedef MemCmd::Command Command;
 273
 274     /// The command field of the packet.
 275     MemCmd cmd;
 276
 277     /// A pointer to the original request.
 278     RequestPtr req;
 279
 280   private:
 281    /**
 282     * A pointer to the data being transfered.  It can be differnt
 283     * sizes at each level of the heirarchy so it belongs in the
 284     * packet, not request. This may or may not be populated when a
 285     * responder recieves the packet. If not populated it memory should
 286     * be allocated.
 287     */
 288     PacketDataPtr data;
 289
 290     /// The address of the request.  This address could be virtual or
 291     /// physical, depending on the system configuration.
 292     Addr addr;
 293
 294     /// The size of the request or transfer.
 295     unsigned size;
 296
 297     /**
 298      * Device address (e.g., bus ID) of the source of the
 299      * transaction. The source is not responsible for setting this
 300      * field; it is set implicitly by the interconnect when the packet
 301      * is first sent.
 302      */
 303     NodeID src;
 304
 305     /**
 306      * Device address (e.g., bus ID) of the destination of the
 307      * transaction. The special value Broadcast indicates that the
 308      * packet should be routed based on its address. This field is
 309      * initialized in the constructor and is thus always valid (unlike
 310      * addr, size, and src).
 311      */
 312     NodeID dest;
 313
 314     /**
 315      * The original value of the command field.  Only valid when the
 316      * current command field is an error condition; in that case, the
 317      * previous contents of the command field are copied here.  This
 318      * field is *not* set on non-error responses.
 319      */
 320     MemCmd origCmd;
 321
 322     /**
 323      * These values specify the range of bytes found that satisfy a
 324      * functional read.
 325      */
 326     uint16_t bytesValidStart;
 327     uint16_t bytesValidEnd;
 328
 329   public:
 330     /// Used to calculate latencies for each packet.
 331     Tick time;
 332
 333     /// The time at which the packet will be fully transmitted
 334     Tick finishTime;
 335
 336     /// The time at which the first chunk of the packet will be transmitted
 337     Tick firstWordTime;
 338
 339     /**
 340      * A virtual base opaque structure used to hold state associated
 341      * with the packet but specific to the sending device (e.g., an
 342      * MSHR).  A pointer to this state is returned in the packet's
 343      * response so that the sender can quickly look up the state
 344      * needed to process it.  A specific subclass would be derived
 345      * from this to carry state specific to a particular sending
 346      * device.
 347      */
 348     struct SenderState
 349     {
 350         virtual ~SenderState() {}
 351     };
 352
 353     /**
 354      * Object used to maintain state of a PrintReq.  The senderState
 355      * field of a PrintReq should always be of this type.
 356      */
 357     class PrintReqState : public SenderState, public FastAlloc
 358     {
 359       private:
 360         /**
 361          * An entry in the label stack.
 362          */
 363         struct LabelStackEntry
 364         {
 365             const std::string label;
 366             std::string *prefix;
 367             bool labelPrinted;
 368             LabelStackEntry(const std::string &_label, std::string *_prefix);
 369         };
 370
 371         typedef std::list<LabelStackEntry> LabelStack;
 372         LabelStack labelStack;
 373
 374         std::string *curPrefixPtr;
 375
 376       public:
 377         std::ostream &os;
 378         const int verbosity;
 379
 380         PrintReqState(std::ostream &os, int verbosity = 0);
 381         ~PrintReqState();
 382
 383         /**
 384          * Returns the current line prefix.
 385          */
 386         const std::string &curPrefix() { return *curPrefixPtr; }
 387
 388         /**
 389          * Push a label onto the label stack, and prepend the given
 390          * prefix string onto the current prefix.  Labels will only be
 391          * printed if an object within the label's scope is printed.
 392          */
 393         void pushLabel(const std::string &lbl,
 394                        const std::string &prefix = "  ");
 395
 396         /**
 397          * Pop a label off the label stack.
 398          */
 399         void popLabel();
 400
 401         /**
 402          * Print all of the pending unprinted labels on the
 403          * stack. Called by printObj(), so normally not called by
 404          * users unless bypassing printObj().
 405          */
 406         void printLabels();
 407
 408         /**
 409          * Print a Printable object to os, because it matched the
 410          * address on a PrintReq.
 411          */
 412         void printObj(Printable *obj);
 413     };
 414
 415     /**
 416      * This packet's sender state.  Devices should use dynamic_cast<>
 417      * to cast to the state appropriate to the sender.  The intent of
 418      * this variable is to allow a device to attach extra information
 419      * to a request.  A response packet must return the sender state
 420      * that was attached to the original request (even if a new packet
 421      * is created).
 422      */
 423     SenderState *senderState;
 424
 425     /// Return the string name of the cmd field (for debugging and
 426     /// tracing).
 427     const std::string &cmdString() const { return cmd.toString(); }
 428
 429     /// Return the index of this command.
 430     inline int cmdToIndex() const { return cmd.toInt(); }
 431
 432     bool isRead() const         { return cmd.isRead(); }
 433     bool isWrite() const        { return cmd.isWrite(); }
 434     bool isUpgrade()  const     { return cmd.isUpgrade(); }
 435     bool isRequest() const      { return cmd.isRequest(); }
 436     bool isResponse() const     { return cmd.isResponse(); }
 437     bool needsExclusive() const { return cmd.needsExclusive(); }
 438     bool needsResponse() const  { return cmd.needsResponse(); }
 439     bool isInvalidate() const   { return cmd.isInvalidate(); }
 440     bool hasData() const        { return cmd.hasData(); }
 441     bool isReadWrite() const    { return cmd.isReadWrite(); }
 442     bool isLLSC() const         { return cmd.isLLSC(); }
 443     bool isError() const        { return cmd.isError(); }
 444     bool isPrint() const        { return cmd.isPrint(); }
 445     bool isFlush() const        { return cmd.isFlush(); }
 446
 447     // Snoop flags
 448     void assertMemInhibit()     { flags.set(MEM_INHIBIT); }
 449     bool memInhibitAsserted()   { return flags.isSet(MEM_INHIBIT); }
 450     void assertShared()         { flags.set(SHARED); }
 451     bool sharedAsserted()       { return flags.isSet(SHARED); }
 452
 453     // Special control flags
 454     void setExpressSnoop()      { flags.set(EXPRESS_SNOOP); }
 455     bool isExpressSnoop()       { return flags.isSet(EXPRESS_SNOOP); }
 456     void setSupplyExclusive()   { flags.set(SUPPLY_EXCLUSIVE); }
 457     void clearSupplyExclusive() { flags.clear(SUPPLY_EXCLUSIVE); }
 458     bool isSupplyExclusive()    { return flags.isSet(SUPPLY_EXCLUSIVE); }
 459     void setSuppressFuncError() { flags.set(SUPPRESS_FUNC_ERROR); }
 460     bool suppressFuncError()    { return flags.isSet(SUPPRESS_FUNC_ERROR); }
 461
 462     // Network error conditions... encapsulate them as methods since
 463     // their encoding keeps changing (from result field to command
 464     // field, etc.)
 465     void
 466     setNacked()
 467     {
 468         assert(isResponse());
 469         cmd = MemCmd::NetworkNackError;
 470     }
 471
 472     void
 473     setBadAddress()
 474     {
 475         assert(isResponse());
 476         cmd = MemCmd::BadAddressError;
 477     }
 478
 479     bool wasNacked() const     { return cmd == MemCmd::NetworkNackError; }
 480     bool hadBadAddress() const { return cmd == MemCmd::BadAddressError; }
 481     void copyError(Packet *pkt) { assert(pkt->isError()); cmd = pkt->cmd; }
 482
 483     bool isSrcValid() { return flags.isSet(VALID_SRC); }
 484     /// Accessor function to get the source index of the packet.
 485     NodeID getSrc() const    { assert(flags.isSet(VALID_SRC)); return src; }
 486     /// Accessor function to set the source index of the packet.
 487     void setSrc(NodeID _src) { src = _src; flags.set(VALID_SRC); }
 488     /// Reset source field, e.g. to retransmit packet on different bus.
 489     void clearSrc() { flags.clear(VALID_SRC); }
 490
 491     bool isDestValid() { return flags.isSet(VALID_DST); }
 492     /// Accessor function for the destination index of the packet.
 493     NodeID getDest() const     { assert(flags.isSet(VALID_DST)); return dest; }
 494     /// Accessor function to set the destination index of the packet.
 495     void setDest(NodeID _dest) { dest = _dest; flags.set(VALID_DST); }
 496     /// Reset destination field, e.g. to turn a response into a request again.
 497     void clearDest() { flags.clear(VALID_DST); }
 498
 499     Addr getAddr() const { assert(flags.isSet(VALID_ADDR)); return addr; }
 500     unsigned getSize() const  { assert(flags.isSet(VALID_SIZE)); return size; }
 501     Addr getOffset(int blkSize) const { return getAddr() & (Addr)(blkSize - 1); }
 502
 503     /**
 504      * It has been determined that the SC packet should successfully update
 505      * memory.  Therefore, convert this SC packet to a normal write.
 506      */
 507     void
 508     convertScToWrite()
 509     {
 510         assert(isLLSC());
 511         assert(isWrite());
 512         cmd = MemCmd::WriteReq;
 513     }
 514
 515     /**
 516      * When ruby is in use, Ruby will monitor the cache line and thus M5
 517      * phys memory should treat LL ops as normal reads.
 518      */
 519     void
 520     convertLlToRead()
 521     {
 522         assert(isLLSC());
 523         assert(isRead());
 524         cmd = MemCmd::ReadReq;
 525     }
 526
 527     /**
 528      * Constructor.  Note that a Request object must be constructed
 529      * first, but the Requests's physical address and size fields need
 530      * not be valid. The command and destination addresses must be
 531      * supplied.
 532      */
 533     Packet(Request *_req, MemCmd _cmd)
 534         :  cmd(_cmd), req(_req), data(NULL),
 535            bytesValidStart(0), bytesValidEnd(0),
 536            time(curTick()), senderState(NULL)
 537     {
 538         if (req->hasPaddr()) {
 539             addr = req->getPaddr();
 540             flags.set(VALID_ADDR);
 541         }
 542         if (req->hasSize()) {
 543             size = req->getSize();
 544             flags.set(VALID_SIZE);
 545         }
 546     }
 547
 548     /**
 549      * Alternate constructor if you are trying to create a packet with
 550      * a request that is for a whole block, not the address from the
 551      * req.  this allows for overriding the size/addr of the req.
 552      */
 553     Packet(Request *_req, MemCmd _cmd, int _blkSize)
 554         :  cmd(_cmd), req(_req), data(NULL),
 555            bytesValidStart(0), bytesValidEnd(0),
 556            time(curTick()), senderState(NULL)
 557     {
 558         if (req->hasPaddr()) {
 559             addr = req->getPaddr() & ~(_blkSize - 1);
 560             flags.set(VALID_ADDR);
 561         }
 562         size = _blkSize;
 563         flags.set(VALID_SIZE);
 564     }
 565
 566     /**
 567      * Alternate constructor for copying a packet.  Copy all fields
 568      * *except* if the original packet's data was dynamic, don't copy
 569      * that, as we can't guarantee that the new packet's lifetime is
 570      * less than that of the original packet.  In this case the new
 571      * packet should allocate its own data.
 572      */
 573     Packet(Packet *pkt, bool clearFlags = false)
 574         :  cmd(pkt->cmd), req(pkt->req),
 575            data(pkt->flags.isSet(STATIC_DATA) ? pkt->data : NULL),
 576            addr(pkt->addr), size(pkt->size), src(pkt->src), dest(pkt->dest),
 577            bytesValidStart(pkt->bytesValidStart), bytesValidEnd(pkt->bytesValidEnd),
 578            time(curTick()), senderState(pkt->senderState)
 579     {
 580         if (!clearFlags)
 581             flags.set(pkt->flags & COPY_FLAGS);
 582
 583         flags.set(pkt->flags & (VALID_ADDR|VALID_SIZE|VALID_SRC|VALID_DST));
 584         flags.set(pkt->flags & STATIC_DATA);
 585
 586     }
 587
 588     /**
 589      * clean up packet variables
 590      */
 591     ~Packet()
 592     {
 593         // If this is a request packet for which there's no response,
 594         // delete the request object here, since the requester will
 595         // never get the chance.
 596         if (req && isRequest() && !needsResponse())
 597             delete req;
 598         deleteData();
 599     }
 600
 601     /**
 602      * Reinitialize packet address and size from the associated
 603      * Request object, and reset other fields that may have been
 604      * modified by a previous transaction.  Typically called when a
 605      * statically allocated Request/Packet pair is reused for multiple
 606      * transactions.
 607      */
 608     void
 609     reinitFromRequest()
 610     {
 611         assert(req->hasPaddr());
 612         flags = 0;
 613         addr = req->getPaddr();
 614         size = req->getSize();
 615         time = req->time();
 616
 617         flags.set(VALID_ADDR|VALID_SIZE);
 618         deleteData();
 619     }
 620
 621     /**
 622      * Take a request packet and modify it in place to be suitable for
 623      * returning as a response to that request.  The source and
 624      * destination fields are *not* modified, as is appropriate for
 625      * atomic accesses.
 626      */
 627     void
 628     makeResponse()
 629     {
 630         assert(needsResponse());
 631         assert(isRequest());
 632         origCmd = cmd;
 633         cmd = cmd.responseCommand();
 634
 635         // responses are never express, even if the snoop that
 636         // triggered them was
 637         flags.clear(EXPRESS_SNOOP);
 638
 639         dest = src;
 640         flags.set(VALID_DST, flags.isSet(VALID_SRC));
 641         flags.clear(VALID_SRC);
 642     }
 643
 644     void
 645     makeAtomicResponse()
 646     {
 647         makeResponse();
 648     }
 649
 650     void
 651     makeTimingResponse()
 652     {
 653         makeResponse();
 654     }
 655
 656     void
 657     setFunctionalResponseStatus(bool success)
 658     {
 659         if (!success) {
 660             if (isWrite()) {
 661                 cmd = MemCmd::FunctionalWriteError;
 662             } else {
 663                 cmd = MemCmd::FunctionalReadError;
 664             }
 665         }
 666     }
 667
 668     /**
 669      * Take a request packet that has been returned as NACKED and
 670      * modify it so that it can be sent out again. Only packets that
 671      * need a response can be NACKED, so verify that that is true.
 672      */
 673     void
 674     reinitNacked()
 675     {
 676         assert(wasNacked());
 677         cmd = origCmd;
 678         assert(needsResponse());
 679         clearDest();
 680     }
 681
 682     void
 683     setSize(unsigned size)
 684     {
 685         assert(!flags.isSet(VALID_SIZE));
 686
 687         this->size = size;
 688         flags.set(VALID_SIZE);
 689     }
 690
 691
 692     /**
 693      * Set the data pointer to the following value that should not be
 694      * freed.
 695      */
 696     template <typename T>
 697     void
 698     dataStatic(T *p)
 699     {
 700         assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA));
 701         data = (PacketDataPtr)p;
 702         flags.set(STATIC_DATA);
 703     }
 704
 705     /**
 706      * Set the data pointer to a value that should have delete []
 707      * called on it.
 708      */
 709     template <typename T>
 710     void
 711     dataDynamicArray(T *p)
 712     {
 713         assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA));
 714         data = (PacketDataPtr)p;
 715         flags.set(DYNAMIC_DATA|ARRAY_DATA);
 716     }
 717
 718     /**
 719      * set the data pointer to a value that should have delete called
 720      * on it.
 721      */
 722     template <typename T>
 723     void
 724     dataDynamic(T *p)
 725     {
 726         assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA));
 727         data = (PacketDataPtr)p;
 728         flags.set(DYNAMIC_DATA);
 729     }
 730
 731     /**
 732      * get a pointer to the data ptr.
 733      */
 734     template <typename T>
 735     T*
 736     getPtr(bool null_ok = false)
 737     {
 738         assert(null_ok || flags.isSet(STATIC_DATA|DYNAMIC_DATA));
 739         return (T*)data;
 740     }
 741
 742     /**
 743      * return the value of what is pointed to in the packet.
 744      */
 745     template <typename T>
 746     T get();
 747
 748     /**
 749      * set the value in the data pointer to v.
 750      */
 751     template <typename T>
 752     void set(T v);
 753
 754     /**
 755      * Copy data into the packet from the provided pointer.
 756      */
 757     void
 758     setData(uint8_t *p)
 759     {
 760         if (p != getPtr<uint8_t>())
 761             std::memcpy(getPtr<uint8_t>(), p, getSize());
 762     }
 763
 764     /**
 765      * Copy data into the packet from the provided block pointer,
 766      * which is aligned to the given block size.
 767      */
 768     void
 769     setDataFromBlock(uint8_t *blk_data, int blkSize)
 770     {
 771         setData(blk_data + getOffset(blkSize));
 772     }
 773
 774     /**
 775      * Copy data from the packet to the provided block pointer, which
 776      * is aligned to the given block size.
 777      */
 778     void
 779     writeData(uint8_t *p)
 780     {
 781         std::memcpy(p, getPtr<uint8_t>(), getSize());
 782     }
 783
 784     /**
 785      * Copy data from the packet to the memory at the provided pointer.
 786      */
 787     void
 788     writeDataToBlock(uint8_t *blk_data, int blkSize)
 789     {
 790         writeData(blk_data + getOffset(blkSize));
 791     }
 792
 793     /**
 794      * delete the data pointed to in the data pointer. Ok to call to
 795      * matter how data was allocted.
 796      */
 797     void
 798     deleteData()
 799     {
 800         if (flags.isSet(ARRAY_DATA))
 801             delete [] data;
 802         else if (flags.isSet(DYNAMIC_DATA))
 803             delete data;
 804
 805         flags.clear(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA);
 806         data = NULL;
 807     }
 808
 809     /** If there isn't data in the packet, allocate some. */
 810     void
 811     allocate()
 812     {
 813         if (data) {
 814             assert(flags.isSet(STATIC_DATA|DYNAMIC_DATA));
 815             return;
 816         }
 817
 818         assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
 819         flags.set(DYNAMIC_DATA|ARRAY_DATA);
 820         data = new uint8_t[getSize()];
 821     }
 822
 823     /**
 824      * Check a functional request against a memory value represented
 825      * by a base/size pair and an associated data array.  If the
 826      * functional request is a read, it may be satisfied by the memory
 827      * value.  If the functional request is a write, it may update the
 828      * memory value.
 829      */
 830     bool checkFunctional(Printable *obj, Addr base, int size, uint8_t *data);
 831
 832     /**
 833      * Check a functional request against a memory value stored in
 834      * another packet (i.e. an in-transit request or response).
 835      */
 836     bool
 837     checkFunctional(PacketPtr other)
 838     {
 839         uint8_t *data = other->hasData() ? other->getPtr<uint8_t>() : NULL;
 840         return checkFunctional(other, other->getAddr(), other->getSize(),
 841                                data);
 842     }
 843
 844     /**
 845      * Push label for PrintReq (safe to call unconditionally).
 846      */
 847     void
 848     pushLabel(const std::string &lbl)
 849     {
 850         if (isPrint())
 851             safe_cast<PrintReqState*>(senderState)->pushLabel(lbl);
 852     }
 853
 854     /**
 855      * Pop label for PrintReq (safe to call unconditionally).
 856      */
 857     void
 858     popLabel()
 859     {
 860         if (isPrint())
 861             safe_cast<PrintReqState*>(senderState)->popLabel();
 862     }
 863
 864     void print(std::ostream &o, int verbosity = 0,
 865                const std::string &prefix = "") const;
 866 };
 867
 868 #endif //__MEM_PACKET_HH