src/mem/packet.cc

   1 /*
   2  * Copyright (c) 2006 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * Authors: Ali Saidi
  29  *          Steve Reinhardt
  30  */
  31
  32 /**
  33  * @file
  34  * Definition of the Packet Class, a packet is a transaction occuring
  35  * between a single level of the memory heirarchy (ie L1->L2).
  36  */
  37
  38 #include <iostream>
  39 #include <cstring>
  40 #include "base/misc.hh"
  41 #include "base/trace.hh"
  42 #include "mem/packet.hh"
  43
  44 // The one downside to bitsets is that static initializers can get ugly.
  45 #define SET1(a1)                     (1 << (a1))
  46 #define SET2(a1, a2)                 (SET1(a1) | SET1(a2))
  47 #define SET3(a1, a2, a3)             (SET2(a1, a2) | SET1(a3))
  48 #define SET4(a1, a2, a3, a4)         (SET3(a1, a2, a3) | SET1(a4))
  49 #define SET5(a1, a2, a3, a4, a5)     (SET4(a1, a2, a3, a4) | SET1(a5))
  50 #define SET6(a1, a2, a3, a4, a5, a6) (SET5(a1, a2, a3, a4, a5) | SET1(a6))
  51
  52 const MemCmd::CommandInfo
  53 MemCmd::commandInfo[] =
  54 {
  55     /* InvalidCmd */
  56     { 0, InvalidCmd, "InvalidCmd" },
  57     /* ReadReq */
  58     { SET3(IsRead, IsRequest, NeedsResponse), ReadResp, "ReadReq" },
  59     /* WriteReq */
  60     { SET4(IsWrite, IsRequest, NeedsResponse, HasData),
  61             WriteResp, "WriteReq" },
  62     /* WriteReqNoAck */
  63     { SET3(IsWrite, IsRequest, HasData), InvalidCmd, "WriteReqNoAck" },
  64     /* ReadResp */
  65     { SET3(IsRead, IsResponse, HasData), InvalidCmd, "ReadResp" },
  66     /* WriteResp */
  67     { SET2(IsWrite, IsResponse), InvalidCmd, "WriteResp" },
  68     /* Writeback */
  69     { SET3(IsWrite, IsRequest, HasData), InvalidCmd, "Writeback" },
  70     /* SoftPFReq */
  71     { SET4(IsRead, IsRequest, IsSWPrefetch, NeedsResponse),
  72             SoftPFResp, "SoftPFReq" },
  73     /* HardPFReq */
  74     { SET4(IsRead, IsRequest, IsHWPrefetch, NeedsResponse),
  75             HardPFResp, "HardPFReq" },
  76     /* SoftPFResp */
  77     { SET4(IsRead, IsResponse, IsSWPrefetch, HasData),
  78             InvalidCmd, "SoftPFResp" },
  79     /* HardPFResp */
  80     { SET4(IsRead, IsResponse, IsHWPrefetch, HasData),
  81             InvalidCmd, "HardPFResp" },
  82     /* InvalidateReq */
  83     { SET2(IsInvalidate, IsRequest), InvalidCmd, "InvalidateReq" },
  84     /* WriteInvalidateReq */
  85     { SET5(IsWrite, IsInvalidate, IsRequest, HasData, NeedsResponse),
  86             WriteInvalidateResp, "WriteInvalidateReq" },
  87     /* WriteInvalidateResp */
  88     { SET5(IsWrite, IsInvalidate, IsRequest, NeedsResponse, IsResponse),
  89             InvalidCmd, "WriteInvalidateResp" },
  90     /* UpgradeReq */
  91     { SET3(IsInvalidate, IsRequest, IsUpgrade), InvalidCmd, "UpgradeReq" },
  92     /* ReadExReq */
  93     { SET4(IsRead, IsInvalidate, IsRequest, NeedsResponse),
  94             ReadExResp, "ReadExReq" },
  95     /* ReadExResp */
  96     { SET4(IsRead, IsInvalidate, IsResponse, HasData),
  97             InvalidCmd, "ReadExResp" },
  98     /* SwapReq -- for Swap ldstub type operations */
  99     { SET4(IsReadWrite, IsRequest, HasData, NeedsResponse),
 100         SwapResp, "SwapReq" },
 101     /* SwapResp -- for Swap ldstub type operations */
 102     { SET3(IsReadWrite, IsResponse, HasData),
 103         InvalidCmd, "SwapResp" }
 104 };
 105
 106
 107 /** delete the data pointed to in the data pointer. Ok to call to matter how
 108  * data was allocted. */
 109 void
 110 Packet::deleteData()
 111 {
 112     assert(staticData || dynamicData);
 113     if (staticData)
 114         return;
 115
 116     if (arrayData)
 117         delete [] data;
 118     else
 119         delete data;
 120 }
 121
 122 /** If there isn't data in the packet, allocate some. */
 123 void
 124 Packet::allocate()
 125 {
 126     if (data)
 127         return;
 128     assert(!staticData);
 129     dynamicData = true;
 130     arrayData = true;
 131     data = new uint8_t[getSize()];
 132 }
 133
 134 /** Do the packet modify the same addresses. */
 135 bool
 136 Packet::intersect(PacketPtr p)
 137 {
 138     Addr s1 = getAddr();
 139     Addr e1 = getAddr() + getSize() - 1;
 140     Addr s2 = p->getAddr();
 141     Addr e2 = p->getAddr() + p->getSize() - 1;
 142
 143     return !(s1 > e2 || e1 < s2);
 144 }
 145
 146 bool
 147 fixDelayedResponsePacket(PacketPtr func, PacketPtr timing)
 148 {
 149     bool result;
 150
 151     if (timing->isRead() || timing->isWrite()) {
 152         // Ugly hack to deal with the fact that we queue the requests
 153         // and don't convert them to responses until we issue them on
 154         // the bus.  I tried to avoid this by converting packets to
 155         // responses right away, but this breaks during snoops where a
 156         // responder may do the conversion before other caches have
 157         // done the snoop.  Would work if we copied the packet instead
 158         // of just hanging on to a pointer.
 159         MemCmd oldCmd = timing->cmd;
 160         timing->cmd = timing->cmd.responseCommand();
 161         result = fixPacket(func, timing);
 162         timing->cmd = oldCmd;
 163     }
 164     else {
 165         //Don't toggle if it isn't a read/write response
 166         result = fixPacket(func, timing);
 167     }
 168
 169     return result;
 170 }
 171
 172 bool
 173 fixPacket(PacketPtr func, PacketPtr timing)
 174 {
 175     Addr funcStart      = func->getAddr();
 176     Addr funcEnd        = func->getAddr() + func->getSize() - 1;
 177     Addr timingStart    = timing->getAddr();
 178     Addr timingEnd      = timing->getAddr() + timing->getSize() - 1;
 179
 180     assert(!(funcStart > timingEnd || timingStart > funcEnd));
 181
 182     // this packet can't solve our problem, continue on
 183     if (!timing->hasData())
 184         return true;
 185
 186     if (func->isRead()) {
 187         if (funcStart >= timingStart && funcEnd <= timingEnd) {
 188             func->allocate();
 189             std::memcpy(func->getPtr<uint8_t>(), timing->getPtr<uint8_t>() +
 190                     funcStart - timingStart, func->getSize());
 191             func->result = Packet::Success;
 192             func->flags |= SATISFIED;
 193             return false;
 194         } else {
 195             // In this case the timing packet only partially satisfies the
 196             // requset, so we would need more information to make this work.
 197             // Like bytes valid in the packet or something, so the request could
 198             // continue and get this bit of possibly newer data along with the
 199             // older data not written to yet.
 200             panic("Timing packet only partially satisfies the functional"
 201                     "request. Now what?");
 202         }
 203     } else if (func->isWrite()) {
 204         if (funcStart >= timingStart) {
 205             std::memcpy(timing->getPtr<uint8_t>() + (funcStart - timingStart),
 206                    func->getPtr<uint8_t>(),
 207                    (std::min(funcEnd, timingEnd) - funcStart) + 1);
 208         } else { // timingStart > funcStart
 209             std::memcpy(timing->getPtr<uint8_t>(),
 210                    func->getPtr<uint8_t>() + (timingStart - funcStart),
 211                    (std::min(funcEnd, timingEnd) - timingStart) + 1);
 212         }
 213         // we always want to keep going with a write
 214         return true;
 215     } else
 216         panic("Don't know how to handle command type %#x\n",
 217                 func->cmdToIndex());
 218
 219 }
 220
 221
 222 std::ostream &
 223 operator<<(std::ostream &o, const Packet &p)
 224 {
 225
 226     o << "[0x";
 227     o.setf(std::ios_base::hex, std::ios_base::showbase);
 228     o <<  p.getAddr();
 229     o.unsetf(std::ios_base::hex| std::ios_base::showbase);
 230     o <<  ":";
 231     o.setf(std::ios_base::hex, std::ios_base::showbase);
 232     o <<  p.getAddr() + p.getSize() - 1 << "] ";
 233     o.unsetf(std::ios_base::hex| std::ios_base::showbase);
 234
 235     if (p.result == Packet::Success)
 236         o << "Successful ";
 237     if (p.result == Packet::BadAddress)
 238         o << "BadAddress ";
 239     if (p.result == Packet::Nacked)
 240         o << "Nacked ";
 241     if (p.result == Packet::Unknown)
 242         o << "Inflight ";
 243
 244     if (p.isRead())
 245         o << "Read ";
 246     if (p.isWrite())
 247         o << "Write ";
 248     if (p.isReadWrite())
 249         o << "Read/Write ";
 250     if (p.isInvalidate())
 251         o << "Invalidate ";
 252     if (p.isRequest())
 253         o << "Request ";
 254     if (p.isResponse())
 255         o << "Response ";
 256     if (p.hasData())
 257         o << "w/Data ";
 258
 259     o << std::endl;
 260     return o;
 261 }
 262