src/mem/bus.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  */
  30
  31 /**
  32  * @file
  33  * Definition of a bus object.
  34  */
  35
  36
  37 #include "base/misc.hh"
  38 #include "base/trace.hh"
  39 #include "mem/bus.hh"
  40 #include "sim/builder.hh"
  41
  42 Port *
  43 Bus::getPort(const std::string &if_name, int idx)
  44 {
  45     if (if_name == "default") {
  46         if (defaultPort == NULL) {
  47             defaultPort = new BusPort(csprintf("%s-default",name()), this,
  48                                       defaultId);
  49             return defaultPort;
  50         } else
  51             fatal("Default port already set\n");
  52     }
  53
  54     // if_name ignored?  forced to be empty?
  55     int id = interfaces.size();
  56     BusPort *bp = new BusPort(csprintf("%s-p%d", name(), id), this, id);
  57     interfaces.push_back(bp);
  58     return bp;
  59 }
  60
  61 /** Get the ranges of anyone other buses that we are connected to. */
  62 void
  63 Bus::init()
  64 {
  65     std::vector<BusPort*>::iterator intIter;
  66
  67     for (intIter = interfaces.begin(); intIter != interfaces.end(); intIter++)
  68         (*intIter)->sendStatusChange(Port::RangeChange);
  69 }
  70
  71 Bus::BusFreeEvent::BusFreeEvent(Bus *_bus) : Event(&mainEventQueue), bus(_bus)
  72 {}
  73
  74 void Bus::BusFreeEvent::process()
  75 {
  76     bus->recvRetry(-1);
  77 }
  78
  79 const char * Bus::BusFreeEvent::description()
  80 {
  81     return "bus became available";
  82 }
  83
  84 void Bus::occupyBus(PacketPtr pkt)
  85 {
  86     //Bring tickNextIdle up to the present tick
  87     //There is some potential ambiguity where a cycle starts, which might make
  88     //a difference when devices are acting right around a cycle boundary. Using
  89     //a < allows things which happen exactly on a cycle boundary to take up only
  90     //the following cycle. Anthing that happens later will have to "wait" for
  91     //the end of that cycle, and then start using the bus after that.
  92     while (tickNextIdle < curTick)
  93         tickNextIdle += clock;
  94
  95     // The packet will be sent. Figure out how long it occupies the bus, and
  96     // how much of that time is for the first "word", aka bus width.
  97     int numCycles = 0;
  98     // Requests need one cycle to send an address
  99     if (pkt->isRequest())
 100         numCycles++;
 101     else if (pkt->isResponse() || pkt->hasData()) {
 102         // If a packet has data, it needs ceil(size/width) cycles to send it
 103         // We're using the "adding instead of dividing" trick again here
 104         if (pkt->hasData()) {
 105             int dataSize = pkt->getSize();
 106             for (int transmitted = 0; transmitted < dataSize;
 107                     transmitted += width) {
 108                 numCycles++;
 109             }
 110         } else {
 111             // If the packet didn't have data, it must have been a response.
 112             // Those use the bus for one cycle to send their data.
 113             numCycles++;
 114         }
 115     }
 116
 117     // The first word will be delivered after the current tick, the delivery
 118     // of the address if any, and one bus cycle to deliver the data
 119     pkt->firstWordTime =
 120         tickNextIdle +
 121         pkt->isRequest() ? clock : 0 +
 122         clock;
 123
 124     //Advance it numCycles bus cycles.
 125     //XXX Should this use the repeated addition trick as well?
 126     tickNextIdle += (numCycles * clock);
 127     if (!busIdle.scheduled()) {
 128         busIdle.schedule(tickNextIdle);
 129     } else {
 130         busIdle.reschedule(tickNextIdle);
 131     }
 132     DPRINTF(Bus, "The bus is now occupied from tick %d to %d\n",
 133             curTick, tickNextIdle);
 134
 135     // The bus will become idle once the current packet is delivered.
 136     pkt->finishTime = tickNextIdle;
 137 }
 138
 139 /** Function called by the port when the bus is receiving a Timing
 140  * transaction.*/
 141 bool
 142 Bus::recvTiming(PacketPtr pkt)
 143 {
 144     Port *port;
 145     DPRINTF(Bus, "recvTiming: packet src %d dest %d addr 0x%x cmd %s\n",
 146             pkt->getSrc(), pkt->getDest(), pkt->getAddr(), pkt->cmdString());
 147
 148     BusPort *pktPort;
 149     if (pkt->getSrc() == defaultId)
 150         pktPort = defaultPort;
 151     else pktPort = interfaces[pkt->getSrc()];
 152
 153     // If the bus is busy, or other devices are in line ahead of the current
 154     // one, put this device on the retry list.
 155     if (tickNextIdle > curTick ||
 156             (retryList.size() && (!inRetry || pktPort != retryList.front()))) {
 157         addToRetryList(pktPort);
 158         return false;
 159     }
 160
 161     short dest = pkt->getDest();
 162     if (dest == Packet::Broadcast) {
 163         port = findPort(pkt->getAddr(), pkt->getSrc());
 164         if (timingSnoop(pkt, port ? port : interfaces[pkt->getSrc()])) {
 165             bool success;
 166
 167             pkt->flags |= SNOOP_COMMIT;
 168             success = timingSnoop(pkt, port ? port : interfaces[pkt->getSrc()]);
 169             assert(success);
 170
 171             if (pkt->flags & SATISFIED) {
 172                 //Cache-Cache transfer occuring
 173                 if (inRetry) {
 174                     retryList.front()->onRetryList(false);
 175                     retryList.pop_front();
 176                     inRetry = false;
 177                 }
 178                 occupyBus(pkt);
 179                 return true;
 180             }
 181         } else {
 182             //Snoop didn't succeed
 183             DPRINTF(Bus, "Adding a retry to RETRY list %i\n", pktPort);
 184             addToRetryList(pktPort);
 185             return false;
 186         }
 187     } else {
 188         assert(dest >= 0 && dest < interfaces.size());
 189         assert(dest != pkt->getSrc()); // catch infinite loops
 190         port = interfaces[dest];
 191     }
 192
 193     occupyBus(pkt);
 194
 195     if (port) {
 196         if (port->sendTiming(pkt))  {
 197             // Packet was successfully sent. Return true.
 198             // Also take care of retries
 199             if (inRetry) {
 200                 DPRINTF(Bus, "Remove retry from list %i\n", retryList.front());
 201                 retryList.front()->onRetryList(false);
 202                 retryList.pop_front();
 203                 inRetry = false;
 204             }
 205             return true;
 206         }
 207
 208         // Packet not successfully sent. Leave or put it on the retry list.
 209         DPRINTF(Bus, "Adding a retry to RETRY list %i\n", pktPort);
 210         addToRetryList(pktPort);
 211         return false;
 212     }
 213     else {
 214         //Forwarding up from responder, just return true;
 215         return true;
 216     }
 217 }
 218
 219 void
 220 Bus::recvRetry(int id)
 221 {
 222     DPRINTF(Bus, "Received a retry\n");
 223     // If there's anything waiting, and the bus isn't busy...
 224     if (retryList.size() && curTick >= tickNextIdle) {
 225         //retryingPort = retryList.front();
 226         inRetry = true;
 227         DPRINTF(Bus, "Sending a retry\n");
 228         retryList.front()->sendRetry();
 229         // If inRetry is still true, sendTiming wasn't called
 230         if (inRetry)
 231         {
 232             retryList.front()->onRetryList(false);
 233             retryList.pop_front();
 234             inRetry = false;
 235
 236             //Bring tickNextIdle up to the present
 237             while (tickNextIdle < curTick)
 238                 tickNextIdle += clock;
 239
 240             //Burn a cycle for the missed grant.
 241             tickNextIdle += clock;
 242
 243             if (!busIdle.scheduled()) {
 244                 busIdle.schedule(tickNextIdle);
 245             } else {
 246                 busIdle.reschedule(tickNextIdle);
 247             }
 248         }
 249     }
 250     //If we weren't able to drain before, we might be able to now.
 251     if (drainEvent && retryList.size() == 0 && curTick >= tickNextIdle) {
 252         drainEvent->process();
 253         // Clear the drain event once we're done with it.
 254         drainEvent = NULL;
 255     }
 256 }
 257
 258 Port *
 259 Bus::findPort(Addr addr, int id)
 260 {
 261     /* An interval tree would be a better way to do this. --ali. */
 262     int dest_id = -1;
 263     int i = 0;
 264     bool found = false;
 265     AddrRangeIter iter;
 266
 267     while (i < portList.size() && !found)
 268     {
 269         if (portList[i].range == addr) {
 270             dest_id = portList[i].portId;
 271             found = true;
 272             DPRINTF(Bus, "  found addr %#llx on device %d\n", addr, dest_id);
 273         }
 274         i++;
 275     }
 276
 277     // Check if this matches the default range
 278     if (dest_id == -1) {
 279         for (iter = defaultRange.begin(); iter != defaultRange.end(); iter++) {
 280             if (*iter == addr) {
 281                 DPRINTF(Bus, "  found addr %#llx on default\n", addr);
 282                 return defaultPort;
 283             }
 284         }
 285
 286         if (responderSet) {
 287             panic("Unable to find destination for addr (user set default "
 288                   "responder): %#llx", addr);
 289         } else {
 290             DPRINTF(Bus, "Unable to find destination for addr: %#llx, will use "
 291                     "default port", addr);
 292
 293             return defaultPort;
 294         }
 295     }
 296
 297
 298     // we shouldn't be sending this back to where it came from
 299     // do the snoop access and then we should terminate
 300     // the cyclical call.
 301     if (dest_id == id)
 302         return 0;
 303
 304     return interfaces[dest_id];
 305 }
 306
 307 std::vector<int>
 308 Bus::findSnoopPorts(Addr addr, int id)
 309 {
 310     int i = 0;
 311     AddrRangeIter iter;
 312     std::vector<int> ports;
 313
 314     while (i < portSnoopList.size())
 315     {
 316         if (portSnoopList[i].range == addr && portSnoopList[i].portId != id) {
 317             //Careful  to not overlap ranges
 318             //or snoop will be called more than once on the port
 319
 320             //@todo Fix this hack because ranges are overlapping
 321             //need to make sure we dont't create overlapping ranges
 322             bool hack_overlap = false;
 323             int size = ports.size();
 324             for (int j=0; j < size; j++) {
 325                 if (ports[j] == portSnoopList[i].portId)
 326                     hack_overlap = true;
 327             }
 328
 329             if (!hack_overlap)
 330                 ports.push_back(portSnoopList[i].portId);
 331 //            DPRINTF(Bus, "  found snoop addr %#llx on device%d\n", addr,
 332 //                    portSnoopList[i].portId);
 333         }
 334         i++;
 335     }
 336     return ports;
 337 }
 338
 339 Tick
 340 Bus::atomicSnoop(PacketPtr pkt, Port *responder)
 341 {
 342     std::vector<int> ports = findSnoopPorts(pkt->getAddr(), pkt->getSrc());
 343     Tick response_time = 0;
 344
 345     while (!ports.empty())
 346     {
 347         if (interfaces[ports.back()] != responder) {
 348             Tick response = interfaces[ports.back()]->sendAtomic(pkt);
 349             if (response) {
 350                 assert(!response_time);  //Multiple responders
 351                 response_time = response;
 352             }
 353         }
 354         ports.pop_back();
 355     }
 356     return response_time;
 357 }
 358
 359 void
 360 Bus::functionalSnoop(PacketPtr pkt, Port *responder)
 361 {
 362     std::vector<int> ports = findSnoopPorts(pkt->getAddr(), pkt->getSrc());
 363
 364     //The packet may be changed by another bus on snoops, restore the id after each
 365     int id = pkt->getSrc();
 366     while (!ports.empty() && pkt->result != Packet::Success)
 367     {
 368         if (interfaces[ports.back()] != responder)
 369             interfaces[ports.back()]->sendFunctional(pkt);
 370         ports.pop_back();
 371         pkt->setSrc(id);
 372     }
 373 }
 374
 375 bool
 376 Bus::timingSnoop(PacketPtr pkt, Port* responder)
 377 {
 378     std::vector<int> ports = findSnoopPorts(pkt->getAddr(), pkt->getSrc());
 379     bool success = true;
 380
 381     while (!ports.empty() && success)
 382     {
 383         if (interfaces[ports.back()] != responder) //Don't call if responder also, once will do
 384             success = interfaces[ports.back()]->sendTiming(pkt);
 385         ports.pop_back();
 386     }
 387
 388     return success;
 389 }
 390
 391
 392 /** Function called by the port when the bus is receiving a Atomic
 393  * transaction.*/
 394 Tick
 395 Bus::recvAtomic(PacketPtr pkt)
 396 {
 397     DPRINTF(Bus, "recvAtomic: packet src %d dest %d addr 0x%x cmd %s\n",
 398             pkt->getSrc(), pkt->getDest(), pkt->getAddr(), pkt->cmdString());
 399     assert(pkt->getDest() == Packet::Broadcast);
 400     pkt->flags |= SNOOP_COMMIT;
 401
 402     // Assume one bus cycle in order to get through.  This may have
 403     // some clock skew issues yet again...
 404     pkt->finishTime = curTick + clock;
 405
 406     Port *port = findPort(pkt->getAddr(), pkt->getSrc());
 407     Tick snoopTime = atomicSnoop(pkt, port ? port : interfaces[pkt->getSrc()]);
 408
 409     if (snoopTime)
 410         return snoopTime;  //Snoop satisfies it
 411     else if (port)
 412         return port->sendAtomic(pkt);
 413     else
 414         return 0;
 415 }
 416
 417 /** Function called by the port when the bus is receiving a Functional
 418  * transaction.*/
 419 void
 420 Bus::recvFunctional(PacketPtr pkt)
 421 {
 422     DPRINTF(Bus, "recvFunctional: packet src %d dest %d addr 0x%x cmd %s\n",
 423             pkt->getSrc(), pkt->getDest(), pkt->getAddr(), pkt->cmdString());
 424     assert(pkt->getDest() == Packet::Broadcast);
 425     pkt->flags |= SNOOP_COMMIT;
 426
 427     Port* port = findPort(pkt->getAddr(), pkt->getSrc());
 428     functionalSnoop(pkt, port ? port : interfaces[pkt->getSrc()]);
 429
 430     // If the snooping found what we were looking for, we're done.
 431     if (pkt->result != Packet::Success && port) {
 432         port->sendFunctional(pkt);
 433     }
 434 }
 435
 436 /** Function called by the port when the bus is receiving a status change.*/
 437 void
 438 Bus::recvStatusChange(Port::Status status, int id)
 439 {
 440     AddrRangeList ranges;
 441     AddrRangeList snoops;
 442     int x;
 443     AddrRangeIter iter;
 444
 445     assert(status == Port::RangeChange &&
 446            "The other statuses need to be implemented.");
 447
 448     DPRINTF(BusAddrRanges, "received RangeChange from device id %d\n", id);
 449
 450     if (id == defaultId) {
 451         defaultRange.clear();
 452         // Only try to update these ranges if the user set a default responder.
 453         if (responderSet) {
 454             defaultPort->getPeerAddressRanges(ranges, snoops);
 455             assert(snoops.size() == 0);
 456             for(iter = ranges.begin(); iter != ranges.end(); iter++) {
 457                 defaultRange.push_back(*iter);
 458                 DPRINTF(BusAddrRanges, "Adding range %#llx - %#llx for default range\n",
 459                         iter->start, iter->end);
 460             }
 461         }
 462     } else {
 463
 464         assert((id < interfaces.size() && id >= 0) || id == defaultId);
 465         Port *port = interfaces[id];
 466         std::vector<DevMap>::iterator portIter;
 467         std::vector<DevMap>::iterator snoopIter;
 468
 469         // Clean out any previously existent ids
 470         for (portIter = portList.begin(); portIter != portList.end(); ) {
 471             if (portIter->portId == id)
 472                 portIter = portList.erase(portIter);
 473             else
 474                 portIter++;
 475         }
 476
 477         for (snoopIter = portSnoopList.begin(); snoopIter != portSnoopList.end(); ) {
 478             if (snoopIter->portId == id)
 479                 snoopIter = portSnoopList.erase(snoopIter);
 480             else
 481                 snoopIter++;
 482         }
 483
 484         port->getPeerAddressRanges(ranges, snoops);
 485
 486         for(iter = snoops.begin(); iter != snoops.end(); iter++) {
 487             DevMap dm;
 488             dm.portId = id;
 489             dm.range = *iter;
 490
 491             //@todo, make sure we don't overlap ranges
 492             DPRINTF(BusAddrRanges, "Adding snoop range %#llx - %#llx for id %d\n",
 493                     dm.range.start, dm.range.end, id);
 494             portSnoopList.push_back(dm);
 495         }
 496
 497         for(iter = ranges.begin(); iter != ranges.end(); iter++) {
 498             DevMap dm;
 499             dm.portId = id;
 500             dm.range = *iter;
 501
 502             DPRINTF(BusAddrRanges, "Adding range %#llx - %#llx for id %d\n",
 503                     dm.range.start, dm.range.end, id);
 504             portList.push_back(dm);
 505         }
 506     }
 507     DPRINTF(MMU, "port list has %d entries\n", portList.size());
 508
 509     // tell all our peers that our address range has changed.
 510     // Don't tell the device that caused this change, it already knows
 511     for (x = 0; x < interfaces.size(); x++)
 512         if (x != id)
 513             interfaces[x]->sendStatusChange(Port::RangeChange);
 514
 515     if (id != defaultId && defaultPort)
 516         defaultPort->sendStatusChange(Port::RangeChange);
 517 }
 518
 519 void
 520 Bus::addressRanges(AddrRangeList &resp, AddrRangeList &snoop, int id)
 521 {
 522     std::vector<DevMap>::iterator portIter;
 523     AddrRangeIter dflt_iter;
 524     bool subset;
 525
 526     resp.clear();
 527     snoop.clear();
 528
 529     DPRINTF(BusAddrRanges, "received address range request, returning:\n");
 530
 531     for (dflt_iter = defaultRange.begin(); dflt_iter != defaultRange.end();
 532             dflt_iter++) {
 533         resp.push_back(*dflt_iter);
 534         DPRINTF(BusAddrRanges, "  -- Dflt: %#llx : %#llx\n",dflt_iter->start,
 535                 dflt_iter->end);
 536     }
 537     for (portIter = portList.begin(); portIter != portList.end(); portIter++) {
 538         subset = false;
 539         for (dflt_iter = defaultRange.begin(); dflt_iter != defaultRange.end();
 540                 dflt_iter++) {
 541             if ((portIter->range.start < dflt_iter->start &&
 542                 portIter->range.end >= dflt_iter->start) ||
 543                (portIter->range.start < dflt_iter->end &&
 544                 portIter->range.end >= dflt_iter->end))
 545                 fatal("Devices can not set ranges that itersect the default set\
 546                         but are not a subset of the default set.\n");
 547             if (portIter->range.start >= dflt_iter->start &&
 548                 portIter->range.end <= dflt_iter->end) {
 549                 subset = true;
 550                 DPRINTF(BusAddrRanges, "  -- %#llx : %#llx is a SUBSET\n",
 551                     portIter->range.start, portIter->range.end);
 552             }
 553         }
 554         if (portIter->portId != id && !subset) {
 555             resp.push_back(portIter->range);
 556             DPRINTF(BusAddrRanges, "  -- %#llx : %#llx\n",
 557                     portIter->range.start, portIter->range.end);
 558         }
 559     }
 560
 561     for (portIter = portSnoopList.begin();
 562          portIter != portSnoopList.end(); portIter++)
 563     {
 564         if (portIter->portId != id) {
 565             snoop.push_back(portIter->range);
 566             DPRINTF(BusAddrRanges, "  -- Snoop: %#llx : %#llx\n",
 567                     portIter->range.start, portIter->range.end);
 568             //@todo We need to properly insert snoop ranges
 569             //not overlapping the ranges (multiple)
 570         }
 571     }
 572 }
 573
 574 unsigned int
 575 Bus::drain(Event * de)
 576 {
 577     //We should check that we're not "doing" anything, and that noone is
 578     //waiting. We might be idle but have someone waiting if the device we
 579     //contacted for a retry didn't actually retry.
 580     if (curTick >= tickNextIdle && retryList.size() == 0) {
 581         return 0;
 582     } else {
 583         drainEvent = de;
 584         return 1;
 585     }
 586 }
 587
 588 BEGIN_DECLARE_SIM_OBJECT_PARAMS(Bus)
 589
 590     Param<int> bus_id;
 591     Param<int> clock;
 592     Param<int> width;
 593     Param<bool> responder_set;
 594
 595 END_DECLARE_SIM_OBJECT_PARAMS(Bus)
 596
 597 BEGIN_INIT_SIM_OBJECT_PARAMS(Bus)
 598     INIT_PARAM(bus_id, "a globally unique bus id"),
 599     INIT_PARAM(clock, "bus clock speed"),
 600     INIT_PARAM(width, "width of the bus (bits)"),
 601     INIT_PARAM(responder_set, "Is a default responder set by the user")
 602 END_INIT_SIM_OBJECT_PARAMS(Bus)
 603
 604 CREATE_SIM_OBJECT(Bus)
 605 {
 606     return new Bus(getInstanceName(), bus_id, clock, width, responder_set);
 607 }
 608
 609 REGISTER_SIM_OBJECT("Bus", Bus)