xbar.cc revision 3512
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 42Port * 43Bus::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. */ 62void 63Bus::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 71Bus::BusFreeEvent::BusFreeEvent(Bus *_bus) : Event(&mainEventQueue), bus(_bus) 72{} 73 74void Bus::BusFreeEvent::process() 75{ 76 bus->recvRetry(-1); 77} 78 79const char * Bus::BusFreeEvent::description() 80{ 81 return "bus became available"; 82} 83 84void 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.*/ 141bool 142Bus::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 if (timingSnoop(pkt)) { 164 bool success; 165 166 pkt->flags |= SNOOP_COMMIT; 167 success = timingSnoop(pkt); 168 assert(success); 169 170 if (pkt->flags & SATISFIED) { 171 //Cache-Cache transfer occuring 172 if (inRetry) { 173 retryList.front()->onRetryList(false); 174 retryList.pop_front(); 175 inRetry = false; 176 } 177 occupyBus(pkt); 178 return true; 179 } 180 port = findPort(pkt->getAddr(), pkt->getSrc()); 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->sendTiming(pkt)) { 196 // Packet was successfully sent. Return true. 197 // Also take care of retries 198 if (inRetry) { 199 DPRINTF(Bus, "Remove retry from list %i\n", retryList.front()); 200 retryList.front()->onRetryList(false); 201 retryList.pop_front(); 202 inRetry = false; 203 } 204 return true; 205 } 206 207 // Packet not successfully sent. Leave or put it on the retry list. 208 DPRINTF(Bus, "Adding a retry to RETRY list %i\n", pktPort); 209 addToRetryList(pktPort); 210 return false; 211} 212 213void 214Bus::recvRetry(int id) 215{ 216 DPRINTF(Bus, "Received a retry\n"); 217 // If there's anything waiting, and the bus isn't busy... 218 if (retryList.size() && curTick >= tickNextIdle) { 219 //retryingPort = retryList.front(); 220 inRetry = true; 221 DPRINTF(Bus, "Sending a retry\n"); 222 retryList.front()->sendRetry(); 223 // If inRetry is still true, sendTiming wasn't called 224 if (inRetry) 225 { 226 retryList.front()->onRetryList(false); 227 retryList.pop_front(); 228 inRetry = false; 229 230 //Bring tickNextIdle up to the present 231 while (tickNextIdle < curTick) 232 tickNextIdle += clock; 233 234 //Burn a cycle for the missed grant. 235 tickNextIdle += clock; 236 237 if (!busIdle.scheduled()) { 238 busIdle.schedule(tickNextIdle); 239 } else { 240 busIdle.reschedule(tickNextIdle); 241 } 242 } 243 } 244 //If we weren't able to drain before, we might be able to now. 245 if (drainEvent && retryList.size() == 0 && curTick >= tickNextIdle) { 246 drainEvent->process(); 247 // Clear the drain event once we're done with it. 248 drainEvent = NULL; 249 } 250} 251 252Port * 253Bus::findPort(Addr addr, int id) 254{ 255 /* An interval tree would be a better way to do this. --ali. */ 256 int dest_id = -1; 257 int i = 0; 258 bool found = false; 259 AddrRangeIter iter; 260 261 while (i < portList.size() && !found) 262 { 263 if (portList[i].range == addr) { 264 dest_id = portList[i].portId; 265 found = true; 266 DPRINTF(Bus, " found addr %#llx on device %d\n", addr, dest_id); 267 } 268 i++; 269 } 270 271 // Check if this matches the default range 272 if (dest_id == -1) { 273 for (iter = defaultRange.begin(); iter != defaultRange.end(); iter++) { 274 if (*iter == addr) { 275 DPRINTF(Bus, " found addr %#llx on default\n", addr); 276 return defaultPort; 277 } 278 } 279 280 if (responderSet) { 281 panic("Unable to find destination for addr (user set default " 282 "responder): %#llx", addr); 283 } else { 284 DPRINTF(Bus, "Unable to find destination for addr: %#llx, will use " 285 "default port", addr); 286 287 return defaultPort; 288 } 289 } 290 291 292 // we shouldn't be sending this back to where it came from 293 assert(dest_id != id); 294 295 return interfaces[dest_id]; 296} 297 298std::vector<int> 299Bus::findSnoopPorts(Addr addr, int id) 300{ 301 int i = 0; 302 AddrRangeIter iter; 303 std::vector<int> ports; 304 305 while (i < portSnoopList.size()) 306 { 307 if (portSnoopList[i].range == addr && portSnoopList[i].portId != id) { 308 //Careful to not overlap ranges 309 //or snoop will be called more than once on the port 310 ports.push_back(portSnoopList[i].portId); 311// DPRINTF(Bus, " found snoop addr %#llx on device%d\n", addr, 312// portSnoopList[i].portId); 313 } 314 i++; 315 } 316 return ports; 317} 318 319Tick 320Bus::atomicSnoop(PacketPtr pkt) 321{ 322 std::vector<int> ports = findSnoopPorts(pkt->getAddr(), pkt->getSrc()); 323 Tick response_time = 0; 324 325 while (!ports.empty()) 326 { 327 Tick response = interfaces[ports.back()]->sendAtomic(pkt); 328 if (response) { 329 assert(!response_time); //Multiple responders 330 response_time = response; 331 } 332 ports.pop_back(); 333 } 334 return response_time; 335} 336 337void 338Bus::functionalSnoop(PacketPtr pkt) 339{ 340 std::vector<int> ports = findSnoopPorts(pkt->getAddr(), pkt->getSrc()); 341 342 while (!ports.empty() && pkt->result != Packet::Success) 343 { 344 interfaces[ports.back()]->sendFunctional(pkt); 345 ports.pop_back(); 346 } 347} 348 349bool 350Bus::timingSnoop(PacketPtr pkt) 351{ 352 std::vector<int> ports = findSnoopPorts(pkt->getAddr(), pkt->getSrc()); 353 bool success = true; 354 355 while (!ports.empty() && success) 356 { 357 success = interfaces[ports.back()]->sendTiming(pkt); 358 ports.pop_back(); 359 } 360 361 return success; 362} 363 364 365/** Function called by the port when the bus is receiving a Atomic 366 * transaction.*/ 367Tick 368Bus::recvAtomic(PacketPtr pkt) 369{ 370 DPRINTF(Bus, "recvAtomic: packet src %d dest %d addr 0x%x cmd %s\n", 371 pkt->getSrc(), pkt->getDest(), pkt->getAddr(), pkt->cmdString()); 372 assert(pkt->getDest() == Packet::Broadcast); 373 Tick snoopTime = atomicSnoop(pkt); 374 if (snoopTime) 375 return snoopTime; //Snoop satisfies it 376 else 377 return findPort(pkt->getAddr(), pkt->getSrc())->sendAtomic(pkt); 378} 379 380/** Function called by the port when the bus is receiving a Functional 381 * transaction.*/ 382void 383Bus::recvFunctional(PacketPtr pkt) 384{ 385 DPRINTF(Bus, "recvFunctional: packet src %d dest %d addr 0x%x cmd %s\n", 386 pkt->getSrc(), pkt->getDest(), pkt->getAddr(), pkt->cmdString()); 387 assert(pkt->getDest() == Packet::Broadcast); 388 functionalSnoop(pkt); 389 390 // If the snooping found what we were looking for, we're done. 391 if (pkt->result != Packet::Success) 392 findPort(pkt->getAddr(), pkt->getSrc())->sendFunctional(pkt); 393} 394 395/** Function called by the port when the bus is receiving a status change.*/ 396void 397Bus::recvStatusChange(Port::Status status, int id) 398{ 399 AddrRangeList ranges; 400 AddrRangeList snoops; 401 int x; 402 AddrRangeIter iter; 403 404 assert(status == Port::RangeChange && 405 "The other statuses need to be implemented."); 406 407 DPRINTF(BusAddrRanges, "received RangeChange from device id %d\n", id); 408 409 if (id == defaultId) { 410 defaultRange.clear(); 411 // Only try to update these ranges if the user set a default responder. 412 if (responderSet) { 413 defaultPort->getPeerAddressRanges(ranges, snoops); 414 assert(snoops.size() == 0); 415 for(iter = ranges.begin(); iter != ranges.end(); iter++) { 416 defaultRange.push_back(*iter); 417 DPRINTF(BusAddrRanges, "Adding range %#llx - %#llx for default range\n", 418 iter->start, iter->end); 419 } 420 } 421 } else { 422 423 assert((id < interfaces.size() && id >= 0) || id == defaultId); 424 Port *port = interfaces[id]; 425 std::vector<DevMap>::iterator portIter; 426 std::vector<DevMap>::iterator snoopIter; 427 428 // Clean out any previously existent ids 429 for (portIter = portList.begin(); portIter != portList.end(); ) { 430 if (portIter->portId == id) 431 portIter = portList.erase(portIter); 432 else 433 portIter++; 434 } 435 436 for (snoopIter = portSnoopList.begin(); snoopIter != portSnoopList.end(); ) { 437 if (snoopIter->portId == id) 438 snoopIter = portSnoopList.erase(snoopIter); 439 else 440 snoopIter++; 441 } 442 443 port->getPeerAddressRanges(ranges, snoops); 444 445 for(iter = snoops.begin(); iter != snoops.end(); iter++) { 446 DevMap dm; 447 dm.portId = id; 448 dm.range = *iter; 449 450 DPRINTF(BusAddrRanges, "Adding snoop range %#llx - %#llx for id %d\n", 451 dm.range.start, dm.range.end, id); 452 portSnoopList.push_back(dm); 453 } 454 455 for(iter = ranges.begin(); iter != ranges.end(); iter++) { 456 DevMap dm; 457 dm.portId = id; 458 dm.range = *iter; 459 460 DPRINTF(BusAddrRanges, "Adding range %#llx - %#llx for id %d\n", 461 dm.range.start, dm.range.end, id); 462 portList.push_back(dm); 463 } 464 } 465 DPRINTF(MMU, "port list has %d entries\n", portList.size()); 466 467 // tell all our peers that our address range has changed. 468 // Don't tell the device that caused this change, it already knows 469 for (x = 0; x < interfaces.size(); x++) 470 if (x != id) 471 interfaces[x]->sendStatusChange(Port::RangeChange); 472 473 if (id != defaultId && defaultPort) 474 defaultPort->sendStatusChange(Port::RangeChange); 475} 476 477void 478Bus::addressRanges(AddrRangeList &resp, AddrRangeList &snoop, int id) 479{ 480 std::vector<DevMap>::iterator portIter; 481 AddrRangeIter dflt_iter; 482 bool subset; 483 484 resp.clear(); 485 snoop.clear(); 486 487 DPRINTF(BusAddrRanges, "received address range request, returning:\n"); 488 489 for (dflt_iter = defaultRange.begin(); dflt_iter != defaultRange.end(); 490 dflt_iter++) { 491 resp.push_back(*dflt_iter); 492 DPRINTF(BusAddrRanges, " -- %#llx : %#llx\n",dflt_iter->start, 493 dflt_iter->end); 494 } 495 for (portIter = portList.begin(); portIter != portList.end(); portIter++) { 496 subset = false; 497 for (dflt_iter = defaultRange.begin(); dflt_iter != defaultRange.end(); 498 dflt_iter++) { 499 if ((portIter->range.start < dflt_iter->start && 500 portIter->range.end >= dflt_iter->start) || 501 (portIter->range.start < dflt_iter->end && 502 portIter->range.end >= dflt_iter->end)) 503 fatal("Devices can not set ranges that itersect the default set\ 504 but are not a subset of the default set.\n"); 505 if (portIter->range.start >= dflt_iter->start && 506 portIter->range.end <= dflt_iter->end) { 507 subset = true; 508 DPRINTF(BusAddrRanges, " -- %#llx : %#llx is a SUBSET\n", 509 portIter->range.start, portIter->range.end); 510 } 511 } 512 if (portIter->portId != id && !subset) { 513 resp.push_back(portIter->range); 514 DPRINTF(BusAddrRanges, " -- %#llx : %#llx\n", 515 portIter->range.start, portIter->range.end); 516 } 517 } 518} 519 520unsigned int 521Bus::drain(Event * de) 522{ 523 //We should check that we're not "doing" anything, and that noone is 524 //waiting. We might be idle but have someone waiting if the device we 525 //contacted for a retry didn't actually retry. 526 if (curTick >= tickNextIdle && retryList.size() == 0) { 527 return 0; 528 } else { 529 drainEvent = de; 530 return 1; 531 } 532} 533 534BEGIN_DECLARE_SIM_OBJECT_PARAMS(Bus) 535 536 Param<int> bus_id; 537 Param<int> clock; 538 Param<int> width; 539 Param<bool> responder_set; 540 541END_DECLARE_SIM_OBJECT_PARAMS(Bus) 542 543BEGIN_INIT_SIM_OBJECT_PARAMS(Bus) 544 INIT_PARAM(bus_id, "a globally unique bus id"), 545 INIT_PARAM(clock, "bus clock speed"), 546 INIT_PARAM(width, "width of the bus (bits)"), 547 INIT_PARAM(responder_set, "Is a default responder set by the user") 548END_INIT_SIM_OBJECT_PARAMS(Bus) 549 550CREATE_SIM_OBJECT(Bus) 551{ 552 return new Bus(getInstanceName(), bus_id, clock, width, responder_set); 553} 554 555REGISTER_SIM_OBJECT("Bus", Bus) 556