src/mem/packet.hh

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