src/mem/bridge.cc

   1 /*
   2  * Copyright (c) 2011-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  * All rights reserved.
  16  *
  17  * Redistribution and use in source and binary forms, with or without
  18  * modification, are permitted provided that the following conditions are
  19  * met: redistributions of source code must retain the above copyright
  20  * notice, this list of conditions and the following disclaimer;
  21  * redistributions in binary form must reproduce the above copyright
  22  * notice, this list of conditions and the following disclaimer in the
  23  * documentation and/or other materials provided with the distribution;
  24  * neither the name of the copyright holders nor the names of its
  25  * contributors may be used to endorse or promote products derived from
  26  * this software without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  29  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  30  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  31  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  32  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  33  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  34  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  35  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  36  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  37  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  38  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  39  *
  40  * Authors: Ali Saidi
  41  *          Steve Reinhardt
  42  *          Andreas Hansson
  43  */
  44
  45 /**
  46  * @file
  47  * Implementation of a memory-mapped bus bridge that connects a master
  48  * and a slave through a request and response queue.
  49  */
  50
  51 #include "base/trace.hh"
  52 #include "debug/Bridge.hh"
  53 #include "mem/bridge.hh"
  54 #include "params/Bridge.hh"
  55
  56 Bridge::BridgeSlavePort::BridgeSlavePort(const std::string& _name,
  57                                          Bridge& _bridge,
  58                                          BridgeMasterPort& _masterPort,
  59                                          Cycles _delay, int _resp_limit,
  60                                          std::vector<Range<Addr> > _ranges)
  61     : SlavePort(_name, &_bridge), bridge(_bridge), masterPort(_masterPort),
  62       delay(_delay), ranges(_ranges.begin(), _ranges.end()),
  63       outstandingResponses(0), retryReq(false),
  64       respQueueLimit(_resp_limit), sendEvent(*this)
  65 {
  66 }
  67
  68 Bridge::BridgeMasterPort::BridgeMasterPort(const std::string& _name,
  69                                            Bridge& _bridge,
  70                                            BridgeSlavePort& _slavePort,
  71                                            Cycles _delay, int _req_limit)
  72     : MasterPort(_name, &_bridge), bridge(_bridge), slavePort(_slavePort),
  73       delay(_delay), reqQueueLimit(_req_limit), sendEvent(*this)
  74 {
  75 }
  76
  77 Bridge::Bridge(Params *p)
  78     : MemObject(p),
  79       slavePort(p->name + ".slave", *this, masterPort,
  80                 ticksToCycles(p->delay), p->resp_size, p->ranges),
  81       masterPort(p->name + ".master", *this, slavePort,
  82                  ticksToCycles(p->delay), p->req_size)
  83 {
  84 }
  85
  86 MasterPort&
  87 Bridge::getMasterPort(const std::string &if_name, int idx)
  88 {
  89     if (if_name == "master")
  90         return masterPort;
  91     else
  92         // pass it along to our super class
  93         return MemObject::getMasterPort(if_name, idx);
  94 }
  95
  96 SlavePort&
  97 Bridge::getSlavePort(const std::string &if_name, int idx)
  98 {
  99     if (if_name == "slave")
 100         return slavePort;
 101     else
 102         // pass it along to our super class
 103         return MemObject::getSlavePort(if_name, idx);
 104 }
 105
 106 void
 107 Bridge::init()
 108 {
 109     // make sure both sides are connected and have the same block size
 110     if (!slavePort.isConnected() || !masterPort.isConnected())
 111         fatal("Both ports of bus bridge are not connected to a bus.\n");
 112
 113     if (slavePort.peerBlockSize() != masterPort.peerBlockSize())
 114         fatal("Slave port size %d, master port size %d \n " \
 115               "Busses don't have the same block size... Not supported.\n",
 116               slavePort.peerBlockSize(), masterPort.peerBlockSize());
 117
 118     // notify the master side  of our address ranges
 119     slavePort.sendRangeChange();
 120 }
 121
 122 bool
 123 Bridge::BridgeSlavePort::respQueueFull()
 124 {
 125     return outstandingResponses == respQueueLimit;
 126 }
 127
 128 bool
 129 Bridge::BridgeMasterPort::reqQueueFull()
 130 {
 131     return transmitList.size() == reqQueueLimit;
 132 }
 133
 134 bool
 135 Bridge::BridgeMasterPort::recvTimingResp(PacketPtr pkt)
 136 {
 137     // all checks are done when the request is accepted on the slave
 138     // side, so we are guaranteed to have space for the response
 139     DPRINTF(Bridge, "recvTimingResp: %s addr 0x%x\n",
 140             pkt->cmdString(), pkt->getAddr());
 141
 142     DPRINTF(Bridge, "Request queue size: %d\n", transmitList.size());
 143
 144     slavePort.schedTimingResp(pkt, bridge.clockEdge(delay));
 145
 146     return true;
 147 }
 148
 149 bool
 150 Bridge::BridgeSlavePort::recvTimingReq(PacketPtr pkt)
 151 {
 152     DPRINTF(Bridge, "recvTimingReq: %s addr 0x%x\n",
 153             pkt->cmdString(), pkt->getAddr());
 154
 155     // ensure we do not have something waiting to retry
 156     if(retryReq)
 157         return false;
 158
 159     DPRINTF(Bridge, "Response queue size: %d outresp: %d\n",
 160             transmitList.size(), outstandingResponses);
 161
 162     if (masterPort.reqQueueFull()) {
 163         DPRINTF(Bridge, "Request queue full\n");
 164         retryReq = true;
 165     } else if (pkt->needsResponse()) {
 166         if (respQueueFull()) {
 167             DPRINTF(Bridge, "Response queue full\n");
 168             retryReq = true;
 169         } else {
 170             DPRINTF(Bridge, "Reserving space for response\n");
 171             assert(outstandingResponses != respQueueLimit);
 172             ++outstandingResponses;
 173             retryReq = false;
 174             masterPort.schedTimingReq(pkt, bridge.clockEdge(delay));
 175         }
 176     }
 177
 178     // remember that we are now stalling a packet and that we have to
 179     // tell the sending master to retry once space becomes available,
 180     // we make no distinction whether the stalling is due to the
 181     // request queue or response queue being full
 182     return !retryReq;
 183 }
 184
 185 void
 186 Bridge::BridgeSlavePort::retryStalledReq()
 187 {
 188     if (retryReq) {
 189         DPRINTF(Bridge, "Request waiting for retry, now retrying\n");
 190         retryReq = false;
 191         sendRetry();
 192     }
 193 }
 194
 195 void
 196 Bridge::BridgeMasterPort::schedTimingReq(PacketPtr pkt, Tick when)
 197 {
 198     // If we expect to see a response, we need to restore the source
 199     // and destination field that is potentially changed by a second
 200     // bus
 201     if (!pkt->memInhibitAsserted() && pkt->needsResponse()) {
 202         // Update the sender state so we can deal with the response
 203         // appropriately
 204         RequestState *req_state = new RequestState(pkt);
 205         pkt->senderState = req_state;
 206     }
 207
 208     // If we're about to put this packet at the head of the queue, we
 209     // need to schedule an event to do the transmit.  Otherwise there
 210     // should already be an event scheduled for sending the head
 211     // packet.
 212     if (transmitList.empty()) {
 213         bridge.schedule(sendEvent, when);
 214     }
 215
 216     assert(transmitList.size() != reqQueueLimit);
 217
 218     transmitList.push_back(DeferredPacket(pkt, when));
 219 }
 220
 221
 222 void
 223 Bridge::BridgeSlavePort::schedTimingResp(PacketPtr pkt, Tick when)
 224 {
 225     // This is a response for a request we forwarded earlier.  The
 226     // corresponding request state should be stored in the packet's
 227     // senderState field.
 228     RequestState *req_state = dynamic_cast<RequestState*>(pkt->senderState);
 229     assert(req_state != NULL);
 230     // set up new packet dest & senderState based on values saved
 231     // from original request
 232     req_state->fixResponse(pkt);
 233     delete req_state;
 234
 235     // the bridge assumes that at least one bus has set the
 236     // destination field of the packet
 237     assert(pkt->isDestValid());
 238     DPRINTF(Bridge, "response, new dest %d\n", pkt->getDest());
 239
 240     // If we're about to put this packet at the head of the queue, we
 241     // need to schedule an event to do the transmit.  Otherwise there
 242     // should already be an event scheduled for sending the head
 243     // packet.
 244     if (transmitList.empty()) {
 245         bridge.schedule(sendEvent, when);
 246     }
 247
 248     transmitList.push_back(DeferredPacket(pkt, when));
 249 }
 250
 251 void
 252 Bridge::BridgeMasterPort::trySendTiming()
 253 {
 254     assert(!transmitList.empty());
 255
 256     DeferredPacket req = transmitList.front();
 257
 258     assert(req.tick <= curTick());
 259
 260     PacketPtr pkt = req.pkt;
 261
 262     DPRINTF(Bridge, "trySend request addr 0x%x, queue size %d\n",
 263             pkt->getAddr(), transmitList.size());
 264
 265     if (sendTimingReq(pkt)) {
 266         // send successful
 267         transmitList.pop_front();
 268         DPRINTF(Bridge, "trySend request successful\n");
 269
 270         // If there are more packets to send, schedule event to try again.
 271         if (!transmitList.empty()) {
 272             req = transmitList.front();
 273             DPRINTF(Bridge, "Scheduling next send\n");
 274             bridge.schedule(sendEvent, std::max(req.tick,
 275                                                 bridge.nextCycle()));
 276         }
 277
 278         // if we have stalled a request due to a full request queue,
 279         // then send a retry at this point, also note that if the
 280         // request we stalled was waiting for the response queue
 281         // rather than the request queue we might stall it again
 282         slavePort.retryStalledReq();
 283     }
 284
 285     // if the send failed, then we try again once we receive a retry,
 286     // and therefore there is no need to take any action
 287 }
 288
 289 void
 290 Bridge::BridgeSlavePort::trySendTiming()
 291 {
 292     assert(!transmitList.empty());
 293
 294     DeferredPacket resp = transmitList.front();
 295
 296     assert(resp.tick <= curTick());
 297
 298     PacketPtr pkt = resp.pkt;
 299
 300     DPRINTF(Bridge, "trySend response addr 0x%x, outstanding %d\n",
 301             pkt->getAddr(), outstandingResponses);
 302
 303     if (sendTimingResp(pkt)) {
 304         // send successful
 305         transmitList.pop_front();
 306         DPRINTF(Bridge, "trySend response successful\n");
 307
 308         assert(outstandingResponses != 0);
 309         --outstandingResponses;
 310
 311         // If there are more packets to send, schedule event to try again.
 312         if (!transmitList.empty()) {
 313             resp = transmitList.front();
 314             DPRINTF(Bridge, "Scheduling next send\n");
 315             bridge.schedule(sendEvent, std::max(resp.tick,
 316                                                 bridge.nextCycle()));
 317         }
 318
 319         // if there is space in the request queue and we were stalling
 320         // a request, it will definitely be possible to accept it now
 321         // since there is guaranteed space in the response queue
 322         if (!masterPort.reqQueueFull() && retryReq) {
 323             DPRINTF(Bridge, "Request waiting for retry, now retrying\n");
 324             retryReq = false;
 325             sendRetry();
 326         }
 327     }
 328
 329     // if the send failed, then we try again once we receive a retry,
 330     // and therefore there is no need to take any action
 331 }
 332
 333 void
 334 Bridge::BridgeMasterPort::recvRetry()
 335 {
 336     Tick nextReady = transmitList.front().tick;
 337     if (nextReady <= curTick())
 338         trySendTiming();
 339     else
 340         bridge.schedule(sendEvent, nextReady);
 341 }
 342
 343 void
 344 Bridge::BridgeSlavePort::recvRetry()
 345 {
 346     Tick nextReady = transmitList.front().tick;
 347     if (nextReady <= curTick())
 348         trySendTiming();
 349     else
 350         bridge.schedule(sendEvent, nextReady);
 351 }
 352
 353 Tick
 354 Bridge::BridgeSlavePort::recvAtomic(PacketPtr pkt)
 355 {
 356     return delay * bridge.clockPeriod() + masterPort.sendAtomic(pkt);
 357 }
 358
 359 void
 360 Bridge::BridgeSlavePort::recvFunctional(PacketPtr pkt)
 361 {
 362     std::list<DeferredPacket>::iterator i;
 363
 364     pkt->pushLabel(name());
 365
 366     // check the response queue
 367     for (i = transmitList.begin();  i != transmitList.end(); ++i) {
 368         if (pkt->checkFunctional((*i).pkt)) {
 369             pkt->makeResponse();
 370             return;
 371         }
 372     }
 373
 374     // also check the master port's request queue
 375     if (masterPort.checkFunctional(pkt)) {
 376         return;
 377     }
 378
 379     pkt->popLabel();
 380
 381     // fall through if pkt still not satisfied
 382     masterPort.sendFunctional(pkt);
 383 }
 384
 385 bool
 386 Bridge::BridgeMasterPort::checkFunctional(PacketPtr pkt)
 387 {
 388     bool found = false;
 389     std::list<DeferredPacket>::iterator i = transmitList.begin();
 390
 391     while(i != transmitList.end() && !found) {
 392         if (pkt->checkFunctional((*i).pkt)) {
 393             pkt->makeResponse();
 394             found = true;
 395         }
 396         ++i;
 397     }
 398
 399     return found;
 400 }
 401
 402 AddrRangeList
 403 Bridge::BridgeSlavePort::getAddrRanges() const
 404 {
 405     return ranges;
 406 }
 407
 408 Bridge *
 409 BridgeParams::create()
 410 {
 411     return new Bridge(this);
 412 }