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