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     /* ReadResp */
  60     { SET3(IsRead, IsResponse, HasData), InvalidCmd, "ReadResp" },
  61     /* WriteReq */
  62     { SET5(IsWrite, NeedsExclusive, IsRequest, NeedsResponse, HasData),
  63             WriteResp, "WriteReq" },
  64     /* WriteResp */
  65     { SET3(IsWrite, NeedsExclusive, IsResponse), InvalidCmd, "WriteResp" },
  66     /* Writeback */
  67     { SET4(IsWrite, NeedsExclusive, IsRequest, HasData),
  68             InvalidCmd, "Writeback" },
  69     /* SoftPFReq */
  70     { SET4(IsRead, IsRequest, IsSWPrefetch, NeedsResponse),
  71             SoftPFResp, "SoftPFReq" },
  72     /* HardPFReq */
  73     { SET4(IsRead, IsRequest, IsHWPrefetch, NeedsResponse),
  74             HardPFResp, "HardPFReq" },
  75     /* SoftPFResp */
  76     { SET4(IsRead, IsResponse, IsSWPrefetch, HasData),
  77             InvalidCmd, "SoftPFResp" },
  78     /* HardPFResp */
  79     { SET4(IsRead, IsResponse, IsHWPrefetch, HasData),
  80             InvalidCmd, "HardPFResp" },
  81     /* WriteInvalidateReq */
  82     { SET6(IsWrite, NeedsExclusive, IsInvalidate,
  83            IsRequest, HasData, NeedsResponse),
  84             WriteInvalidateResp, "WriteInvalidateReq" },
  85     /* WriteInvalidateResp */
  86     { SET4(IsWrite, NeedsExclusive, IsInvalidate, IsResponse),
  87             InvalidCmd, "WriteInvalidateResp" },
  88     /* UpgradeReq */
  89     { SET4(IsInvalidate, NeedsExclusive, IsRequest, NeedsResponse),
  90             UpgradeResp, "UpgradeReq" },
  91     /* UpgradeResp */
  92     { SET3(IsInvalidate, NeedsExclusive, IsResponse),
  93             InvalidCmd, "UpgradeResp" },
  94     /* ReadExReq */
  95     { SET5(IsRead, NeedsExclusive, IsInvalidate, IsRequest, NeedsResponse),
  96             ReadExResp, "ReadExReq" },
  97     /* ReadExResp */
  98     { SET5(IsRead, NeedsExclusive, IsInvalidate, IsResponse, HasData),
  99             InvalidCmd, "ReadExResp" },
 100     /* LoadLockedReq */
 101     { SET4(IsRead, IsLocked, IsRequest, NeedsResponse),
 102             ReadResp, "LoadLockedReq" },
 103     /* LoadLockedResp */
 104     { SET4(IsRead, IsLocked, IsResponse, HasData),
 105             InvalidCmd, "LoadLockedResp" },
 106     /* StoreCondReq */
 107     { SET6(IsWrite, NeedsExclusive, IsLocked,
 108            IsRequest, NeedsResponse, HasData),
 109             StoreCondResp, "StoreCondReq" },
 110     /* StoreCondResp */
 111     { SET4(IsWrite, NeedsExclusive, IsLocked, IsResponse),
 112             InvalidCmd, "StoreCondResp" },
 113     /* SwapReq -- for Swap ldstub type operations */
 114     { SET6(IsRead, IsWrite, NeedsExclusive, IsRequest, HasData, NeedsResponse),
 115         SwapResp, "SwapReq" },
 116     /* SwapResp -- for Swap ldstub type operations */
 117     { SET5(IsRead, IsWrite, NeedsExclusive, IsResponse, HasData),
 118             InvalidCmd, "SwapResp" },
 119     /* NetworkNackError  -- nacked at network layer (not by protocol) */
 120     { SET2(IsRequest, IsError), InvalidCmd, "NetworkNackError" },
 121     /* InvalidDestError  -- packet dest field invalid */
 122     { SET2(IsRequest, IsError), InvalidCmd, "InvalidDestError" },
 123     /* BadAddressError   -- memory address invalid */
 124     { SET2(IsRequest, IsError), InvalidCmd, "BadAddressError" }
 125 };
 126
 127
 128 /** delete the data pointed to in the data pointer. Ok to call to matter how
 129  * data was allocted. */
 130 void
 131 Packet::deleteData()
 132 {
 133     assert(staticData || dynamicData);
 134     if (staticData)
 135         return;
 136
 137     if (arrayData)
 138         delete [] data;
 139     else
 140         delete data;
 141 }
 142
 143 /** If there isn't data in the packet, allocate some. */
 144 void
 145 Packet::allocate()
 146 {
 147     if (data)
 148         return;
 149     assert(!staticData);
 150     dynamicData = true;
 151     arrayData = true;
 152     data = new uint8_t[getSize()];
 153 }
 154
 155 /** Do the packet modify the same addresses. */
 156 bool
 157 Packet::intersect(PacketPtr p)
 158 {
 159     Addr s1 = getAddr();
 160     Addr e1 = getAddr() + getSize() - 1;
 161     Addr s2 = p->getAddr();
 162     Addr e2 = p->getAddr() + p->getSize() - 1;
 163
 164     return !(s1 > e2 || e1 < s2);
 165 }
 166
 167 bool
 168 fixDelayedResponsePacket(PacketPtr func, PacketPtr timing)
 169 {
 170     bool result;
 171
 172     if (timing->isRead() || timing->isWrite()) {
 173         // Ugly hack to deal with the fact that we queue the requests
 174         // and don't convert them to responses until we issue them on
 175         // the bus.  I tried to avoid this by converting packets to
 176         // responses right away, but this breaks during snoops where a
 177         // responder may do the conversion before other caches have
 178         // done the snoop.  Would work if we copied the packet instead
 179         // of just hanging on to a pointer.
 180         MemCmd oldCmd = timing->cmd;
 181         timing->cmd = timing->cmd.responseCommand();
 182         result = fixPacket(func, timing);
 183         timing->cmd = oldCmd;
 184     }
 185     else {
 186         //Don't toggle if it isn't a read/write response
 187         result = fixPacket(func, timing);
 188     }
 189
 190     return result;
 191 }
 192
 193 bool
 194 Packet::checkFunctional(Addr addr, int size, uint8_t *data)
 195 {
 196     Addr func_start = getAddr();
 197     Addr func_end   = getAddr() + getSize() - 1;
 198     Addr val_start  = addr;
 199     Addr val_end    = val_start + size - 1;
 200
 201     if (func_start > val_end || val_start > func_end) {
 202         // no intersection
 203         return false;
 204     }
 205
 206     // offset of functional request into supplied value (could be
 207     // negative if partial overlap)
 208     int offset = func_start - val_start;
 209
 210     if (isRead()) {
 211         if (func_start >= val_start && func_end <= val_end) {
 212             allocate();
 213             std::memcpy(getPtr<uint8_t>(), data + offset, getSize());
 214             makeResponse();
 215             return true;
 216         } else {
 217             // In this case the timing packet only partially satisfies
 218             // the request, so we would need more information to make
 219             // this work.  Like bytes valid in the packet or
 220             // something, so the request could continue and get this
 221             // bit of possibly newer data along with the older data
 222             // not written to yet.
 223             panic("Memory value only partially satisfies the functional "
 224                   "request. Now what?");
 225         }
 226     } else if (isWrite()) {
 227         if (offset >= 0) {
 228             std::memcpy(data + offset, getPtr<uint8_t>(),
 229                         (std::min(func_end, val_end) - func_start) + 1);
 230         } else { // val_start > func_start
 231             std::memcpy(data, getPtr<uint8_t>() - offset,
 232                         (std::min(func_end, val_end) - val_start) + 1);
 233         }
 234         // we always want to keep going with a write
 235         return false;
 236     } else
 237         panic("Don't know how to handle command %s\n", cmdString());
 238 }
 239
 240
 241 std::ostream &
 242 operator<<(std::ostream &o, const Packet &p)
 243 {
 244
 245     o << "[0x";
 246     o.setf(std::ios_base::hex, std::ios_base::showbase);
 247     o <<  p.getAddr();
 248     o.unsetf(std::ios_base::hex| std::ios_base::showbase);
 249     o <<  ":";
 250     o.setf(std::ios_base::hex, std::ios_base::showbase);
 251     o <<  p.getAddr() + p.getSize() - 1 << "] ";
 252     o.unsetf(std::ios_base::hex| std::ios_base::showbase);
 253
 254     if (p.isRead())
 255         o << "Read ";
 256     if (p.isWrite())
 257         o << "Write ";
 258     if (p.isInvalidate())
 259         o << "Invalidate ";
 260     if (p.isRequest())
 261         o << "Request ";
 262     if (p.isResponse())
 263         o << "Response ";
 264     if (p.hasData())
 265         o << "w/Data ";
 266
 267     o << std::endl;
 268     return o;
 269 }
 270