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__ |