CacheMemory.cc (10980:7de6f95a0817) CacheMemory.cc (11019:fc1e41e88fd3)
1/*
2 * Copyright (c) 1999-2012 Mark D. Hill and David A. Wood
3 * Copyright (c) 2013 Advanced Micro Devices, Inc.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are
8 * met: redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer;
10 * redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution;
13 * neither the name of the copyright holders nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include "base/intmath.hh"
31#include "debug/RubyCache.hh"
32#include "debug/RubyCacheTrace.hh"
33#include "debug/RubyResourceStalls.hh"
34#include "debug/RubyStats.hh"
35#include "mem/protocol/AccessPermission.hh"
36#include "mem/ruby/structures/CacheMemory.hh"
37#include "mem/ruby/system/System.hh"
38
39using namespace std;
40
41ostream&
42operator<<(ostream& out, const CacheMemory& obj)
43{
44 obj.print(out);
45 out << flush;
46 return out;
47}
48
49CacheMemory *
50RubyCacheParams::create()
51{
52 return new CacheMemory(this);
53}
54
55CacheMemory::CacheMemory(const Params *p)
56 : SimObject(p),
57 dataArray(p->dataArrayBanks, p->dataAccessLatency,
58 p->start_index_bit, p->ruby_system),
59 tagArray(p->tagArrayBanks, p->tagAccessLatency,
60 p->start_index_bit, p->ruby_system)
61{
62 m_cache_size = p->size;
1/*
2 * Copyright (c) 1999-2012 Mark D. Hill and David A. Wood
3 * Copyright (c) 2013 Advanced Micro Devices, Inc.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are
8 * met: redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer;
10 * redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution;
13 * neither the name of the copyright holders nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include "base/intmath.hh"
31#include "debug/RubyCache.hh"
32#include "debug/RubyCacheTrace.hh"
33#include "debug/RubyResourceStalls.hh"
34#include "debug/RubyStats.hh"
35#include "mem/protocol/AccessPermission.hh"
36#include "mem/ruby/structures/CacheMemory.hh"
37#include "mem/ruby/system/System.hh"
38
39using namespace std;
40
41ostream&
42operator<<(ostream& out, const CacheMemory& obj)
43{
44 obj.print(out);
45 out << flush;
46 return out;
47}
48
49CacheMemory *
50RubyCacheParams::create()
51{
52 return new CacheMemory(this);
53}
54
55CacheMemory::CacheMemory(const Params *p)
56 : SimObject(p),
57 dataArray(p->dataArrayBanks, p->dataAccessLatency,
58 p->start_index_bit, p->ruby_system),
59 tagArray(p->tagArrayBanks, p->tagAccessLatency,
60 p->start_index_bit, p->ruby_system)
61{
62 m_cache_size = p->size;
63 m_latency = p->latency;
64 m_cache_assoc = p->assoc;
65 m_replacementPolicy_ptr = p->replacement_policy;
66 m_replacementPolicy_ptr->setCache(this);
67 m_start_index_bit = p->start_index_bit;
68 m_is_instruction_only_cache = p->is_icache;
69 m_resource_stalls = p->resourceStalls;
70}
71
72void
73CacheMemory::init()
74{
75 m_cache_num_sets = (m_cache_size / m_cache_assoc) /
76 RubySystem::getBlockSizeBytes();
77 assert(m_cache_num_sets > 1);
78 m_cache_num_set_bits = floorLog2(m_cache_num_sets);
79 assert(m_cache_num_set_bits > 0);
80
81 m_cache.resize(m_cache_num_sets);
82 for (int i = 0; i < m_cache_num_sets; i++) {
83 m_cache[i].resize(m_cache_assoc);
84 for (int j = 0; j < m_cache_assoc; j++) {
85 m_cache[i][j] = NULL;
86 }
87 }
88}
89
90CacheMemory::~CacheMemory()
91{
92 if (m_replacementPolicy_ptr != NULL)
93 delete m_replacementPolicy_ptr;
94 for (int i = 0; i < m_cache_num_sets; i++) {
95 for (int j = 0; j < m_cache_assoc; j++) {
96 delete m_cache[i][j];
97 }
98 }
99}
100
101// convert a Address to its location in the cache
102int64
103CacheMemory::addressToCacheSet(const Address& address) const
104{
105 assert(address == line_address(address));
106 return address.bitSelect(m_start_index_bit,
107 m_start_index_bit + m_cache_num_set_bits - 1);
108}
109
110// Given a cache index: returns the index of the tag in a set.
111// returns -1 if the tag is not found.
112int
113CacheMemory::findTagInSet(int64 cacheSet, const Address& tag) const
114{
115 assert(tag == line_address(tag));
116 // search the set for the tags
117 m5::hash_map<Address, int>::const_iterator it = m_tag_index.find(tag);
118 if (it != m_tag_index.end())
119 if (m_cache[cacheSet][it->second]->m_Permission !=
120 AccessPermission_NotPresent)
121 return it->second;
122 return -1; // Not found
123}
124
125// Given a cache index: returns the index of the tag in a set.
126// returns -1 if the tag is not found.
127int
128CacheMemory::findTagInSetIgnorePermissions(int64 cacheSet,
129 const Address& tag) const
130{
131 assert(tag == line_address(tag));
132 // search the set for the tags
133 m5::hash_map<Address, int>::const_iterator it = m_tag_index.find(tag);
134 if (it != m_tag_index.end())
135 return it->second;
136 return -1; // Not found
137}
138
139// Given an unique cache block identifier (idx): return the valid address
140// stored by the cache block. If the block is invalid/notpresent, the
141// function returns the 0 address
142Address
143CacheMemory::getAddressAtIdx(int idx) const
144{
145 Address tmp(0);
146
147 int set = idx / m_cache_assoc;
148 assert(set < m_cache_num_sets);
149
150 int way = idx - set * m_cache_assoc;
151 assert (way < m_cache_assoc);
152
153 AbstractCacheEntry* entry = m_cache[set][way];
154 if (entry == NULL ||
155 entry->m_Permission == AccessPermission_Invalid ||
156 entry->m_Permission == AccessPermission_NotPresent) {
157 return tmp;
158 }
159 return entry->m_Address;
160}
161
162bool
163CacheMemory::tryCacheAccess(const Address& address, RubyRequestType type,
164 DataBlock*& data_ptr)
165{
166 assert(address == line_address(address));
167 DPRINTF(RubyCache, "address: %s\n", address);
168 int64 cacheSet = addressToCacheSet(address);
169 int loc = findTagInSet(cacheSet, address);
170 if (loc != -1) {
171 // Do we even have a tag match?
172 AbstractCacheEntry* entry = m_cache[cacheSet][loc];
173 m_replacementPolicy_ptr->touch(cacheSet, loc, curTick());
174 data_ptr = &(entry->getDataBlk());
175
176 if (entry->m_Permission == AccessPermission_Read_Write) {
177 return true;
178 }
179 if ((entry->m_Permission == AccessPermission_Read_Only) &&
180 (type == RubyRequestType_LD || type == RubyRequestType_IFETCH)) {
181 return true;
182 }
183 // The line must not be accessible
184 }
185 data_ptr = NULL;
186 return false;
187}
188
189bool
190CacheMemory::testCacheAccess(const Address& address, RubyRequestType type,
191 DataBlock*& data_ptr)
192{
193 assert(address == line_address(address));
194 DPRINTF(RubyCache, "address: %s\n", address);
195 int64 cacheSet = addressToCacheSet(address);
196 int loc = findTagInSet(cacheSet, address);
197
198 if (loc != -1) {
199 // Do we even have a tag match?
200 AbstractCacheEntry* entry = m_cache[cacheSet][loc];
201 m_replacementPolicy_ptr->touch(cacheSet, loc, curTick());
202 data_ptr = &(entry->getDataBlk());
203
204 return m_cache[cacheSet][loc]->m_Permission !=
205 AccessPermission_NotPresent;
206 }
207
208 data_ptr = NULL;
209 return false;
210}
211
212// tests to see if an address is present in the cache
213bool
214CacheMemory::isTagPresent(const Address& address) const
215{
216 assert(address == line_address(address));
217 int64 cacheSet = addressToCacheSet(address);
218 int loc = findTagInSet(cacheSet, address);
219
220 if (loc == -1) {
221 // We didn't find the tag
222 DPRINTF(RubyCache, "No tag match for address: %s\n", address);
223 return false;
224 }
225 DPRINTF(RubyCache, "address: %s found\n", address);
226 return true;
227}
228
229// Returns true if there is:
230// a) a tag match on this address or there is
231// b) an unused line in the same cache "way"
232bool
233CacheMemory::cacheAvail(const Address& address) const
234{
235 assert(address == line_address(address));
236
237 int64 cacheSet = addressToCacheSet(address);
238
239 for (int i = 0; i < m_cache_assoc; i++) {
240 AbstractCacheEntry* entry = m_cache[cacheSet][i];
241 if (entry != NULL) {
242 if (entry->m_Address == address ||
243 entry->m_Permission == AccessPermission_NotPresent) {
244 // Already in the cache or we found an empty entry
245 return true;
246 }
247 } else {
248 return true;
249 }
250 }
251 return false;
252}
253
254AbstractCacheEntry*
255CacheMemory::allocate(const Address& address, AbstractCacheEntry* entry, bool touch)
256{
257 assert(address == line_address(address));
258 assert(!isTagPresent(address));
259 assert(cacheAvail(address));
260 DPRINTF(RubyCache, "address: %s\n", address);
261
262 // Find the first open slot
263 int64 cacheSet = addressToCacheSet(address);
264 std::vector<AbstractCacheEntry*> &set = m_cache[cacheSet];
265 for (int i = 0; i < m_cache_assoc; i++) {
266 if (!set[i] || set[i]->m_Permission == AccessPermission_NotPresent) {
267 set[i] = entry; // Init entry
268 set[i]->m_Address = address;
269 set[i]->m_Permission = AccessPermission_Invalid;
270 DPRINTF(RubyCache, "Allocate clearing lock for addr: %x\n",
271 address);
272 set[i]->m_locked = -1;
273 m_tag_index[address] = i;
274
275 if (touch) {
276 m_replacementPolicy_ptr->touch(cacheSet, i, curTick());
277 }
278
279 return entry;
280 }
281 }
282 panic("Allocate didn't find an available entry");
283}
284
285void
286CacheMemory::deallocate(const Address& address)
287{
288 assert(address == line_address(address));
289 assert(isTagPresent(address));
290 DPRINTF(RubyCache, "address: %s\n", address);
291 int64 cacheSet = addressToCacheSet(address);
292 int loc = findTagInSet(cacheSet, address);
293 if (loc != -1) {
294 delete m_cache[cacheSet][loc];
295 m_cache[cacheSet][loc] = NULL;
296 m_tag_index.erase(address);
297 }
298}
299
300// Returns with the physical address of the conflicting cache line
301Address
302CacheMemory::cacheProbe(const Address& address) const
303{
304 assert(address == line_address(address));
305 assert(!cacheAvail(address));
306
307 int64 cacheSet = addressToCacheSet(address);
308 return m_cache[cacheSet][m_replacementPolicy_ptr->getVictim(cacheSet)]->
309 m_Address;
310}
311
312// looks an address up in the cache
313AbstractCacheEntry*
314CacheMemory::lookup(const Address& address)
315{
316 assert(address == line_address(address));
317 int64 cacheSet = addressToCacheSet(address);
318 int loc = findTagInSet(cacheSet, address);
319 if(loc == -1) return NULL;
320 return m_cache[cacheSet][loc];
321}
322
323// looks an address up in the cache
324const AbstractCacheEntry*
325CacheMemory::lookup(const Address& address) const
326{
327 assert(address == line_address(address));
328 int64 cacheSet = addressToCacheSet(address);
329 int loc = findTagInSet(cacheSet, address);
330 if(loc == -1) return NULL;
331 return m_cache[cacheSet][loc];
332}
333
334// Sets the most recently used bit for a cache block
335void
336CacheMemory::setMRU(const Address& address)
337{
338 int64 cacheSet = addressToCacheSet(address);
339 int loc = findTagInSet(cacheSet, address);
340
341 if(loc != -1)
342 m_replacementPolicy_ptr->touch(cacheSet, loc, curTick());
343}
344
345void
346CacheMemory::recordCacheContents(int cntrl, CacheRecorder* tr) const
347{
348 uint64 warmedUpBlocks = 0;
349 uint64 totalBlocks M5_VAR_USED = (uint64)m_cache_num_sets
350 * (uint64)m_cache_assoc;
351
352 for (int i = 0; i < m_cache_num_sets; i++) {
353 for (int j = 0; j < m_cache_assoc; j++) {
354 if (m_cache[i][j] != NULL) {
355 AccessPermission perm = m_cache[i][j]->m_Permission;
356 RubyRequestType request_type = RubyRequestType_NULL;
357 if (perm == AccessPermission_Read_Only) {
358 if (m_is_instruction_only_cache) {
359 request_type = RubyRequestType_IFETCH;
360 } else {
361 request_type = RubyRequestType_LD;
362 }
363 } else if (perm == AccessPermission_Read_Write) {
364 request_type = RubyRequestType_ST;
365 }
366
367 if (request_type != RubyRequestType_NULL) {
368 tr->addRecord(cntrl, m_cache[i][j]->m_Address.getAddress(),
369 0, request_type,
370 m_replacementPolicy_ptr->getLastAccess(i, j),
371 m_cache[i][j]->getDataBlk());
372 warmedUpBlocks++;
373 }
374 }
375 }
376 }
377
378 DPRINTF(RubyCacheTrace, "%s: %lli blocks of %lli total blocks"
379 "recorded %.2f%% \n", name().c_str(), warmedUpBlocks,
380 (uint64)m_cache_num_sets * (uint64)m_cache_assoc,
381 (float(warmedUpBlocks)/float(totalBlocks))*100.0);
382}
383
384void
385CacheMemory::print(ostream& out) const
386{
387 out << "Cache dump: " << name() << endl;
388 for (int i = 0; i < m_cache_num_sets; i++) {
389 for (int j = 0; j < m_cache_assoc; j++) {
390 if (m_cache[i][j] != NULL) {
391 out << " Index: " << i
392 << " way: " << j
393 << " entry: " << *m_cache[i][j] << endl;
394 } else {
395 out << " Index: " << i
396 << " way: " << j
397 << " entry: NULL" << endl;
398 }
399 }
400 }
401}
402
403void
404CacheMemory::printData(ostream& out) const
405{
406 out << "printData() not supported" << endl;
407}
408
409void
410CacheMemory::setLocked(const Address& address, int context)
411{
412 DPRINTF(RubyCache, "Setting Lock for addr: %x to %d\n", address, context);
413 assert(address == line_address(address));
414 int64 cacheSet = addressToCacheSet(address);
415 int loc = findTagInSet(cacheSet, address);
416 assert(loc != -1);
417 m_cache[cacheSet][loc]->m_locked = context;
418}
419
420void
421CacheMemory::clearLocked(const Address& address)
422{
423 DPRINTF(RubyCache, "Clear Lock for addr: %x\n", address);
424 assert(address == line_address(address));
425 int64 cacheSet = addressToCacheSet(address);
426 int loc = findTagInSet(cacheSet, address);
427 assert(loc != -1);
428 m_cache[cacheSet][loc]->m_locked = -1;
429}
430
431bool
432CacheMemory::isLocked(const Address& address, int context)
433{
434 assert(address == line_address(address));
435 int64 cacheSet = addressToCacheSet(address);
436 int loc = findTagInSet(cacheSet, address);
437 assert(loc != -1);
438 DPRINTF(RubyCache, "Testing Lock for addr: %llx cur %d con %d\n",
439 address, m_cache[cacheSet][loc]->m_locked, context);
440 return m_cache[cacheSet][loc]->m_locked == context;
441}
442
443void
444CacheMemory::regStats()
445{
446 m_demand_hits
447 .name(name() + ".demand_hits")
448 .desc("Number of cache demand hits")
449 ;
450
451 m_demand_misses
452 .name(name() + ".demand_misses")
453 .desc("Number of cache demand misses")
454 ;
455
456 m_demand_accesses
457 .name(name() + ".demand_accesses")
458 .desc("Number of cache demand accesses")
459 ;
460
461 m_demand_accesses = m_demand_hits + m_demand_misses;
462
463 m_sw_prefetches
464 .name(name() + ".total_sw_prefetches")
465 .desc("Number of software prefetches")
466 .flags(Stats::nozero)
467 ;
468
469 m_hw_prefetches
470 .name(name() + ".total_hw_prefetches")
471 .desc("Number of hardware prefetches")
472 .flags(Stats::nozero)
473 ;
474
475 m_prefetches
476 .name(name() + ".total_prefetches")
477 .desc("Number of prefetches")
478 .flags(Stats::nozero)
479 ;
480
481 m_prefetches = m_sw_prefetches + m_hw_prefetches;
482
483 m_accessModeType
484 .init(RubyRequestType_NUM)
485 .name(name() + ".access_mode")
486 .flags(Stats::pdf | Stats::total)
487 ;
488 for (int i = 0; i < RubyAccessMode_NUM; i++) {
489 m_accessModeType
490 .subname(i, RubyAccessMode_to_string(RubyAccessMode(i)))
491 .flags(Stats::nozero)
492 ;
493 }
494
495 numDataArrayReads
496 .name(name() + ".num_data_array_reads")
497 .desc("number of data array reads")
498 .flags(Stats::nozero)
499 ;
500
501 numDataArrayWrites
502 .name(name() + ".num_data_array_writes")
503 .desc("number of data array writes")
504 .flags(Stats::nozero)
505 ;
506
507 numTagArrayReads
508 .name(name() + ".num_tag_array_reads")
509 .desc("number of tag array reads")
510 .flags(Stats::nozero)
511 ;
512
513 numTagArrayWrites
514 .name(name() + ".num_tag_array_writes")
515 .desc("number of tag array writes")
516 .flags(Stats::nozero)
517 ;
518
519 numTagArrayStalls
520 .name(name() + ".num_tag_array_stalls")
521 .desc("number of stalls caused by tag array")
522 .flags(Stats::nozero)
523 ;
524
525 numDataArrayStalls
526 .name(name() + ".num_data_array_stalls")
527 .desc("number of stalls caused by data array")
528 .flags(Stats::nozero)
529 ;
530}
531
532// assumption: SLICC generated files will only call this function
533// once **all** resources are granted
534void
535CacheMemory::recordRequestType(CacheRequestType requestType, Address addr)
536{
537 DPRINTF(RubyStats, "Recorded statistic: %s\n",
538 CacheRequestType_to_string(requestType));
539 switch(requestType) {
540 case CacheRequestType_DataArrayRead:
541 if (m_resource_stalls)
542 dataArray.reserve(addressToCacheSet(addr));
543 numDataArrayReads++;
544 return;
545 case CacheRequestType_DataArrayWrite:
546 if (m_resource_stalls)
547 dataArray.reserve(addressToCacheSet(addr));
548 numDataArrayWrites++;
549 return;
550 case CacheRequestType_TagArrayRead:
551 if (m_resource_stalls)
552 tagArray.reserve(addressToCacheSet(addr));
553 numTagArrayReads++;
554 return;
555 case CacheRequestType_TagArrayWrite:
556 if (m_resource_stalls)
557 tagArray.reserve(addressToCacheSet(addr));
558 numTagArrayWrites++;
559 return;
560 default:
561 warn("CacheMemory access_type not found: %s",
562 CacheRequestType_to_string(requestType));
563 }
564}
565
566bool
567CacheMemory::checkResourceAvailable(CacheResourceType res, Address addr)
568{
569 if (!m_resource_stalls) {
570 return true;
571 }
572
573 if (res == CacheResourceType_TagArray) {
574 if (tagArray.tryAccess(addressToCacheSet(addr))) return true;
575 else {
576 DPRINTF(RubyResourceStalls,
577 "Tag array stall on addr %s in set %d\n",
578 addr, addressToCacheSet(addr));
579 numTagArrayStalls++;
580 return false;
581 }
582 } else if (res == CacheResourceType_DataArray) {
583 if (dataArray.tryAccess(addressToCacheSet(addr))) return true;
584 else {
585 DPRINTF(RubyResourceStalls,
586 "Data array stall on addr %s in set %d\n",
587 addr, addressToCacheSet(addr));
588 numDataArrayStalls++;
589 return false;
590 }
591 } else {
592 assert(false);
593 return true;
594 }
595}
596
597bool
598CacheMemory::isBlockInvalid(int64 cache_set, int64 loc)
599{
600 return (m_cache[cache_set][loc]->m_Permission == AccessPermission_Invalid);
601}
602
603bool
604CacheMemory::isBlockNotBusy(int64 cache_set, int64 loc)
605{
606 return (m_cache[cache_set][loc]->m_Permission != AccessPermission_Busy);
607}
63 m_cache_assoc = p->assoc;
64 m_replacementPolicy_ptr = p->replacement_policy;
65 m_replacementPolicy_ptr->setCache(this);
66 m_start_index_bit = p->start_index_bit;
67 m_is_instruction_only_cache = p->is_icache;
68 m_resource_stalls = p->resourceStalls;
69}
70
71void
72CacheMemory::init()
73{
74 m_cache_num_sets = (m_cache_size / m_cache_assoc) /
75 RubySystem::getBlockSizeBytes();
76 assert(m_cache_num_sets > 1);
77 m_cache_num_set_bits = floorLog2(m_cache_num_sets);
78 assert(m_cache_num_set_bits > 0);
79
80 m_cache.resize(m_cache_num_sets);
81 for (int i = 0; i < m_cache_num_sets; i++) {
82 m_cache[i].resize(m_cache_assoc);
83 for (int j = 0; j < m_cache_assoc; j++) {
84 m_cache[i][j] = NULL;
85 }
86 }
87}
88
89CacheMemory::~CacheMemory()
90{
91 if (m_replacementPolicy_ptr != NULL)
92 delete m_replacementPolicy_ptr;
93 for (int i = 0; i < m_cache_num_sets; i++) {
94 for (int j = 0; j < m_cache_assoc; j++) {
95 delete m_cache[i][j];
96 }
97 }
98}
99
100// convert a Address to its location in the cache
101int64
102CacheMemory::addressToCacheSet(const Address& address) const
103{
104 assert(address == line_address(address));
105 return address.bitSelect(m_start_index_bit,
106 m_start_index_bit + m_cache_num_set_bits - 1);
107}
108
109// Given a cache index: returns the index of the tag in a set.
110// returns -1 if the tag is not found.
111int
112CacheMemory::findTagInSet(int64 cacheSet, const Address& tag) const
113{
114 assert(tag == line_address(tag));
115 // search the set for the tags
116 m5::hash_map<Address, int>::const_iterator it = m_tag_index.find(tag);
117 if (it != m_tag_index.end())
118 if (m_cache[cacheSet][it->second]->m_Permission !=
119 AccessPermission_NotPresent)
120 return it->second;
121 return -1; // Not found
122}
123
124// Given a cache index: returns the index of the tag in a set.
125// returns -1 if the tag is not found.
126int
127CacheMemory::findTagInSetIgnorePermissions(int64 cacheSet,
128 const Address& tag) const
129{
130 assert(tag == line_address(tag));
131 // search the set for the tags
132 m5::hash_map<Address, int>::const_iterator it = m_tag_index.find(tag);
133 if (it != m_tag_index.end())
134 return it->second;
135 return -1; // Not found
136}
137
138// Given an unique cache block identifier (idx): return the valid address
139// stored by the cache block. If the block is invalid/notpresent, the
140// function returns the 0 address
141Address
142CacheMemory::getAddressAtIdx(int idx) const
143{
144 Address tmp(0);
145
146 int set = idx / m_cache_assoc;
147 assert(set < m_cache_num_sets);
148
149 int way = idx - set * m_cache_assoc;
150 assert (way < m_cache_assoc);
151
152 AbstractCacheEntry* entry = m_cache[set][way];
153 if (entry == NULL ||
154 entry->m_Permission == AccessPermission_Invalid ||
155 entry->m_Permission == AccessPermission_NotPresent) {
156 return tmp;
157 }
158 return entry->m_Address;
159}
160
161bool
162CacheMemory::tryCacheAccess(const Address& address, RubyRequestType type,
163 DataBlock*& data_ptr)
164{
165 assert(address == line_address(address));
166 DPRINTF(RubyCache, "address: %s\n", address);
167 int64 cacheSet = addressToCacheSet(address);
168 int loc = findTagInSet(cacheSet, address);
169 if (loc != -1) {
170 // Do we even have a tag match?
171 AbstractCacheEntry* entry = m_cache[cacheSet][loc];
172 m_replacementPolicy_ptr->touch(cacheSet, loc, curTick());
173 data_ptr = &(entry->getDataBlk());
174
175 if (entry->m_Permission == AccessPermission_Read_Write) {
176 return true;
177 }
178 if ((entry->m_Permission == AccessPermission_Read_Only) &&
179 (type == RubyRequestType_LD || type == RubyRequestType_IFETCH)) {
180 return true;
181 }
182 // The line must not be accessible
183 }
184 data_ptr = NULL;
185 return false;
186}
187
188bool
189CacheMemory::testCacheAccess(const Address& address, RubyRequestType type,
190 DataBlock*& data_ptr)
191{
192 assert(address == line_address(address));
193 DPRINTF(RubyCache, "address: %s\n", address);
194 int64 cacheSet = addressToCacheSet(address);
195 int loc = findTagInSet(cacheSet, address);
196
197 if (loc != -1) {
198 // Do we even have a tag match?
199 AbstractCacheEntry* entry = m_cache[cacheSet][loc];
200 m_replacementPolicy_ptr->touch(cacheSet, loc, curTick());
201 data_ptr = &(entry->getDataBlk());
202
203 return m_cache[cacheSet][loc]->m_Permission !=
204 AccessPermission_NotPresent;
205 }
206
207 data_ptr = NULL;
208 return false;
209}
210
211// tests to see if an address is present in the cache
212bool
213CacheMemory::isTagPresent(const Address& address) const
214{
215 assert(address == line_address(address));
216 int64 cacheSet = addressToCacheSet(address);
217 int loc = findTagInSet(cacheSet, address);
218
219 if (loc == -1) {
220 // We didn't find the tag
221 DPRINTF(RubyCache, "No tag match for address: %s\n", address);
222 return false;
223 }
224 DPRINTF(RubyCache, "address: %s found\n", address);
225 return true;
226}
227
228// Returns true if there is:
229// a) a tag match on this address or there is
230// b) an unused line in the same cache "way"
231bool
232CacheMemory::cacheAvail(const Address& address) const
233{
234 assert(address == line_address(address));
235
236 int64 cacheSet = addressToCacheSet(address);
237
238 for (int i = 0; i < m_cache_assoc; i++) {
239 AbstractCacheEntry* entry = m_cache[cacheSet][i];
240 if (entry != NULL) {
241 if (entry->m_Address == address ||
242 entry->m_Permission == AccessPermission_NotPresent) {
243 // Already in the cache or we found an empty entry
244 return true;
245 }
246 } else {
247 return true;
248 }
249 }
250 return false;
251}
252
253AbstractCacheEntry*
254CacheMemory::allocate(const Address& address, AbstractCacheEntry* entry, bool touch)
255{
256 assert(address == line_address(address));
257 assert(!isTagPresent(address));
258 assert(cacheAvail(address));
259 DPRINTF(RubyCache, "address: %s\n", address);
260
261 // Find the first open slot
262 int64 cacheSet = addressToCacheSet(address);
263 std::vector<AbstractCacheEntry*> &set = m_cache[cacheSet];
264 for (int i = 0; i < m_cache_assoc; i++) {
265 if (!set[i] || set[i]->m_Permission == AccessPermission_NotPresent) {
266 set[i] = entry; // Init entry
267 set[i]->m_Address = address;
268 set[i]->m_Permission = AccessPermission_Invalid;
269 DPRINTF(RubyCache, "Allocate clearing lock for addr: %x\n",
270 address);
271 set[i]->m_locked = -1;
272 m_tag_index[address] = i;
273
274 if (touch) {
275 m_replacementPolicy_ptr->touch(cacheSet, i, curTick());
276 }
277
278 return entry;
279 }
280 }
281 panic("Allocate didn't find an available entry");
282}
283
284void
285CacheMemory::deallocate(const Address& address)
286{
287 assert(address == line_address(address));
288 assert(isTagPresent(address));
289 DPRINTF(RubyCache, "address: %s\n", address);
290 int64 cacheSet = addressToCacheSet(address);
291 int loc = findTagInSet(cacheSet, address);
292 if (loc != -1) {
293 delete m_cache[cacheSet][loc];
294 m_cache[cacheSet][loc] = NULL;
295 m_tag_index.erase(address);
296 }
297}
298
299// Returns with the physical address of the conflicting cache line
300Address
301CacheMemory::cacheProbe(const Address& address) const
302{
303 assert(address == line_address(address));
304 assert(!cacheAvail(address));
305
306 int64 cacheSet = addressToCacheSet(address);
307 return m_cache[cacheSet][m_replacementPolicy_ptr->getVictim(cacheSet)]->
308 m_Address;
309}
310
311// looks an address up in the cache
312AbstractCacheEntry*
313CacheMemory::lookup(const Address& address)
314{
315 assert(address == line_address(address));
316 int64 cacheSet = addressToCacheSet(address);
317 int loc = findTagInSet(cacheSet, address);
318 if(loc == -1) return NULL;
319 return m_cache[cacheSet][loc];
320}
321
322// looks an address up in the cache
323const AbstractCacheEntry*
324CacheMemory::lookup(const Address& address) const
325{
326 assert(address == line_address(address));
327 int64 cacheSet = addressToCacheSet(address);
328 int loc = findTagInSet(cacheSet, address);
329 if(loc == -1) return NULL;
330 return m_cache[cacheSet][loc];
331}
332
333// Sets the most recently used bit for a cache block
334void
335CacheMemory::setMRU(const Address& address)
336{
337 int64 cacheSet = addressToCacheSet(address);
338 int loc = findTagInSet(cacheSet, address);
339
340 if(loc != -1)
341 m_replacementPolicy_ptr->touch(cacheSet, loc, curTick());
342}
343
344void
345CacheMemory::recordCacheContents(int cntrl, CacheRecorder* tr) const
346{
347 uint64 warmedUpBlocks = 0;
348 uint64 totalBlocks M5_VAR_USED = (uint64)m_cache_num_sets
349 * (uint64)m_cache_assoc;
350
351 for (int i = 0; i < m_cache_num_sets; i++) {
352 for (int j = 0; j < m_cache_assoc; j++) {
353 if (m_cache[i][j] != NULL) {
354 AccessPermission perm = m_cache[i][j]->m_Permission;
355 RubyRequestType request_type = RubyRequestType_NULL;
356 if (perm == AccessPermission_Read_Only) {
357 if (m_is_instruction_only_cache) {
358 request_type = RubyRequestType_IFETCH;
359 } else {
360 request_type = RubyRequestType_LD;
361 }
362 } else if (perm == AccessPermission_Read_Write) {
363 request_type = RubyRequestType_ST;
364 }
365
366 if (request_type != RubyRequestType_NULL) {
367 tr->addRecord(cntrl, m_cache[i][j]->m_Address.getAddress(),
368 0, request_type,
369 m_replacementPolicy_ptr->getLastAccess(i, j),
370 m_cache[i][j]->getDataBlk());
371 warmedUpBlocks++;
372 }
373 }
374 }
375 }
376
377 DPRINTF(RubyCacheTrace, "%s: %lli blocks of %lli total blocks"
378 "recorded %.2f%% \n", name().c_str(), warmedUpBlocks,
379 (uint64)m_cache_num_sets * (uint64)m_cache_assoc,
380 (float(warmedUpBlocks)/float(totalBlocks))*100.0);
381}
382
383void
384CacheMemory::print(ostream& out) const
385{
386 out << "Cache dump: " << name() << endl;
387 for (int i = 0; i < m_cache_num_sets; i++) {
388 for (int j = 0; j < m_cache_assoc; j++) {
389 if (m_cache[i][j] != NULL) {
390 out << " Index: " << i
391 << " way: " << j
392 << " entry: " << *m_cache[i][j] << endl;
393 } else {
394 out << " Index: " << i
395 << " way: " << j
396 << " entry: NULL" << endl;
397 }
398 }
399 }
400}
401
402void
403CacheMemory::printData(ostream& out) const
404{
405 out << "printData() not supported" << endl;
406}
407
408void
409CacheMemory::setLocked(const Address& address, int context)
410{
411 DPRINTF(RubyCache, "Setting Lock for addr: %x to %d\n", address, context);
412 assert(address == line_address(address));
413 int64 cacheSet = addressToCacheSet(address);
414 int loc = findTagInSet(cacheSet, address);
415 assert(loc != -1);
416 m_cache[cacheSet][loc]->m_locked = context;
417}
418
419void
420CacheMemory::clearLocked(const Address& address)
421{
422 DPRINTF(RubyCache, "Clear Lock for addr: %x\n", address);
423 assert(address == line_address(address));
424 int64 cacheSet = addressToCacheSet(address);
425 int loc = findTagInSet(cacheSet, address);
426 assert(loc != -1);
427 m_cache[cacheSet][loc]->m_locked = -1;
428}
429
430bool
431CacheMemory::isLocked(const Address& address, int context)
432{
433 assert(address == line_address(address));
434 int64 cacheSet = addressToCacheSet(address);
435 int loc = findTagInSet(cacheSet, address);
436 assert(loc != -1);
437 DPRINTF(RubyCache, "Testing Lock for addr: %llx cur %d con %d\n",
438 address, m_cache[cacheSet][loc]->m_locked, context);
439 return m_cache[cacheSet][loc]->m_locked == context;
440}
441
442void
443CacheMemory::regStats()
444{
445 m_demand_hits
446 .name(name() + ".demand_hits")
447 .desc("Number of cache demand hits")
448 ;
449
450 m_demand_misses
451 .name(name() + ".demand_misses")
452 .desc("Number of cache demand misses")
453 ;
454
455 m_demand_accesses
456 .name(name() + ".demand_accesses")
457 .desc("Number of cache demand accesses")
458 ;
459
460 m_demand_accesses = m_demand_hits + m_demand_misses;
461
462 m_sw_prefetches
463 .name(name() + ".total_sw_prefetches")
464 .desc("Number of software prefetches")
465 .flags(Stats::nozero)
466 ;
467
468 m_hw_prefetches
469 .name(name() + ".total_hw_prefetches")
470 .desc("Number of hardware prefetches")
471 .flags(Stats::nozero)
472 ;
473
474 m_prefetches
475 .name(name() + ".total_prefetches")
476 .desc("Number of prefetches")
477 .flags(Stats::nozero)
478 ;
479
480 m_prefetches = m_sw_prefetches + m_hw_prefetches;
481
482 m_accessModeType
483 .init(RubyRequestType_NUM)
484 .name(name() + ".access_mode")
485 .flags(Stats::pdf | Stats::total)
486 ;
487 for (int i = 0; i < RubyAccessMode_NUM; i++) {
488 m_accessModeType
489 .subname(i, RubyAccessMode_to_string(RubyAccessMode(i)))
490 .flags(Stats::nozero)
491 ;
492 }
493
494 numDataArrayReads
495 .name(name() + ".num_data_array_reads")
496 .desc("number of data array reads")
497 .flags(Stats::nozero)
498 ;
499
500 numDataArrayWrites
501 .name(name() + ".num_data_array_writes")
502 .desc("number of data array writes")
503 .flags(Stats::nozero)
504 ;
505
506 numTagArrayReads
507 .name(name() + ".num_tag_array_reads")
508 .desc("number of tag array reads")
509 .flags(Stats::nozero)
510 ;
511
512 numTagArrayWrites
513 .name(name() + ".num_tag_array_writes")
514 .desc("number of tag array writes")
515 .flags(Stats::nozero)
516 ;
517
518 numTagArrayStalls
519 .name(name() + ".num_tag_array_stalls")
520 .desc("number of stalls caused by tag array")
521 .flags(Stats::nozero)
522 ;
523
524 numDataArrayStalls
525 .name(name() + ".num_data_array_stalls")
526 .desc("number of stalls caused by data array")
527 .flags(Stats::nozero)
528 ;
529}
530
531// assumption: SLICC generated files will only call this function
532// once **all** resources are granted
533void
534CacheMemory::recordRequestType(CacheRequestType requestType, Address addr)
535{
536 DPRINTF(RubyStats, "Recorded statistic: %s\n",
537 CacheRequestType_to_string(requestType));
538 switch(requestType) {
539 case CacheRequestType_DataArrayRead:
540 if (m_resource_stalls)
541 dataArray.reserve(addressToCacheSet(addr));
542 numDataArrayReads++;
543 return;
544 case CacheRequestType_DataArrayWrite:
545 if (m_resource_stalls)
546 dataArray.reserve(addressToCacheSet(addr));
547 numDataArrayWrites++;
548 return;
549 case CacheRequestType_TagArrayRead:
550 if (m_resource_stalls)
551 tagArray.reserve(addressToCacheSet(addr));
552 numTagArrayReads++;
553 return;
554 case CacheRequestType_TagArrayWrite:
555 if (m_resource_stalls)
556 tagArray.reserve(addressToCacheSet(addr));
557 numTagArrayWrites++;
558 return;
559 default:
560 warn("CacheMemory access_type not found: %s",
561 CacheRequestType_to_string(requestType));
562 }
563}
564
565bool
566CacheMemory::checkResourceAvailable(CacheResourceType res, Address addr)
567{
568 if (!m_resource_stalls) {
569 return true;
570 }
571
572 if (res == CacheResourceType_TagArray) {
573 if (tagArray.tryAccess(addressToCacheSet(addr))) return true;
574 else {
575 DPRINTF(RubyResourceStalls,
576 "Tag array stall on addr %s in set %d\n",
577 addr, addressToCacheSet(addr));
578 numTagArrayStalls++;
579 return false;
580 }
581 } else if (res == CacheResourceType_DataArray) {
582 if (dataArray.tryAccess(addressToCacheSet(addr))) return true;
583 else {
584 DPRINTF(RubyResourceStalls,
585 "Data array stall on addr %s in set %d\n",
586 addr, addressToCacheSet(addr));
587 numDataArrayStalls++;
588 return false;
589 }
590 } else {
591 assert(false);
592 return true;
593 }
594}
595
596bool
597CacheMemory::isBlockInvalid(int64 cache_set, int64 loc)
598{
599 return (m_cache[cache_set][loc]->m_Permission == AccessPermission_Invalid);
600}
601
602bool
603CacheMemory::isBlockNotBusy(int64 cache_set, int64 loc)
604{
605 return (m_cache[cache_set][loc]->m_Permission != AccessPermission_Busy);
606}