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
| 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
|
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 QueuedSlavePort* 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 // store the old header delay so we can restore it if needed
131 Tick old_header_delay = pkt->headerDelay;
132
133 // a request sees the frontend and forward latency
134 Tick xbar_delay = (frontendLatency + forwardLatency) * clockPeriod();
135
136 // set the packet header and payload delay
137 calcPacketTiming(pkt, xbar_delay);
138
139 // determine how long to be crossbar layer is busy
140 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay;
141
142 // before forwarding the packet (and possibly altering it),
143 // remember if we are expecting a response
144 const bool expect_response = pkt->needsResponse() &&
145 !pkt->cacheResponding();
146
147 // since it is a normal request, attempt to send the packet
148 bool success = masterPorts[master_port_id]->sendTimingReq(pkt);
149
150 if (!success) {
151 DPRINTF(NoncoherentXBar, "recvTimingReq: src %s %s 0x%x RETRY\n",
152 src_port->name(), pkt->cmdString(), pkt->getAddr());
153
154 // restore the header delay as it is additive
155 pkt->headerDelay = old_header_delay;
156
157 // occupy until the header is sent
158 reqLayers[master_port_id]->failedTiming(src_port,
159 clockEdge(Cycles(1)));
160
161 return false;
162 }
163
164 // remember where to route the response to
165 if (expect_response) {
166 assert(routeTo.find(pkt->req) == routeTo.end());
167 routeTo[pkt->req] = slave_port_id;
168 }
169
170 reqLayers[master_port_id]->succeededTiming(packetFinishTime);
171
172 // stats updates
173 pktCount[slave_port_id][master_port_id]++;
174 pktSize[slave_port_id][master_port_id] += pkt_size;
175 transDist[pkt_cmd]++;
176
177 return true;
178}
179
180bool
181NoncoherentXBar::recvTimingResp(PacketPtr pkt, PortID master_port_id)
182{
183 // determine the source port based on the id
184 MasterPort *src_port = masterPorts[master_port_id];
185
186 // determine the destination
187 const auto route_lookup = routeTo.find(pkt->req);
188 assert(route_lookup != routeTo.end());
189 const PortID slave_port_id = route_lookup->second;
190 assert(slave_port_id != InvalidPortID);
191 assert(slave_port_id < respLayers.size());
192
193 // test if the layer should be considered occupied for the current
194 // port
195 if (!respLayers[slave_port_id]->tryTiming(src_port)) {
196 DPRINTF(NoncoherentXBar, "recvTimingResp: src %s %s 0x%x BUSY\n",
197 src_port->name(), pkt->cmdString(), pkt->getAddr());
198 return false;
199 }
200
201 DPRINTF(NoncoherentXBar, "recvTimingResp: src %s %s 0x%x\n",
202 src_port->name(), pkt->cmdString(), pkt->getAddr());
203
204 // store size and command as they might be modified when
205 // forwarding the packet
206 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
207 unsigned int pkt_cmd = pkt->cmdToIndex();
208
209 // a response sees the response latency
210 Tick xbar_delay = responseLatency * clockPeriod();
211
212 // set the packet header and payload delay
213 calcPacketTiming(pkt, xbar_delay);
214
215 // determine how long to be crossbar layer is busy
216 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay;
217
218 // send the packet through the destination slave port, and pay for
219 // any outstanding latency
220 Tick latency = pkt->headerDelay;
221 pkt->headerDelay = 0;
222 slavePorts[slave_port_id]->schedTimingResp(pkt, curTick() + latency);
223
224 // remove the request from the routing table
225 routeTo.erase(route_lookup);
226
227 respLayers[slave_port_id]->succeededTiming(packetFinishTime);
228
229 // stats updates
230 pktCount[slave_port_id][master_port_id]++;
231 pktSize[slave_port_id][master_port_id] += pkt_size;
232 transDist[pkt_cmd]++;
233
234 return true;
235}
236
237void
238NoncoherentXBar::recvReqRetry(PortID master_port_id)
239{
240 // responses never block on forwarding them, so the retry will
241 // always be coming from a port to which we tried to forward a
242 // request
243 reqLayers[master_port_id]->recvRetry();
244}
245
246Tick
247NoncoherentXBar::recvAtomic(PacketPtr pkt, PortID slave_port_id)
248{
249 DPRINTF(NoncoherentXBar, "recvAtomic: packet src %s addr 0x%x cmd %s\n",
250 slavePorts[slave_port_id]->name(), pkt->getAddr(),
251 pkt->cmdString());
252
253 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
254 unsigned int pkt_cmd = pkt->cmdToIndex();
255
256 // determine the destination port
257 PortID master_port_id = findPort(pkt->getAddr());
258
259 // stats updates for the request
260 pktCount[slave_port_id][master_port_id]++;
261 pktSize[slave_port_id][master_port_id] += pkt_size;
262 transDist[pkt_cmd]++;
263
264 // forward the request to the appropriate destination
265 Tick response_latency = masterPorts[master_port_id]->sendAtomic(pkt);
266
267 // add the response data
268 if (pkt->isResponse()) {
269 pkt_size = pkt->hasData() ? pkt->getSize() : 0;
270 pkt_cmd = pkt->cmdToIndex();
271
272 // stats updates
273 pktCount[slave_port_id][master_port_id]++;
274 pktSize[slave_port_id][master_port_id] += pkt_size;
275 transDist[pkt_cmd]++;
276 }
277
278 // @todo: Not setting first-word time
279 pkt->payloadDelay = response_latency;
280 return response_latency;
281}
282
283void
284NoncoherentXBar::recvFunctional(PacketPtr pkt, PortID slave_port_id)
285{
286 if (!pkt->isPrint()) {
287 // don't do DPRINTFs on PrintReq as it clutters up the output
288 DPRINTF(NoncoherentXBar,
289 "recvFunctional: packet src %s addr 0x%x cmd %s\n",
290 slavePorts[slave_port_id]->name(), pkt->getAddr(),
291 pkt->cmdString());
292 }
293
294 // since our slave ports are queued ports we need to check them as well
295 for (const auto& p : slavePorts) {
296 // if we find a response that has the data, then the
297 // downstream caches/memories may be out of date, so simply stop
298 // here
299 if (p->checkFunctional(pkt)) {
300 if (pkt->needsResponse())
301 pkt->makeResponse();
302 return;
303 }
304 }
305
306 // determine the destination port
307 PortID dest_id = findPort(pkt->getAddr());
308
309 // forward the request to the appropriate destination
310 masterPorts[dest_id]->sendFunctional(pkt);
311}
312
313NoncoherentXBar*
314NoncoherentXBarParams::create()
315{
316 return new NoncoherentXBar(this);
317}
318
319void
320NoncoherentXBar::regStats()
321{
322 // register the stats of the base class and our layers
323 BaseXBar::regStats();
324 for (auto l: reqLayers)
325 l->regStats();
326 for (auto l: respLayers)
327 l->regStats();
328}
| 56
57NoncoherentXBar::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
95NoncoherentXBar::~NoncoherentXBar()
96{
97 for (auto l: reqLayers)
98 delete l;
99 for (auto l: respLayers)
100 delete l;
101}
102
103bool
104NoncoherentXBar::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
181bool
182NoncoherentXBar::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
238void
239NoncoherentXBar::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
247Tick
248NoncoherentXBar::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
284void
285NoncoherentXBar::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
314NoncoherentXBar*
315NoncoherentXBarParams::create()
316{
317 return new NoncoherentXBar(this);
318}
319
320void
321NoncoherentXBar::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}
|