src/mem/noncoherent_xbar.cc

   1 /*
   2  * Copyright (c) 2011-2015 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  *          Andreas Hansson
  42  *          William Wang
  43  */
  44
  45 /**
  46  * @file
  47  * Definition of a non-coherent crossbar object.
  48  */
  49
  50 #include "mem/noncoherent_xbar.hh"
  51
  52 #include "base/logging.hh"
  53 #include "base/trace.hh"
  54 #include "debug/NoncoherentXBar.hh"
  55 #include "debug/XBar.hh"
  56
  57 NoncoherentXBar::NoncoherentXBar(const NoncoherentXBarParams *p)
  58     : BaseXBar(p)
  59 {
  60     // create the ports based on the size of the master and slave
  61     // vector ports, and the presence of the default port, the ports
  62     // are enumerated starting from zero
  63     for (int i = 0; i < p->port_master_connection_count; ++i) {
  64         std::string portName = csprintf("%s.master[%d]", name(), i);
  65         MasterPort* bp = new NoncoherentXBarMasterPort(portName, *this, i);
  66         masterPorts.push_back(bp);
  67         reqLayers.push_back(new ReqLayer(*bp, *this,
  68                                          csprintf(".reqLayer%d", i)));
  69     }
  70
  71     // see if we have a default slave device connected and if so add
  72     // our corresponding master port
  73     if (p->port_default_connection_count) {
  74         defaultPortID = masterPorts.size();
  75         std::string portName = name() + ".default";
  76         MasterPort* bp = new NoncoherentXBarMasterPort(portName, *this,
  77                                                       defaultPortID);
  78         masterPorts.push_back(bp);
  79         reqLayers.push_back(new ReqLayer(*bp, *this, csprintf(".reqLayer%d",
  80                                                               defaultPortID)));
  81     }
  82
  83     // create the slave ports, once again starting at zero
  84     for (int i = 0; i < p->port_slave_connection_count; ++i) {
  85         std::string portName = csprintf("%s.slave[%d]", name(), i);
  86         QueuedSlavePort* bp = new NoncoherentXBarSlavePort(portName, *this, i);
  87         slavePorts.push_back(bp);
  88         respLayers.push_back(new RespLayer(*bp, *this,
  89                                            csprintf(".respLayer%d", i)));
  90     }
  91
  92     clearPortCache();
  93 }
  94
  95 NoncoherentXBar::~NoncoherentXBar()
  96 {
  97     for (auto l: reqLayers)
  98         delete l;
  99     for (auto l: respLayers)
 100         delete l;
 101 }
 102
 103 bool
 104 NoncoherentXBar::recvTimingReq(PacketPtr pkt, PortID slave_port_id)
 105 {
 106     // determine the source port based on the id
 107     SlavePort *src_port = slavePorts[slave_port_id];
 108
 109     // we should never see express snoops on a non-coherent crossbar
 110     assert(!pkt->isExpressSnoop());
 111
 112     // determine the destination based on the address
 113     PortID master_port_id = findPort(pkt->getAddr());
 114
 115     // test if the layer should be considered occupied for the current
 116     // port
 117     if (!reqLayers[master_port_id]->tryTiming(src_port)) {
 118         DPRINTF(NoncoherentXBar, "recvTimingReq: src %s %s 0x%x BUSY\n",
 119                 src_port->name(), pkt->cmdString(), pkt->getAddr());
 120         return false;
 121     }
 122
 123     DPRINTF(NoncoherentXBar, "recvTimingReq: src %s %s 0x%x\n",
 124             src_port->name(), pkt->cmdString(), pkt->getAddr());
 125
 126     // store size and command as they might be modified when
 127     // forwarding the packet
 128     unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
 129     unsigned int pkt_cmd = pkt->cmdToIndex();
 130
 131     // store the old header delay so we can restore it if needed
 132     Tick old_header_delay = pkt->headerDelay;
 133
 134     // a request sees the frontend and forward latency
 135     Tick xbar_delay = (frontendLatency + forwardLatency) * clockPeriod();
 136
 137     // set the packet header and payload delay
 138     calcPacketTiming(pkt, xbar_delay);
 139
 140     // determine how long to be crossbar layer is busy
 141     Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay;
 142
 143     // before forwarding the packet (and possibly altering it),
 144     // remember if we are expecting a response
 145     const bool expect_response = pkt->needsResponse() &&
 146         !pkt->cacheResponding();
 147
 148     // since it is a normal request, attempt to send the packet
 149     bool success = masterPorts[master_port_id]->sendTimingReq(pkt);
 150
 151     if (!success)  {
 152         DPRINTF(NoncoherentXBar, "recvTimingReq: src %s %s 0x%x RETRY\n",
 153                 src_port->name(), pkt->cmdString(), pkt->getAddr());
 154
 155         // restore the header delay as it is additive
 156         pkt->headerDelay = old_header_delay;
 157
 158         // occupy until the header is sent
 159         reqLayers[master_port_id]->failedTiming(src_port,
 160                                                 clockEdge(Cycles(1)));
 161
 162         return false;
 163     }
 164
 165     // remember where to route the response to
 166     if (expect_response) {
 167         assert(routeTo.find(pkt->req) == routeTo.end());
 168         routeTo[pkt->req] = slave_port_id;
 169     }
 170
 171     reqLayers[master_port_id]->succeededTiming(packetFinishTime);
 172
 173     // stats updates
 174     pktCount[slave_port_id][master_port_id]++;
 175     pktSize[slave_port_id][master_port_id] += pkt_size;
 176     transDist[pkt_cmd]++;
 177
 178     return true;
 179 }
 180
 181 bool
 182 NoncoherentXBar::recvTimingResp(PacketPtr pkt, PortID master_port_id)
 183 {
 184     // determine the source port based on the id
 185     MasterPort *src_port = masterPorts[master_port_id];
 186
 187     // determine the destination
 188     const auto route_lookup = routeTo.find(pkt->req);
 189     assert(route_lookup != routeTo.end());
 190     const PortID slave_port_id = route_lookup->second;
 191     assert(slave_port_id != InvalidPortID);
 192     assert(slave_port_id < respLayers.size());
 193
 194     // test if the layer should be considered occupied for the current
 195     // port
 196     if (!respLayers[slave_port_id]->tryTiming(src_port)) {
 197         DPRINTF(NoncoherentXBar, "recvTimingResp: src %s %s 0x%x BUSY\n",
 198                 src_port->name(), pkt->cmdString(), pkt->getAddr());
 199         return false;
 200     }
 201
 202     DPRINTF(NoncoherentXBar, "recvTimingResp: src %s %s 0x%x\n",
 203             src_port->name(), pkt->cmdString(), pkt->getAddr());
 204
 205     // store size and command as they might be modified when
 206     // forwarding the packet
 207     unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
 208     unsigned int pkt_cmd = pkt->cmdToIndex();
 209
 210     // a response sees the response latency
 211     Tick xbar_delay = responseLatency * clockPeriod();
 212
 213     // set the packet header and payload delay
 214     calcPacketTiming(pkt, xbar_delay);
 215
 216     // determine how long to be crossbar layer is busy
 217     Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay;
 218
 219     // send the packet through the destination slave port, and pay for
 220     // any outstanding latency
 221     Tick latency = pkt->headerDelay;
 222     pkt->headerDelay = 0;
 223     slavePorts[slave_port_id]->schedTimingResp(pkt, curTick() + latency);
 224
 225     // remove the request from the routing table
 226     routeTo.erase(route_lookup);
 227
 228     respLayers[slave_port_id]->succeededTiming(packetFinishTime);
 229
 230     // stats updates
 231     pktCount[slave_port_id][master_port_id]++;
 232     pktSize[slave_port_id][master_port_id] += pkt_size;
 233     transDist[pkt_cmd]++;
 234
 235     return true;
 236 }
 237
 238 void
 239 NoncoherentXBar::recvReqRetry(PortID master_port_id)
 240 {
 241     // responses never block on forwarding them, so the retry will
 242     // always be coming from a port to which we tried to forward a
 243     // request
 244     reqLayers[master_port_id]->recvRetry();
 245 }
 246
 247 Tick
 248 NoncoherentXBar::recvAtomic(PacketPtr pkt, PortID slave_port_id)
 249 {
 250     DPRINTF(NoncoherentXBar, "recvAtomic: packet src %s addr 0x%x cmd %s\n",
 251             slavePorts[slave_port_id]->name(), pkt->getAddr(),
 252             pkt->cmdString());
 253
 254     unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
 255     unsigned int pkt_cmd = pkt->cmdToIndex();
 256
 257     // determine the destination port
 258     PortID master_port_id = findPort(pkt->getAddr());
 259
 260     // stats updates for the request
 261     pktCount[slave_port_id][master_port_id]++;
 262     pktSize[slave_port_id][master_port_id] += pkt_size;
 263     transDist[pkt_cmd]++;
 264
 265     // forward the request to the appropriate destination
 266     Tick response_latency = masterPorts[master_port_id]->sendAtomic(pkt);
 267
 268     // add the response data
 269     if (pkt->isResponse()) {
 270         pkt_size = pkt->hasData() ? pkt->getSize() : 0;
 271         pkt_cmd = pkt->cmdToIndex();
 272
 273         // stats updates
 274         pktCount[slave_port_id][master_port_id]++;
 275         pktSize[slave_port_id][master_port_id] += pkt_size;
 276         transDist[pkt_cmd]++;
 277     }
 278
 279     // @todo: Not setting first-word time
 280     pkt->payloadDelay = response_latency;
 281     return response_latency;
 282 }
 283
 284 void
 285 NoncoherentXBar::recvFunctional(PacketPtr pkt, PortID slave_port_id)
 286 {
 287     if (!pkt->isPrint()) {
 288         // don't do DPRINTFs on PrintReq as it clutters up the output
 289         DPRINTF(NoncoherentXBar,
 290                 "recvFunctional: packet src %s addr 0x%x cmd %s\n",
 291                 slavePorts[slave_port_id]->name(), pkt->getAddr(),
 292                 pkt->cmdString());
 293     }
 294
 295     // since our slave ports are queued ports we need to check them as well
 296     for (const auto& p : slavePorts) {
 297         // if we find a response that has the data, then the
 298         // downstream caches/memories may be out of date, so simply stop
 299         // here
 300         if (p->checkFunctional(pkt)) {
 301             if (pkt->needsResponse())
 302                 pkt->makeResponse();
 303             return;
 304         }
 305     }
 306
 307     // determine the destination port
 308     PortID dest_id = findPort(pkt->getAddr());
 309
 310     // forward the request to the appropriate destination
 311     masterPorts[dest_id]->sendFunctional(pkt);
 312 }
 313
 314 NoncoherentXBar*
 315 NoncoherentXBarParams::create()
 316 {
 317     return new NoncoherentXBar(this);
 318 }
 319
 320 void
 321 NoncoherentXBar::regStats()
 322 {
 323     // register the stats of the base class and our layers
 324     BaseXBar::regStats();
 325     for (auto l: reqLayers)
 326         l->regStats();
 327     for (auto l: respLayers)
 328         l->regStats();
 329 }