mshr.hh (11278:18411ccc4f3c) mshr.hh (11284:b3926db25371)
1/*
2 * Copyright (c) 2012-2013, 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

--- 66 unchanged lines hidden (view full) ---

75 Tick readyTime;
76
77 /** True if the request is uncacheable */
78 bool _isUncacheable;
79
80 /** Flag set by downstream caches */
81 bool downstreamPending;
82
1/*
2 * Copyright (c) 2012-2013, 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

--- 66 unchanged lines hidden (view full) ---

75 Tick readyTime;
76
77 /** True if the request is uncacheable */
78 bool _isUncacheable;
79
80 /** Flag set by downstream caches */
81 bool downstreamPending;
82
83 /** Will we have a dirty copy after this request? */
84 bool pendingDirty;
83 /**
84 * Here we use one flag to track both if:
85 *
86 * 1. We are going to become owner or not, i.e., we will get the
87 * block in an ownership state (Owned or Modified) with BlkDirty
88 * set. This determines whether or not we are going to become the
89 * responder and ordering point for future requests that we snoop.
90 *
91 * 2. We know that we are going to get a writable block, i.e. we
92 * will get the block in writable state (Exclusive or Modified
93 * state) with BlkWritable set. That determines whether additional
94 * targets with needsWritable set will be able to be satisfied, or
95 * if not should be put on the deferred list to possibly wait for
96 * another request that does give us writable access.
97 *
98 * Condition 2 is actually just a shortcut that saves us from
99 * possibly building a deferred target list and calling
100 * promoteWritable() every time we get a writable block. Condition
101 * 1, tracking ownership, is what is important. However, we never
102 * receive ownership without marking the block dirty, and
103 * consequently use pendingModified to track both ownership and
104 * writability rather than having separate pendingDirty and
105 * pendingWritable flags.
106 */
107 bool pendingModified;
85
86 /** Did we snoop an invalidate while waiting for data? */
87 bool postInvalidate;
88
89 /** Did we snoop a read while waiting for data? */
90 bool postDowngrade;
91
92 public:

--- 20 unchanged lines hidden (view full) ---

113 : recvTime(curTick()), readyTime(_readyTime), order(_order),
114 pkt(_pkt), source(_source), markedPending(_markedPending)
115 {}
116 };
117
118 class TargetList : public std::list<Target> {
119
120 public:
108
109 /** Did we snoop an invalidate while waiting for data? */
110 bool postInvalidate;
111
112 /** Did we snoop a read while waiting for data? */
113 bool postDowngrade;
114
115 public:

--- 20 unchanged lines hidden (view full) ---

136 : recvTime(curTick()), readyTime(_readyTime), order(_order),
137 pkt(_pkt), source(_source), markedPending(_markedPending)
138 {}
139 };
140
141 class TargetList : public std::list<Target> {
142
143 public:
121 bool needsExclusive;
144 bool needsWritable;
122 bool hasUpgrade;
123
124 TargetList();
145 bool hasUpgrade;
146
147 TargetList();
125 void resetFlags() { needsExclusive = hasUpgrade = false; }
126 bool isReset() const { return !needsExclusive && !hasUpgrade; }
148 void resetFlags() { needsWritable = hasUpgrade = false; }
149 bool isReset() const { return !needsWritable && !hasUpgrade; }
127 void add(PacketPtr pkt, Tick readyTime, Counter order,
128 Target::Source source, bool markPending);
129 void replaceUpgrades();
130 void clearDownstreamPending();
131 bool checkFunctional(PacketPtr pkt);
132 void print(std::ostream &os, int verbosity,
133 const std::string &prefix) const;
134 };

--- 29 unchanged lines hidden (view full) ---

164 /** Keep track of whether we should allocate on fill or not */
165 bool allocOnFill;
166
167 /** The pending* and post* flags are only valid if inService is
168 * true. Using the accessor functions lets us detect if these
169 * flags are accessed improperly.
170 */
171
150 void add(PacketPtr pkt, Tick readyTime, Counter order,
151 Target::Source source, bool markPending);
152 void replaceUpgrades();
153 void clearDownstreamPending();
154 bool checkFunctional(PacketPtr pkt);
155 void print(std::ostream &os, int verbosity,
156 const std::string &prefix) const;
157 };

--- 29 unchanged lines hidden (view full) ---

187 /** Keep track of whether we should allocate on fill or not */
188 bool allocOnFill;
189
190 /** The pending* and post* flags are only valid if inService is
191 * true. Using the accessor functions lets us detect if these
192 * flags are accessed improperly.
193 */
194
172 /** True if we need to get an exclusive copy of the block. */
173 bool needsExclusive() const { return targets.needsExclusive; }
195 /** True if we need to get a writable copy of the block. */
196 bool needsWritable() const { return targets.needsWritable; }
174
197
175 bool isPendingDirty() const {
176 assert(inService); return pendingDirty;
198 bool isPendingModified() const {
199 assert(inService); return pendingModified;
177 }
178
179 bool hasPostInvalidate() const {
180 assert(inService); return postInvalidate;
181 }
182
183 bool hasPostDowngrade() const {
184 assert(inService); return postDowngrade;

--- 33 unchanged lines hidden (view full) ---

218 * @param pkt The original miss.
219 * @param when_ready When should the MSHR be ready to act upon.
220 * @param _order The logical order of this MSHR
221 * @param alloc_on_fill Should the cache allocate a block on fill
222 */
223 void allocate(Addr blk_addr, unsigned blk_size, PacketPtr pkt,
224 Tick when_ready, Counter _order, bool alloc_on_fill);
225
200 }
201
202 bool hasPostInvalidate() const {
203 assert(inService); return postInvalidate;
204 }
205
206 bool hasPostDowngrade() const {
207 assert(inService); return postDowngrade;

--- 33 unchanged lines hidden (view full) ---

241 * @param pkt The original miss.
242 * @param when_ready When should the MSHR be ready to act upon.
243 * @param _order The logical order of this MSHR
244 * @param alloc_on_fill Should the cache allocate a block on fill
245 */
246 void allocate(Addr blk_addr, unsigned blk_size, PacketPtr pkt,
247 Tick when_ready, Counter _order, bool alloc_on_fill);
248
226 bool markInService(bool pending_dirty_resp);
249 bool markInService(bool pending_modified_resp);
227
228 void clearDownstreamPending();
229
230 /**
231 * Mark this MSHR as free.
232 */
233 void deallocate();
234

--- 44 unchanged lines hidden (view full) ---

279 if (getNumTargets() != 1)
280 return false;
281 const Target *tgt = &targets.front();
282 return tgt->source == Target::FromCPU && !tgt->pkt->needsResponse();
283 }
284
285 bool promoteDeferredTargets();
286
250
251 void clearDownstreamPending();
252
253 /**
254 * Mark this MSHR as free.
255 */
256 void deallocate();
257

--- 44 unchanged lines hidden (view full) ---

302 if (getNumTargets() != 1)
303 return false;
304 const Target *tgt = &targets.front();
305 return tgt->source == Target::FromCPU && !tgt->pkt->needsResponse();
306 }
307
308 bool promoteDeferredTargets();
309
287 void promoteExclusive();
310 void promoteWritable();
288
289 bool checkFunctional(PacketPtr pkt);
290
291 /**
292 * Prints the contents of this MSHR for debugging.
293 */
294 void print(std::ostream &os,
295 int verbosity = 0,
296 const std::string &prefix = "") const;
297 /**
298 * A no-args wrapper of print(std::ostream...) meant to be
299 * invoked from DPRINTFs avoiding string overheads in fast mode
300 *
301 * @return string with mshr fields + [deferred]targets
302 */
303 std::string print() const;
304};
305
306#endif // __MEM_CACHE_MSHR_HH__
311
312 bool checkFunctional(PacketPtr pkt);
313
314 /**
315 * Prints the contents of this MSHR for debugging.
316 */
317 void print(std::ostream &os,
318 int verbosity = 0,
319 const std::string &prefix = "") const;
320 /**
321 * A no-args wrapper of print(std::ostream...) meant to be
322 * invoked from DPRINTFs avoiding string overheads in fast mode
323 *
324 * @return string with mshr fields + [deferred]targets
325 */
326 std::string print() const;
327};
328
329#endif // __MEM_CACHE_MSHR_HH__