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