src/mem/noncoherent_xbar.cc

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