noncoherent_xbar.cc revision 10572:fc4c90a7d2f5 
1/*
2 * Copyright (c) 2011-2014 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 "base/misc.hh"
51#include "base/trace.hh"
52#include "debug/NoncoherentXBar.hh"
53#include "debug/XBar.hh"
54#include "mem/noncoherent_xbar.hh"
55
56NoncoherentXBar::NoncoherentXBar(const NoncoherentXBarParams *p)
57    : BaseXBar(p)
58{
59    // create the ports based on the size of the master and slave
60    // vector ports, and the presence of the default port, the ports
61    // are enumerated starting from zero
62    for (int i = 0; i < p->port_master_connection_count; ++i) {
63        std::string portName = csprintf("%s.master[%d]", name(), i);
64        MasterPort* bp = new NoncoherentXBarMasterPort(portName, *this, i);
65        masterPorts.push_back(bp);
66        reqLayers.push_back(new ReqLayer(*bp, *this,
67                                         csprintf(".reqLayer%d", i)));
68    }
69
70    // see if we have a default slave device connected and if so add
71    // our corresponding master port
72    if (p->port_default_connection_count) {
73        defaultPortID = masterPorts.size();
74        std::string portName = name() + ".default";
75        MasterPort* bp = new NoncoherentXBarMasterPort(portName, *this,
76                                                      defaultPortID);
77        masterPorts.push_back(bp);
78        reqLayers.push_back(new ReqLayer(*bp, *this, csprintf(".reqLayer%d",
79                                                              defaultPortID)));
80    }
81
82    // create the slave ports, once again starting at zero
83    for (int i = 0; i < p->port_slave_connection_count; ++i) {
84        std::string portName = csprintf("%s.slave[%d]", name(), i);
85        SlavePort* bp = new NoncoherentXBarSlavePort(portName, *this, i);
86        slavePorts.push_back(bp);
87        respLayers.push_back(new RespLayer(*bp, *this,
88                                           csprintf(".respLayer%d", i)));
89    }
90
91    clearPortCache();
92}
93
94NoncoherentXBar::~NoncoherentXBar()
95{
96    for (auto l: reqLayers)
97        delete l;
98    for (auto l: respLayers)
99        delete l;
100}
101
102bool
103NoncoherentXBar::recvTimingReq(PacketPtr pkt, PortID slave_port_id)
104{
105    // determine the source port based on the id
106    SlavePort *src_port = slavePorts[slave_port_id];
107
108    // we should never see express snoops on a non-coherent crossbar
109    assert(!pkt->isExpressSnoop());
110
111    // determine the destination based on the address
112    PortID master_port_id = findPort(pkt->getAddr());
113
114    // test if the layer should be considered occupied for the current
115    // port
116    if (!reqLayers[master_port_id]->tryTiming(src_port)) {
117        DPRINTF(NoncoherentXBar, "recvTimingReq: src %s %s 0x%x BUSY\n",
118                src_port->name(), pkt->cmdString(), pkt->getAddr());
119        return false;
120    }
121
122    DPRINTF(NoncoherentXBar, "recvTimingReq: src %s %s 0x%x\n",
123            src_port->name(), pkt->cmdString(), pkt->getAddr());
124
125    // store size and command as they might be modified when
126    // forwarding the packet
127    unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
128    unsigned int pkt_cmd = pkt->cmdToIndex();
129
130    // set the source port for routing of the response
131    pkt->setSrc(slave_port_id);
132
133    calcPacketTiming(pkt);
134    Tick packetFinishTime = pkt->lastWordDelay + curTick();
135
136    // since it is a normal request, attempt to send the packet
137    bool success = masterPorts[master_port_id]->sendTimingReq(pkt);
138
139    if (!success)  {
140        // inhibited packets should never be forced to retry
141        assert(!pkt->memInhibitAsserted());
142
143        DPRINTF(NoncoherentXBar, "recvTimingReq: src %s %s 0x%x RETRY\n",
144                src_port->name(), pkt->cmdString(), pkt->getAddr());
145
146        // undo the calculation so we can check for 0 again
147        pkt->firstWordDelay = pkt->lastWordDelay = 0;
148
149        // occupy until the header is sent
150        reqLayers[master_port_id]->failedTiming(src_port,
151                                                clockEdge(headerCycles));
152
153        return false;
154    }
155
156    reqLayers[master_port_id]->succeededTiming(packetFinishTime);
157
158    // stats updates
159    pktCount[slave_port_id][master_port_id]++;
160    pktSize[slave_port_id][master_port_id] += pkt_size;
161    transDist[pkt_cmd]++;
162
163    return true;
164}
165
166bool
167NoncoherentXBar::recvTimingResp(PacketPtr pkt, PortID master_port_id)
168{
169    // determine the source port based on the id
170    MasterPort *src_port = masterPorts[master_port_id];
171
172    // determine the destination based on what is stored in the packet
173    PortID slave_port_id = pkt->getDest();
174    assert(slave_port_id != InvalidPortID);
175    assert(slave_port_id < respLayers.size());
176
177    // test if the layer should be considered occupied for the current
178    // port
179    if (!respLayers[slave_port_id]->tryTiming(src_port)) {
180        DPRINTF(NoncoherentXBar, "recvTimingResp: src %s %s 0x%x BUSY\n",
181                src_port->name(), pkt->cmdString(), pkt->getAddr());
182        return false;
183    }
184
185    DPRINTF(NoncoherentXBar, "recvTimingResp: src %s %s 0x%x\n",
186            src_port->name(), pkt->cmdString(), pkt->getAddr());
187
188    // store size and command as they might be modified when
189    // forwarding the packet
190    unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
191    unsigned int pkt_cmd = pkt->cmdToIndex();
192
193    calcPacketTiming(pkt);
194    Tick packetFinishTime = pkt->lastWordDelay + curTick();
195
196    // send the packet through the destination slave port
197    bool success M5_VAR_USED = slavePorts[slave_port_id]->sendTimingResp(pkt);
198
199    // currently it is illegal to block responses... can lead to
200    // deadlock
201    assert(success);
202
203    respLayers[slave_port_id]->succeededTiming(packetFinishTime);
204
205    // stats updates
206    pktCount[slave_port_id][master_port_id]++;
207    pktSize[slave_port_id][master_port_id] += pkt_size;
208    transDist[pkt_cmd]++;
209
210    return true;
211}
212
213void
214NoncoherentXBar::recvRetry(PortID master_port_id)
215{
216    // responses never block on forwarding them, so the retry will
217    // always be coming from a port to which we tried to forward a
218    // request
219    reqLayers[master_port_id]->recvRetry();
220}
221
222Tick
223NoncoherentXBar::recvAtomic(PacketPtr pkt, PortID slave_port_id)
224{
225    DPRINTF(NoncoherentXBar, "recvAtomic: packet src %s addr 0x%x cmd %s\n",
226            slavePorts[slave_port_id]->name(), pkt->getAddr(),
227            pkt->cmdString());
228
229    unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
230    unsigned int pkt_cmd = pkt->cmdToIndex();
231
232    // determine the destination port
233    PortID master_port_id = findPort(pkt->getAddr());
234
235    // stats updates for the request
236    pktCount[slave_port_id][master_port_id]++;
237    pktSize[slave_port_id][master_port_id] += pkt_size;
238    transDist[pkt_cmd]++;
239
240    // forward the request to the appropriate destination
241    Tick response_latency = masterPorts[master_port_id]->sendAtomic(pkt);
242
243    // add the response data
244    if (pkt->isResponse()) {
245        pkt_size = pkt->hasData() ? pkt->getSize() : 0;
246        pkt_cmd = pkt->cmdToIndex();
247
248        // stats updates
249        pktCount[slave_port_id][master_port_id]++;
250        pktSize[slave_port_id][master_port_id] += pkt_size;
251        transDist[pkt_cmd]++;
252    }
253
254    // @todo: Not setting first-word time
255    pkt->lastWordDelay = response_latency;
256    return response_latency;
257}
258
259void
260NoncoherentXBar::recvFunctional(PacketPtr pkt, PortID slave_port_id)
261{
262    if (!pkt->isPrint()) {
263        // don't do DPRINTFs on PrintReq as it clutters up the output
264        DPRINTF(NoncoherentXBar,
265                "recvFunctional: packet src %s addr 0x%x cmd %s\n",
266                slavePorts[slave_port_id]->name(), pkt->getAddr(),
267                pkt->cmdString());
268    }
269
270    // determine the destination port
271    PortID dest_id = findPort(pkt->getAddr());
272
273    // forward the request to the appropriate destination
274    masterPorts[dest_id]->sendFunctional(pkt);
275}
276
277unsigned int
278NoncoherentXBar::drain(DrainManager *dm)
279{
280    // sum up the individual layers
281    unsigned int total = 0;
282    for (auto l: reqLayers)
283        total += l->drain(dm);
284    for (auto l: respLayers)
285        total += l->drain(dm);
286    return total;
287}
288
289NoncoherentXBar*
290NoncoherentXBarParams::create()
291{
292    return new NoncoherentXBar(this);
293}
294
295void
296NoncoherentXBar::regStats()
297{
298    // register the stats of the base class and our layers
299    BaseXBar::regStats();
300    for (auto l: reqLayers)
301        l->regStats();
302    for (auto l: respLayers)
303        l->regStats();
304}
305