src/mem/bridge.cc

   1
   2 /*
   3  * Copyright (c) 2006 The Regents of The University of Michigan
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are
   8  * met: redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer;
  10  * redistributions in binary form must reproduce the above copyright
  11  * notice, this list of conditions and the following disclaimer in the
  12  * documentation and/or other materials provided with the distribution;
  13  * neither the name of the copyright holders nor the names of its
  14  * contributors may be used to endorse or promote products derived from
  15  * this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * Authors: Ali Saidi
  30  *          Steve Reinhardt
  31  */
  32
  33 /**
  34  * @file
  35  * Definition of a simple bus bridge without buffering.
  36  */
  37
  38 #include <algorithm>
  39
  40 #include "base/trace.hh"
  41 #include "mem/bridge.hh"
  42 #include "sim/builder.hh"
  43
  44 Bridge::BridgePort::BridgePort(const std::string &_name,
  45                                Bridge *_bridge, BridgePort *_otherPort,
  46                                int _delay, int _nack_delay, int _req_limit,
  47                                int _resp_limit, bool fix_partial_write)
  48     : Port(_name), bridge(_bridge), otherPort(_otherPort),
  49       delay(_delay), nackDelay(_nack_delay), fixPartialWrite(fix_partial_write),
  50       outstandingResponses(0), queuedRequests(0), inRetry(false),
  51       reqQueueLimit(_req_limit), respQueueLimit(_resp_limit), sendEvent(this)
  52 {
  53 }
  54
  55 Bridge::Bridge(Params *p)
  56     : MemObject(p->name),
  57       portA(p->name + "-portA", this, &portB, p->delay, p->nack_delay,
  58               p->req_size_a, p->resp_size_a, p->fix_partial_write_a),
  59       portB(p->name + "-portB", this, &portA, p->delay, p->nack_delay,
  60               p->req_size_b, p->resp_size_b, p->fix_partial_write_b),
  61       ackWrites(p->write_ack), _params(p)
  62 {
  63     if (ackWrites)
  64         panic("No support for acknowledging writes\n");
  65 }
  66
  67 Port *
  68 Bridge::getPort(const std::string &if_name, int idx)
  69 {
  70     BridgePort *port;
  71
  72     if (if_name == "side_a")
  73         port = &portA;
  74     else if (if_name == "side_b")
  75         port = &portB;
  76     else
  77         return NULL;
  78
  79     if (port->getPeer() != NULL)
  80         panic("bridge side %s already connected to.", if_name);
  81     return port;
  82 }
  83
  84
  85 void
  86 Bridge::init()
  87 {
  88     // Make sure that both sides are connected to.
  89     if (portA.getPeer() == NULL || portB.getPeer() == NULL)
  90         fatal("Both ports of bus bridge are not connected to a bus.\n");
  91
  92     if (portA.peerBlockSize() != portB.peerBlockSize())
  93         fatal("Busses don't have the same block size... Not supported.\n");
  94 }
  95
  96 bool
  97 Bridge::BridgePort::respQueueFull()
  98 {
  99     assert(outstandingResponses >= 0 && outstandingResponses <= respQueueLimit);
 100     return outstandingResponses >= respQueueLimit;
 101 }
 102
 103 bool
 104 Bridge::BridgePort::reqQueueFull()
 105 {
 106     assert(queuedRequests >= 0 && queuedRequests <= reqQueueLimit);
 107     return queuedRequests >= reqQueueLimit;
 108 }
 109
 110 /** Function called by the port when the bus is receiving a Timing
 111  * transaction.*/
 112 bool
 113 Bridge::BridgePort::recvTiming(PacketPtr pkt)
 114 {
 115     if (!(pkt->flags & SNOOP_COMMIT))
 116         return true;
 117
 118
 119     DPRINTF(BusBridge, "recvTiming: src %d dest %d addr 0x%x\n",
 120                 pkt->getSrc(), pkt->getDest(), pkt->getAddr());
 121
 122     DPRINTF(BusBridge, "Local queue size: %d outreq: %d outresp: %d\n",
 123                     sendQueue.size(), queuedRequests, outstandingResponses);
 124     DPRINTF(BusBridge, "Remove queue size: %d outreq: %d outresp: %d\n",
 125                     otherPort->sendQueue.size(), otherPort->queuedRequests,
 126                     otherPort->outstandingResponses);
 127
 128     if (pkt->isRequest() && otherPort->reqQueueFull() && pkt->result !=
 129             Packet::Nacked) {
 130         DPRINTF(BusBridge, "Remote queue full, nacking\n");
 131         nackRequest(pkt);
 132         return true;
 133     }
 134
 135     if (pkt->needsResponse() && pkt->result != Packet::Nacked)
 136         if (respQueueFull()) {
 137             DPRINTF(BusBridge, "Local queue full, no space for response, nacking\n");
 138             DPRINTF(BusBridge, "queue size: %d outreq: %d outstanding resp: %d\n",
 139                     sendQueue.size(), queuedRequests, outstandingResponses);
 140             nackRequest(pkt);
 141             return true;
 142         } else {
 143             DPRINTF(BusBridge, "Request Needs response, reserving space\n");
 144             ++outstandingResponses;
 145         }
 146
 147     otherPort->queueForSendTiming(pkt);
 148
 149     return true;
 150 }
 151
 152 void
 153 Bridge::BridgePort::nackRequest(PacketPtr pkt)
 154 {
 155     // Nack the packet
 156     pkt->result = Packet::Nacked;
 157     pkt->setDest(pkt->getSrc());
 158
 159     //put it on the list to send
 160     Tick readyTime = curTick + nackDelay;
 161     PacketBuffer *buf = new PacketBuffer(pkt, readyTime, true);
 162
 163     // nothing on the list, add it and we're done
 164     if (sendQueue.empty()) {
 165         assert(!sendEvent.scheduled());
 166         sendEvent.schedule(readyTime);
 167         sendQueue.push_back(buf);
 168         return;
 169     }
 170
 171     assert(sendEvent.scheduled() || inRetry);
 172
 173     // does it go at the end?
 174     if (readyTime >= sendQueue.back()->ready) {
 175         sendQueue.push_back(buf);
 176         return;
 177     }
 178
 179     // ok, somewhere in the middle, fun
 180     std::list<PacketBuffer*>::iterator i = sendQueue.begin();
 181     std::list<PacketBuffer*>::iterator end = sendQueue.end();
 182     std::list<PacketBuffer*>::iterator begin = sendQueue.begin();
 183     bool done = false;
 184
 185     while (i != end && !done) {
 186         if (readyTime < (*i)->ready) {
 187             if (i == begin)
 188                 sendEvent.reschedule(readyTime);
 189             sendQueue.insert(i,buf);
 190             done = true;
 191         }
 192         i++;
 193     }
 194     assert(done);
 195 }
 196
 197
 198 void
 199 Bridge::BridgePort::queueForSendTiming(PacketPtr pkt)
 200 {
 201     if (pkt->isResponse() || pkt->result == Packet::Nacked) {
 202         // This is a response for a request we forwarded earlier.  The
 203         // corresponding PacketBuffer should be stored in the packet's
 204         // senderState field.
 205         PacketBuffer *buf = dynamic_cast<PacketBuffer*>(pkt->senderState);
 206         assert(buf != NULL);
 207         // set up new packet dest & senderState based on values saved
 208         // from original request
 209         buf->fixResponse(pkt);
 210
 211         // Check if this packet was expecting a response and it's a nacked
 212         // packet, in which case we will never being seeing it
 213         if (buf->expectResponse && pkt->result == Packet::Nacked)
 214             --outstandingResponses;
 215
 216         DPRINTF(BusBridge, "response, new dest %d\n", pkt->getDest());
 217         delete buf;
 218     }
 219
 220
 221     if (pkt->isRequest() && pkt->result != Packet::Nacked) {
 222         ++queuedRequests;
 223     }
 224
 225
 226
 227     Tick readyTime = curTick + delay;
 228     PacketBuffer *buf = new PacketBuffer(pkt, readyTime);
 229
 230     // If we're about to put this packet at the head of the queue, we
 231     // need to schedule an event to do the transmit.  Otherwise there
 232     // should already be an event scheduled for sending the head
 233     // packet.
 234     if (sendQueue.empty()) {
 235         sendEvent.schedule(readyTime);
 236     }
 237     sendQueue.push_back(buf);
 238 }
 239
 240 void
 241 Bridge::BridgePort::trySend()
 242 {
 243     assert(!sendQueue.empty());
 244
 245     PacketBuffer *buf = sendQueue.front();
 246
 247     assert(buf->ready <= curTick);
 248
 249     PacketPtr pkt = buf->pkt;
 250
 251     pkt->flags &= ~SNOOP_COMMIT; //CLear it if it was set
 252
 253     // Ugly! @todo When multilevel coherence works this will be removed
 254     if (pkt->cmd == MemCmd::WriteInvalidateReq && fixPartialWrite &&
 255             pkt->result != Packet::Nacked) {
 256         PacketPtr funcPkt = new Packet(pkt->req, MemCmd::WriteReq,
 257                             Packet::Broadcast);
 258         funcPkt->dataStatic(pkt->getPtr<uint8_t>());
 259         sendFunctional(funcPkt);
 260         pkt->cmd = MemCmd::WriteReq;
 261         delete funcPkt;
 262     }
 263
 264     DPRINTF(BusBridge, "trySend: origSrc %d dest %d addr 0x%x\n",
 265             buf->origSrc, pkt->getDest(), pkt->getAddr());
 266
 267     bool wasReq = pkt->isRequest();
 268     bool wasNacked = pkt->result == Packet::Nacked;
 269
 270     if (sendTiming(pkt)) {
 271         // send successful
 272         sendQueue.pop_front();
 273         buf->pkt = NULL; // we no longer own packet, so it's not safe to look at it
 274
 275         if (buf->expectResponse) {
 276             // Must wait for response
 277             DPRINTF(BusBridge, "  successful: awaiting response (%d)\n",
 278                     outstandingResponses);
 279         } else {
 280             // no response expected... deallocate packet buffer now.
 281             DPRINTF(BusBridge, "  successful: no response expected\n");
 282             delete buf;
 283         }
 284
 285         if (!wasNacked) {
 286             if (wasReq)
 287                 --queuedRequests;
 288             else
 289                 --outstandingResponses;
 290         }
 291
 292         // If there are more packets to send, schedule event to try again.
 293         if (!sendQueue.empty()) {
 294             buf = sendQueue.front();
 295             DPRINTF(BusBridge, "Scheduling next send\n");
 296             sendEvent.schedule(std::max(buf->ready, curTick + 1));
 297         }
 298     } else {
 299         DPRINTF(BusBridge, "  unsuccessful\n");
 300         inRetry = true;
 301     }
 302     DPRINTF(BusBridge, "trySend: queue size: %d outreq: %d outstanding resp: %d\n",
 303                     sendQueue.size(), queuedRequests, outstandingResponses);
 304 }
 305
 306
 307 void
 308 Bridge::BridgePort::recvRetry()
 309 {
 310     inRetry = false;
 311     Tick nextReady = sendQueue.front()->ready;
 312     if (nextReady <= curTick)
 313         trySend();
 314     else
 315         sendEvent.schedule(nextReady);
 316 }
 317
 318 /** Function called by the port when the bus is receiving a Atomic
 319  * transaction.*/
 320 Tick
 321 Bridge::BridgePort::recvAtomic(PacketPtr pkt)
 322 {
 323     // fix partial atomic writes... similar to the timing code that does the
 324     // same... will be removed once our code gets this right
 325     if (pkt->cmd == MemCmd::WriteInvalidateReq && fixPartialWrite) {
 326
 327         PacketPtr funcPkt = new Packet(pkt->req, MemCmd::WriteReq,
 328                          Packet::Broadcast);
 329         funcPkt->dataStatic(pkt->getPtr<uint8_t>());
 330         otherPort->sendFunctional(funcPkt);
 331         delete funcPkt;
 332         pkt->cmd = MemCmd::WriteReq;
 333     }
 334     return delay + otherPort->sendAtomic(pkt);
 335 }
 336
 337 /** Function called by the port when the bus is receiving a Functional
 338  * transaction.*/
 339 void
 340 Bridge::BridgePort::recvFunctional(PacketPtr pkt)
 341 {
 342     std::list<PacketBuffer*>::iterator i;
 343     bool pktContinue = true;
 344
 345     for (i = sendQueue.begin();  i != sendQueue.end(); ++i) {
 346         if (pkt->intersect((*i)->pkt)) {
 347             pktContinue &= fixPacket(pkt, (*i)->pkt);
 348         }
 349     }
 350
 351     if (pktContinue) {
 352         otherPort->sendFunctional(pkt);
 353     }
 354 }
 355
 356 /** Function called by the port when the bus is receiving a status change.*/
 357 void
 358 Bridge::BridgePort::recvStatusChange(Port::Status status)
 359 {
 360     otherPort->sendStatusChange(status);
 361 }
 362
 363 void
 364 Bridge::BridgePort::getDeviceAddressRanges(AddrRangeList &resp,
 365                                            bool &snoop)
 366 {
 367     otherPort->getPeerAddressRanges(resp, snoop);
 368 }
 369
 370 BEGIN_DECLARE_SIM_OBJECT_PARAMS(Bridge)
 371
 372    Param<int> req_size_a;
 373    Param<int> req_size_b;
 374    Param<int> resp_size_a;
 375    Param<int> resp_size_b;
 376    Param<Tick> delay;
 377    Param<Tick> nack_delay;
 378    Param<bool> write_ack;
 379    Param<bool> fix_partial_write_a;
 380    Param<bool> fix_partial_write_b;
 381
 382 END_DECLARE_SIM_OBJECT_PARAMS(Bridge)
 383
 384 BEGIN_INIT_SIM_OBJECT_PARAMS(Bridge)
 385
 386     INIT_PARAM(req_size_a, "The size of the queue for requests coming into side a"),
 387     INIT_PARAM(req_size_b, "The size of the queue for requests coming into side b"),
 388     INIT_PARAM(resp_size_a, "The size of the queue for responses coming into side a"),
 389     INIT_PARAM(resp_size_b, "The size of the queue for responses coming into side b"),
 390     INIT_PARAM(delay, "The miminum delay to cross this bridge"),
 391     INIT_PARAM(nack_delay, "The minimum delay to nack a packet"),
 392     INIT_PARAM(write_ack, "Acknowledge any writes that are received."),
 393     INIT_PARAM(fix_partial_write_a, "Fixup any partial block writes that are received"),
 394     INIT_PARAM(fix_partial_write_b, "Fixup any partial block writes that are received")
 395
 396 END_INIT_SIM_OBJECT_PARAMS(Bridge)
 397
 398 CREATE_SIM_OBJECT(Bridge)
 399 {
 400     Bridge::Params *p = new Bridge::Params;
 401     p->name = getInstanceName();
 402     p->req_size_a = req_size_a;
 403     p->req_size_b = req_size_b;
 404     p->resp_size_a = resp_size_a;
 405     p->resp_size_b = resp_size_b;
 406     p->delay = delay;
 407     p->nack_delay = nack_delay;
 408     p->write_ack = write_ack;
 409     p->fix_partial_write_a = fix_partial_write_a;
 410     p->fix_partial_write_b = fix_partial_write_b;
 411     return new Bridge(p);
 412 }
 413
 414 REGISTER_SIM_OBJECT("Bridge", Bridge)
 415
 416