48#include "base/trace.hh"
49#include "debug/SnoopFilter.hh"
50#include "sim/system.hh"
51
52void
53SnoopFilter::eraseIfNullEntry(SnoopFilterCache::iterator& sf_it)
54{
55 SnoopItem& sf_item = sf_it->second;
56 if (!(sf_item.requested | sf_item.holder)) {
57 cachedLocations.erase(sf_it);
58 DPRINTF(SnoopFilter, "%s: Removed SF entry.\n",
59 __func__);
60 }
61}
62
63std::pair<SnoopFilter::SnoopList, Cycles>
64SnoopFilter::lookupRequest(const Packet* cpkt, const SlavePort& slave_port)
65{
66 DPRINTF(SnoopFilter, "%s: src %s packet %s\n", __func__,
67 slave_port.name(), cpkt->print());
68
69 // check if the packet came from a cache
70 bool allocate = !cpkt->req->isUncacheable() && slave_port.isSnooping() &&
71 cpkt->fromCache();
72 Addr line_addr = cpkt->getBlockAddr(linesize);
73 if (cpkt->isSecure()) {
74 line_addr |= LineSecure;
75 }
76 SnoopMask req_port = portToMask(slave_port);
77 reqLookupResult = cachedLocations.find(line_addr);
78 bool is_hit = (reqLookupResult != cachedLocations.end());
79
80 // If the snoop filter has no entry, and we should not allocate,
81 // do not create a new snoop filter entry, simply return a NULL
82 // portlist.
83 if (!is_hit && !allocate)
84 return snoopDown(lookupLatency);
85
86 // If no hit in snoop filter create a new element and update iterator
87 if (!is_hit)
88 reqLookupResult = cachedLocations.emplace(line_addr, SnoopItem()).first;
89 SnoopItem& sf_item = reqLookupResult->second;
90 SnoopMask interested = sf_item.holder | sf_item.requested;
91
92 // Store unmodified value of snoop filter item in temp storage in
93 // case we need to revert because of a send retry in
94 // updateRequest.
95 retryItem = sf_item;
96
97 totRequests++;
98 if (is_hit) {
99 // Single bit set -> value is a power of two
100 if (isPow2(interested))
101 hitSingleRequests++;
102 else
103 hitMultiRequests++;
104 }
105
106 DPRINTF(SnoopFilter, "%s: SF value %x.%x\n",
107 __func__, sf_item.requested, sf_item.holder);
108
109 // If we are not allocating, we are done
110 if (!allocate)
111 return snoopSelected(maskToPortList(interested & ~req_port),
112 lookupLatency);
113
114 if (cpkt->needsResponse()) {
115 if (!cpkt->cacheResponding()) {
116 // Max one request per address per port
117 panic_if(sf_item.requested & req_port, "double request :( " \
118 "SF value %x.%x\n", sf_item.requested, sf_item.holder);
119
120 // Mark in-flight requests to distinguish later on
121 sf_item.requested |= req_port;
122 DPRINTF(SnoopFilter, "%s: new SF value %x.%x\n",
123 __func__, sf_item.requested, sf_item.holder);
124 } else {
125 // NOTE: The memInhibit might have been asserted by a cache closer
126 // to the CPU, already -> the response will not be seen by this
127 // filter -> we do not need to keep the in-flight request, but make
128 // sure that we know that that cluster has a copy
129 panic_if(!(sf_item.holder & req_port), "Need to hold the value!");
130 DPRINTF(SnoopFilter,
131 "%s: not marking request. SF value %x.%x\n",
132 __func__, sf_item.requested, sf_item.holder);
133 }
134 } else { // if (!cpkt->needsResponse())
135 assert(cpkt->isEviction());
136 // make sure that the sender actually had the line
137 panic_if(!(sf_item.holder & req_port), "requester %x is not a " \
138 "holder :( SF value %x.%x\n", req_port,
139 sf_item.requested, sf_item.holder);
140 // CleanEvicts and Writebacks -> the sender and all caches above
141 // it may not have the line anymore.
142 if (!cpkt->isBlockCached()) {
143 sf_item.holder &= ~req_port;
144 DPRINTF(SnoopFilter, "%s: new SF value %x.%x\n",
145 __func__, sf_item.requested, sf_item.holder);
146 }
147 }
148
149 return snoopSelected(maskToPortList(interested & ~req_port), lookupLatency);
150}
151
152void
153SnoopFilter::finishRequest(bool will_retry, Addr addr, bool is_secure)
154{
155 if (reqLookupResult != cachedLocations.end()) {
156 // since we rely on the caller, do a basic check to ensure
157 // that finishRequest is being called following lookupRequest
158 Addr line_addr = (addr & ~(Addr(linesize - 1)));
159 if (is_secure) {
160 line_addr |= LineSecure;
161 }
162 assert(reqLookupResult->first == line_addr);
163 if (will_retry) {
164 // Undo any changes made in lookupRequest to the snoop filter
165 // entry if the request will come again. retryItem holds
166 // the previous value of the snoopfilter entry.
167 reqLookupResult->second = retryItem;
168
169 DPRINTF(SnoopFilter, "%s: restored SF value %x.%x\n",
170 __func__, retryItem.requested, retryItem.holder);
171 }
172
173 eraseIfNullEntry(reqLookupResult);
174 }
175}
176
177std::pair<SnoopFilter::SnoopList, Cycles>
178SnoopFilter::lookupSnoop(const Packet* cpkt)
179{
180 DPRINTF(SnoopFilter, "%s: packet %s\n", __func__, cpkt->print());
181
182 assert(cpkt->isRequest());
183
184 Addr line_addr = cpkt->getBlockAddr(linesize);
185 if (cpkt->isSecure()) {
186 line_addr |= LineSecure;
187 }
188 auto sf_it = cachedLocations.find(line_addr);
189 bool is_hit = (sf_it != cachedLocations.end());
190
191 panic_if(!is_hit && (cachedLocations.size() >= maxEntryCount),
192 "snoop filter exceeded capacity of %d cache blocks\n",
193 maxEntryCount);
194
195 // If the snoop filter has no entry, simply return a NULL
196 // portlist, there is no point creating an entry only to remove it
197 // later
198 if (!is_hit)
199 return snoopDown(lookupLatency);
200
201 SnoopItem& sf_item = sf_it->second;
202
203 DPRINTF(SnoopFilter, "%s: old SF value %x.%x\n",
204 __func__, sf_item.requested, sf_item.holder);
205
206 SnoopMask interested = (sf_item.holder | sf_item.requested);
207
208 totSnoops++;
209 // Single bit set -> value is a power of two
210 if (isPow2(interested))
211 hitSingleSnoops++;
212 else
213 hitMultiSnoops++;
214
215 // ReadEx and Writes require both invalidation and exlusivity, while reads
216 // require neither. Writebacks on the other hand require exclusivity but
217 // not the invalidation. Previously Writebacks did not generate upward
218 // snoops so this was never an aissue. Now that Writebacks generate snoops
219 // we need to special case for Writebacks.
220 assert(cpkt->isWriteback() || cpkt->req->isUncacheable() ||
221 (cpkt->isInvalidate() == cpkt->needsWritable()));
222 if (cpkt->isInvalidate() && !sf_item.requested) {
223 // Early clear of the holder, if no other request is currently going on
224 // @todo: This should possibly be updated even though we do not filter
225 // upward snoops
226 sf_item.holder = 0;
227 }
228
229 eraseIfNullEntry(sf_it);
230 DPRINTF(SnoopFilter, "%s: new SF value %x.%x interest: %x \n",
231 __func__, sf_item.requested, sf_item.holder, interested);
232
233 return snoopSelected(maskToPortList(interested), lookupLatency);
234}
235
236void
237SnoopFilter::updateSnoopResponse(const Packet* cpkt,
238 const SlavePort& rsp_port,
239 const SlavePort& req_port)
240{
241 DPRINTF(SnoopFilter, "%s: rsp %s req %s packet %s\n",
242 __func__, rsp_port.name(), req_port.name(), cpkt->print());
243
244 assert(cpkt->isResponse());
245 assert(cpkt->cacheResponding());
246
247 // if this snoop response is due to an uncacheable request, or is
248 // being turned into a normal response, there is nothing more to
249 // do
250 if (cpkt->req->isUncacheable() || !req_port.isSnooping()) {
251 return;
252 }
253
254 Addr line_addr = cpkt->getBlockAddr(linesize);
255 if (cpkt->isSecure()) {
256 line_addr |= LineSecure;
257 }
258 SnoopMask rsp_mask = portToMask(rsp_port);
259 SnoopMask req_mask = portToMask(req_port);
260 SnoopItem& sf_item = cachedLocations[line_addr];
261
262 DPRINTF(SnoopFilter, "%s: old SF value %x.%x\n",
263 __func__, sf_item.requested, sf_item.holder);
264
265 // The source should have the line
266 panic_if(!(sf_item.holder & rsp_mask), "SF value %x.%x does not have "\
267 "the line\n", sf_item.requested, sf_item.holder);
268
269 // The destination should have had a request in
270 panic_if(!(sf_item.requested & req_mask), "SF value %x.%x missing "\
271 "the original request\n", sf_item.requested, sf_item.holder);
272
273 // If the snoop response has no sharers the line is passed in
274 // Modified state, and we know that there are no other copies, or
275 // they will all be invalidated imminently
276 if (!cpkt->hasSharers()) {
277 DPRINTF(SnoopFilter,
278 "%s: dropping %x because non-shared snoop "
279 "response SF val: %x.%x\n", __func__, rsp_mask,
280 sf_item.requested, sf_item.holder);
281 sf_item.holder = 0;
282 }
283 assert(!cpkt->isWriteback());
284 // @todo Deal with invalidating responses
285 sf_item.holder |= req_mask;
286 sf_item.requested &= ~req_mask;
287 assert(sf_item.requested | sf_item.holder);
288 DPRINTF(SnoopFilter, "%s: new SF value %x.%x\n",
289 __func__, sf_item.requested, sf_item.holder);
290}
291
292void
293SnoopFilter::updateSnoopForward(const Packet* cpkt,
294 const SlavePort& rsp_port, const MasterPort& req_port)
295{
296 DPRINTF(SnoopFilter, "%s: rsp %s req %s packet %s\n",
297 __func__, rsp_port.name(), req_port.name(), cpkt->print());
298
299 assert(cpkt->isResponse());
300 assert(cpkt->cacheResponding());
301
302 Addr line_addr = cpkt->getBlockAddr(linesize);
303 if (cpkt->isSecure()) {
304 line_addr |= LineSecure;
305 }
306 auto sf_it = cachedLocations.find(line_addr);
307 bool is_hit = sf_it != cachedLocations.end();
308
309 // Nothing to do if it is not a hit
310 if (!is_hit)
311 return;
312
313 SnoopItem& sf_item = sf_it->second;
314
315 DPRINTF(SnoopFilter, "%s: old SF value %x.%x\n",
316 __func__, sf_item.requested, sf_item.holder);
317
318 // If the snoop response has no sharers the line is passed in
319 // Modified state, and we know that there are no other copies, or
320 // they will all be invalidated imminently
321 if (!cpkt->hasSharers()) {
322 sf_item.holder = 0;
323 }
324 DPRINTF(SnoopFilter, "%s: new SF value %x.%x\n",
325 __func__, sf_item.requested, sf_item.holder);
326 eraseIfNullEntry(sf_it);
327
328}
329
330void
331SnoopFilter::updateResponse(const Packet* cpkt, const SlavePort& slave_port)
332{
333 DPRINTF(SnoopFilter, "%s: src %s packet %s\n",
334 __func__, slave_port.name(), cpkt->print());
335
336 assert(cpkt->isResponse());
337
338 // we only allocate if the packet actually came from a cache, but
339 // start by checking if the port is snooping
340 if (cpkt->req->isUncacheable() || !slave_port.isSnooping())
341 return;
342
343 // next check if we actually allocated an entry
344 Addr line_addr = cpkt->getBlockAddr(linesize);
345 if (cpkt->isSecure()) {
346 line_addr |= LineSecure;
347 }
348 auto sf_it = cachedLocations.find(line_addr);
349 if (sf_it == cachedLocations.end())
350 return;
351
352 SnoopMask slave_mask = portToMask(slave_port);
353 SnoopItem& sf_item = sf_it->second;
354
355 DPRINTF(SnoopFilter, "%s: old SF value %x.%x\n",
356 __func__, sf_item.requested, sf_item.holder);
357
358 // Make sure we have seen the actual request, too
359 panic_if(!(sf_item.requested & slave_mask), "SF value %x.%x missing "\
360 "request bit\n", sf_item.requested, sf_item.holder);
361
362 // Update the residency of the cache line.
363 sf_item.holder |= slave_mask;
364 sf_item.requested &= ~slave_mask;
365 assert(sf_item.holder | sf_item.requested);
366 DPRINTF(SnoopFilter, "%s: new SF value %x.%x\n",
367 __func__, sf_item.requested, sf_item.holder);
368}
369
370void
371SnoopFilter::regStats()
372{
373 SimObject::regStats();
374
375 totRequests
376 .name(name() + ".tot_requests")
377 .desc("Total number of requests made to the snoop filter.");
378
379 hitSingleRequests
380 .name(name() + ".hit_single_requests")
381 .desc("Number of requests hitting in the snoop filter with a single "\
382 "holder of the requested data.");
383
384 hitMultiRequests
385 .name(name() + ".hit_multi_requests")
386 .desc("Number of requests hitting in the snoop filter with multiple "\
387 "(>1) holders of the requested data.");
388
389 totSnoops
390 .name(name() + ".tot_snoops")
391 .desc("Total number of snoops made to the snoop filter.");
392
393 hitSingleSnoops
394 .name(name() + ".hit_single_snoops")
395 .desc("Number of snoops hitting in the snoop filter with a single "\
396 "holder of the requested data.");
397
398 hitMultiSnoops
399 .name(name() + ".hit_multi_snoops")
400 .desc("Number of snoops hitting in the snoop filter with multiple "\
401 "(>1) holders of the requested data.");
402}
403
404SnoopFilter *
405SnoopFilterParams::create()
406{
407 return new SnoopFilter(this);
408}
| 48#include "base/trace.hh"
49#include "debug/SnoopFilter.hh"
50#include "sim/system.hh"
51
52void
53SnoopFilter::eraseIfNullEntry(SnoopFilterCache::iterator& sf_it)
54{
55 SnoopItem& sf_item = sf_it->second;
56 if (!(sf_item.requested | sf_item.holder)) {
57 cachedLocations.erase(sf_it);
58 DPRINTF(SnoopFilter, "%s: Removed SF entry.\n",
59 __func__);
60 }
61}
62
63std::pair<SnoopFilter::SnoopList, Cycles>
64SnoopFilter::lookupRequest(const Packet* cpkt, const SlavePort& slave_port)
65{
66 DPRINTF(SnoopFilter, "%s: src %s packet %s\n", __func__,
67 slave_port.name(), cpkt->print());
68
69 // check if the packet came from a cache
70 bool allocate = !cpkt->req->isUncacheable() && slave_port.isSnooping() &&
71 cpkt->fromCache();
72 Addr line_addr = cpkt->getBlockAddr(linesize);
73 if (cpkt->isSecure()) {
74 line_addr |= LineSecure;
75 }
76 SnoopMask req_port = portToMask(slave_port);
77 reqLookupResult = cachedLocations.find(line_addr);
78 bool is_hit = (reqLookupResult != cachedLocations.end());
79
80 // If the snoop filter has no entry, and we should not allocate,
81 // do not create a new snoop filter entry, simply return a NULL
82 // portlist.
83 if (!is_hit && !allocate)
84 return snoopDown(lookupLatency);
85
86 // If no hit in snoop filter create a new element and update iterator
87 if (!is_hit)
88 reqLookupResult = cachedLocations.emplace(line_addr, SnoopItem()).first;
89 SnoopItem& sf_item = reqLookupResult->second;
90 SnoopMask interested = sf_item.holder | sf_item.requested;
91
92 // Store unmodified value of snoop filter item in temp storage in
93 // case we need to revert because of a send retry in
94 // updateRequest.
95 retryItem = sf_item;
96
97 totRequests++;
98 if (is_hit) {
99 // Single bit set -> value is a power of two
100 if (isPow2(interested))
101 hitSingleRequests++;
102 else
103 hitMultiRequests++;
104 }
105
106 DPRINTF(SnoopFilter, "%s: SF value %x.%x\n",
107 __func__, sf_item.requested, sf_item.holder);
108
109 // If we are not allocating, we are done
110 if (!allocate)
111 return snoopSelected(maskToPortList(interested & ~req_port),
112 lookupLatency);
113
114 if (cpkt->needsResponse()) {
115 if (!cpkt->cacheResponding()) {
116 // Max one request per address per port
117 panic_if(sf_item.requested & req_port, "double request :( " \
118 "SF value %x.%x\n", sf_item.requested, sf_item.holder);
119
120 // Mark in-flight requests to distinguish later on
121 sf_item.requested |= req_port;
122 DPRINTF(SnoopFilter, "%s: new SF value %x.%x\n",
123 __func__, sf_item.requested, sf_item.holder);
124 } else {
125 // NOTE: The memInhibit might have been asserted by a cache closer
126 // to the CPU, already -> the response will not be seen by this
127 // filter -> we do not need to keep the in-flight request, but make
128 // sure that we know that that cluster has a copy
129 panic_if(!(sf_item.holder & req_port), "Need to hold the value!");
130 DPRINTF(SnoopFilter,
131 "%s: not marking request. SF value %x.%x\n",
132 __func__, sf_item.requested, sf_item.holder);
133 }
134 } else { // if (!cpkt->needsResponse())
135 assert(cpkt->isEviction());
136 // make sure that the sender actually had the line
137 panic_if(!(sf_item.holder & req_port), "requester %x is not a " \
138 "holder :( SF value %x.%x\n", req_port,
139 sf_item.requested, sf_item.holder);
140 // CleanEvicts and Writebacks -> the sender and all caches above
141 // it may not have the line anymore.
142 if (!cpkt->isBlockCached()) {
143 sf_item.holder &= ~req_port;
144 DPRINTF(SnoopFilter, "%s: new SF value %x.%x\n",
145 __func__, sf_item.requested, sf_item.holder);
146 }
147 }
148
149 return snoopSelected(maskToPortList(interested & ~req_port), lookupLatency);
150}
151
152void
153SnoopFilter::finishRequest(bool will_retry, Addr addr, bool is_secure)
154{
155 if (reqLookupResult != cachedLocations.end()) {
156 // since we rely on the caller, do a basic check to ensure
157 // that finishRequest is being called following lookupRequest
158 Addr line_addr = (addr & ~(Addr(linesize - 1)));
159 if (is_secure) {
160 line_addr |= LineSecure;
161 }
162 assert(reqLookupResult->first == line_addr);
163 if (will_retry) {
164 // Undo any changes made in lookupRequest to the snoop filter
165 // entry if the request will come again. retryItem holds
166 // the previous value of the snoopfilter entry.
167 reqLookupResult->second = retryItem;
168
169 DPRINTF(SnoopFilter, "%s: restored SF value %x.%x\n",
170 __func__, retryItem.requested, retryItem.holder);
171 }
172
173 eraseIfNullEntry(reqLookupResult);
174 }
175}
176
177std::pair<SnoopFilter::SnoopList, Cycles>
178SnoopFilter::lookupSnoop(const Packet* cpkt)
179{
180 DPRINTF(SnoopFilter, "%s: packet %s\n", __func__, cpkt->print());
181
182 assert(cpkt->isRequest());
183
184 Addr line_addr = cpkt->getBlockAddr(linesize);
185 if (cpkt->isSecure()) {
186 line_addr |= LineSecure;
187 }
188 auto sf_it = cachedLocations.find(line_addr);
189 bool is_hit = (sf_it != cachedLocations.end());
190
191 panic_if(!is_hit && (cachedLocations.size() >= maxEntryCount),
192 "snoop filter exceeded capacity of %d cache blocks\n",
193 maxEntryCount);
194
195 // If the snoop filter has no entry, simply return a NULL
196 // portlist, there is no point creating an entry only to remove it
197 // later
198 if (!is_hit)
199 return snoopDown(lookupLatency);
200
201 SnoopItem& sf_item = sf_it->second;
202
203 DPRINTF(SnoopFilter, "%s: old SF value %x.%x\n",
204 __func__, sf_item.requested, sf_item.holder);
205
206 SnoopMask interested = (sf_item.holder | sf_item.requested);
207
208 totSnoops++;
209 // Single bit set -> value is a power of two
210 if (isPow2(interested))
211 hitSingleSnoops++;
212 else
213 hitMultiSnoops++;
214
215 // ReadEx and Writes require both invalidation and exlusivity, while reads
216 // require neither. Writebacks on the other hand require exclusivity but
217 // not the invalidation. Previously Writebacks did not generate upward
218 // snoops so this was never an aissue. Now that Writebacks generate snoops
219 // we need to special case for Writebacks.
220 assert(cpkt->isWriteback() || cpkt->req->isUncacheable() ||
221 (cpkt->isInvalidate() == cpkt->needsWritable()));
222 if (cpkt->isInvalidate() && !sf_item.requested) {
223 // Early clear of the holder, if no other request is currently going on
224 // @todo: This should possibly be updated even though we do not filter
225 // upward snoops
226 sf_item.holder = 0;
227 }
228
229 eraseIfNullEntry(sf_it);
230 DPRINTF(SnoopFilter, "%s: new SF value %x.%x interest: %x \n",
231 __func__, sf_item.requested, sf_item.holder, interested);
232
233 return snoopSelected(maskToPortList(interested), lookupLatency);
234}
235
236void
237SnoopFilter::updateSnoopResponse(const Packet* cpkt,
238 const SlavePort& rsp_port,
239 const SlavePort& req_port)
240{
241 DPRINTF(SnoopFilter, "%s: rsp %s req %s packet %s\n",
242 __func__, rsp_port.name(), req_port.name(), cpkt->print());
243
244 assert(cpkt->isResponse());
245 assert(cpkt->cacheResponding());
246
247 // if this snoop response is due to an uncacheable request, or is
248 // being turned into a normal response, there is nothing more to
249 // do
250 if (cpkt->req->isUncacheable() || !req_port.isSnooping()) {
251 return;
252 }
253
254 Addr line_addr = cpkt->getBlockAddr(linesize);
255 if (cpkt->isSecure()) {
256 line_addr |= LineSecure;
257 }
258 SnoopMask rsp_mask = portToMask(rsp_port);
259 SnoopMask req_mask = portToMask(req_port);
260 SnoopItem& sf_item = cachedLocations[line_addr];
261
262 DPRINTF(SnoopFilter, "%s: old SF value %x.%x\n",
263 __func__, sf_item.requested, sf_item.holder);
264
265 // The source should have the line
266 panic_if(!(sf_item.holder & rsp_mask), "SF value %x.%x does not have "\
267 "the line\n", sf_item.requested, sf_item.holder);
268
269 // The destination should have had a request in
270 panic_if(!(sf_item.requested & req_mask), "SF value %x.%x missing "\
271 "the original request\n", sf_item.requested, sf_item.holder);
272
273 // If the snoop response has no sharers the line is passed in
274 // Modified state, and we know that there are no other copies, or
275 // they will all be invalidated imminently
276 if (!cpkt->hasSharers()) {
277 DPRINTF(SnoopFilter,
278 "%s: dropping %x because non-shared snoop "
279 "response SF val: %x.%x\n", __func__, rsp_mask,
280 sf_item.requested, sf_item.holder);
281 sf_item.holder = 0;
282 }
283 assert(!cpkt->isWriteback());
284 // @todo Deal with invalidating responses
285 sf_item.holder |= req_mask;
286 sf_item.requested &= ~req_mask;
287 assert(sf_item.requested | sf_item.holder);
288 DPRINTF(SnoopFilter, "%s: new SF value %x.%x\n",
289 __func__, sf_item.requested, sf_item.holder);
290}
291
292void
293SnoopFilter::updateSnoopForward(const Packet* cpkt,
294 const SlavePort& rsp_port, const MasterPort& req_port)
295{
296 DPRINTF(SnoopFilter, "%s: rsp %s req %s packet %s\n",
297 __func__, rsp_port.name(), req_port.name(), cpkt->print());
298
299 assert(cpkt->isResponse());
300 assert(cpkt->cacheResponding());
301
302 Addr line_addr = cpkt->getBlockAddr(linesize);
303 if (cpkt->isSecure()) {
304 line_addr |= LineSecure;
305 }
306 auto sf_it = cachedLocations.find(line_addr);
307 bool is_hit = sf_it != cachedLocations.end();
308
309 // Nothing to do if it is not a hit
310 if (!is_hit)
311 return;
312
313 SnoopItem& sf_item = sf_it->second;
314
315 DPRINTF(SnoopFilter, "%s: old SF value %x.%x\n",
316 __func__, sf_item.requested, sf_item.holder);
317
318 // If the snoop response has no sharers the line is passed in
319 // Modified state, and we know that there are no other copies, or
320 // they will all be invalidated imminently
321 if (!cpkt->hasSharers()) {
322 sf_item.holder = 0;
323 }
324 DPRINTF(SnoopFilter, "%s: new SF value %x.%x\n",
325 __func__, sf_item.requested, sf_item.holder);
326 eraseIfNullEntry(sf_it);
327
328}
329
330void
331SnoopFilter::updateResponse(const Packet* cpkt, const SlavePort& slave_port)
332{
333 DPRINTF(SnoopFilter, "%s: src %s packet %s\n",
334 __func__, slave_port.name(), cpkt->print());
335
336 assert(cpkt->isResponse());
337
338 // we only allocate if the packet actually came from a cache, but
339 // start by checking if the port is snooping
340 if (cpkt->req->isUncacheable() || !slave_port.isSnooping())
341 return;
342
343 // next check if we actually allocated an entry
344 Addr line_addr = cpkt->getBlockAddr(linesize);
345 if (cpkt->isSecure()) {
346 line_addr |= LineSecure;
347 }
348 auto sf_it = cachedLocations.find(line_addr);
349 if (sf_it == cachedLocations.end())
350 return;
351
352 SnoopMask slave_mask = portToMask(slave_port);
353 SnoopItem& sf_item = sf_it->second;
354
355 DPRINTF(SnoopFilter, "%s: old SF value %x.%x\n",
356 __func__, sf_item.requested, sf_item.holder);
357
358 // Make sure we have seen the actual request, too
359 panic_if(!(sf_item.requested & slave_mask), "SF value %x.%x missing "\
360 "request bit\n", sf_item.requested, sf_item.holder);
361
362 // Update the residency of the cache line.
363 sf_item.holder |= slave_mask;
364 sf_item.requested &= ~slave_mask;
365 assert(sf_item.holder | sf_item.requested);
366 DPRINTF(SnoopFilter, "%s: new SF value %x.%x\n",
367 __func__, sf_item.requested, sf_item.holder);
368}
369
370void
371SnoopFilter::regStats()
372{
373 SimObject::regStats();
374
375 totRequests
376 .name(name() + ".tot_requests")
377 .desc("Total number of requests made to the snoop filter.");
378
379 hitSingleRequests
380 .name(name() + ".hit_single_requests")
381 .desc("Number of requests hitting in the snoop filter with a single "\
382 "holder of the requested data.");
383
384 hitMultiRequests
385 .name(name() + ".hit_multi_requests")
386 .desc("Number of requests hitting in the snoop filter with multiple "\
387 "(>1) holders of the requested data.");
388
389 totSnoops
390 .name(name() + ".tot_snoops")
391 .desc("Total number of snoops made to the snoop filter.");
392
393 hitSingleSnoops
394 .name(name() + ".hit_single_snoops")
395 .desc("Number of snoops hitting in the snoop filter with a single "\
396 "holder of the requested data.");
397
398 hitMultiSnoops
399 .name(name() + ".hit_multi_snoops")
400 .desc("Number of snoops hitting in the snoop filter with multiple "\
401 "(>1) holders of the requested data.");
402}
403
404SnoopFilter *
405SnoopFilterParams::create()
406{
407 return new SnoopFilter(this);
408}
|