ruby/structures/CacheMemory.cc

103 CacheMemory::addressToCacheSet(Addr address) const
105     assert(address == makeLineAddress(address));
106     return bitSelect(address, m_start_index_bit,
139 // Given an unique cache block identifier (idx): return the valid address
141 // function returns the 0 address
163 CacheMemory::tryCacheAccess(Addr address, RubyRequestType type,
166     assert(address == makeLineAddress(address));
167     DPRINTF(RubyCache, "address: %#x\n", address);
168     int64_t cacheSet = addressToCacheSet(address);
169     int loc = findTagInSet(cacheSet, address);
190 CacheMemory::testCacheAccess(Addr address, RubyRequestType type,
193     assert(address == makeLineAddress(address));
194     DPRINTF(RubyCache, "address: %#x\n", address);
195     int64_t cacheSet = addressToCacheSet(address);
196     int loc = findTagInSet(cacheSet, address);
212 // tests to see if an address is present in the cache
214 CacheMemory::isTagPresent(Addr address) const
216     assert(address == makeLineAddress(address));
217     int64_t cacheSet = addressToCacheSet(address);
218     int loc = findTagInSet(cacheSet, address);
222         DPRINTF(RubyCache, "No tag match for address: %#x\n", address);
225     DPRINTF(RubyCache, "address: %#x found\n", address);
230 //   a) a tag match on this address or there is
233 CacheMemory::cacheAvail(Addr address) const
235     assert(address == makeLineAddress(address));
237     int64_t cacheSet = addressToCacheSet(address);
242             if (entry->m_Address == address ||
255 CacheMemory::allocate(Addr address, AbstractCacheEntry *entry, bool touch)
257     assert(address == makeLineAddress(address));
258     assert(!isTagPresent(address));
259     assert(cacheAvail(address));
260     DPRINTF(RubyCache, "address: %#x\n", address);
263     int64_t cacheSet = addressToCacheSet(address);
272                     address);
275             set[i]->m_Address = address;
278                     address);
280             m_tag_index[address] = i;
295 CacheMemory::deallocate(Addr address)
297     assert(address == makeLineAddress(address));
298     assert(isTagPresent(address));
299     DPRINTF(RubyCache, "address: %#x\n", address);
300     int64_t cacheSet = addressToCacheSet(address);
301     int loc = findTagInSet(cacheSet, address);
305         m_tag_index.erase(address);
309 // Returns with the physical address of the conflicting cache line
311 CacheMemory::cacheProbe(Addr address) const
313     assert(address == makeLineAddress(address));
314     assert(!cacheAvail(address));
316     int64_t cacheSet = addressToCacheSet(address);
321 // looks an address up in the cache
323 CacheMemory::lookup(Addr address)
325     assert(address == makeLineAddress(address));
326     int64_t cacheSet = addressToCacheSet(address);
327     int loc = findTagInSet(cacheSet, address);
332 // looks an address up in the cache
334 CacheMemory::lookup(Addr address) const
336     assert(address == makeLineAddress(address));
337     int64_t cacheSet = addressToCacheSet(address);
338     int loc = findTagInSet(cacheSet, address);
345 CacheMemory::setMRU(Addr address)
347     int64_t cacheSet = addressToCacheSet(address);
348     int loc = findTagInSet(cacheSet, address);
363 CacheMemory::setMRU(Addr address, int occupancy)
365     int64_t cacheSet = addressToCacheSet(address);
366     int loc = findTagInSet(cacheSet, address);
457 CacheMemory::setLocked(Addr address, int context)
459     DPRINTF(RubyCache, "Setting Lock for addr: %#x to %d\n", address, context);
460     assert(address == makeLineAddress(address));
461     int64_t cacheSet = addressToCacheSet(address);
462     int loc = findTagInSet(cacheSet, address);
468 CacheMemory::clearLocked(Addr address)
470     DPRINTF(RubyCache, "Clear Lock for addr: %#x\n", address);
471     assert(address == makeLineAddress(address));
472     int64_t cacheSet = addressToCacheSet(address);
473     int loc = findTagInSet(cacheSet, address);
479 CacheMemory::isLocked(Addr address, int context)
481     assert(address == makeLineAddress(address));
482     int64_t cacheSet = addressToCacheSet(address);
483     int loc = findTagInSet(cacheSet, address);
486             address, m_cache[cacheSet][loc]->m_locked, context);