DirectoryMemory.cc revision 6861
1 2/* 3 * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood 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/* 31 * DirectoryMemory.cc 32 * 33 * Description: See DirectoryMemory.hh 34 * 35 * $Id$ 36 * 37 */ 38 39#include "mem/ruby/system/System.hh" 40#include "mem/ruby/system/DirectoryMemory.hh" 41#include "mem/ruby/slicc_interface/RubySlicc_Util.hh" 42#include "mem/ruby/slicc_interface/AbstractController.hh" 43#include "mem/gems_common/util.hh" 44 45int DirectoryMemory::m_num_directories = 0; 46int DirectoryMemory::m_num_directories_bits = 0; 47uint64_t DirectoryMemory::m_total_size_bytes = 0; 48 49DirectoryMemory::DirectoryMemory(const string & name) 50 : m_name(name) 51{ 52} 53 54void DirectoryMemory::init(const vector<string> & argv) 55{ 56 m_controller = NULL; 57 for (vector<string>::const_iterator it = argv.begin(); it != argv.end(); it++) { 58 if ( (*it) == "version" ) 59 m_version = atoi( (*(++it)).c_str() ); 60 else if ( (*it) == "size_mb" ) { 61 m_size_bytes = atoi((*(++it)).c_str()) * static_cast<uint64>(1<<20); 62 m_size_bits = log_int(m_size_bytes); 63 } else if ( (*it) == "controller" ) { 64 m_controller = RubySystem::getController((*(++it))); 65 } else { 66 cerr << "DirectoryMemory: Unkown config parameter: " << (*it) << endl; 67 assert(0); 68 } 69 } 70 assert(m_controller != NULL); 71 72 m_num_entries = m_size_bytes / RubySystem::getBlockSizeBytes(); 73 m_entries = new Directory_Entry*[m_num_entries]; 74 for (int i=0; i < m_num_entries; i++) 75 m_entries[i] = NULL; 76 77 m_ram = g_system_ptr->getMemoryVector(); 78 79 m_num_directories++; 80 m_num_directories_bits = log_int(m_num_directories); 81 m_total_size_bytes += m_size_bytes; 82} 83 84DirectoryMemory::~DirectoryMemory() 85{ 86 // free up all the directory entries 87 for (int i=0;i<m_num_entries;i++) 88 if (m_entries[i] != NULL) 89 delete m_entries; 90 if (m_entries != NULL) 91 delete [] m_entries; 92} 93 94void DirectoryMemory::printConfig(ostream& out) const 95{ 96 out << "DirectoryMemory module config: " << m_name << endl; 97 out << " controller: " << m_controller->getName() << endl; 98 out << " version: " << m_version << endl; 99 out << " memory_bits: " << m_size_bits << endl; 100 out << " memory_size_bytes: " << m_size_bytes << endl; 101 out << " memory_size_Kbytes: " << double(m_size_bytes) / (1<<10) << endl; 102 out << " memory_size_Mbytes: " << double(m_size_bytes) / (1<<20) << endl; 103 out << " memory_size_Gbytes: " << double(m_size_bytes) / (1<<30) << endl; 104} 105 106// Static method 107void DirectoryMemory::printGlobalConfig(ostream & out) 108{ 109 out << "DirectoryMemory Global Config: " << endl; 110 out << " number of directory memories: " << m_num_directories << endl; 111 if (m_num_directories > 1) { 112 out << " number of selection bits: " << m_num_directories_bits << endl; 113 out << " selection bits: " << RubySystem::getBlockSizeBits()+m_num_directories_bits-1 114 << "-" << RubySystem::getBlockSizeBits() << endl; 115 } 116 out << " total memory size bytes: " << m_total_size_bytes << endl; 117 out << " total memory size bits: " << log_int(m_total_size_bytes) << endl; 118 119} 120 121int DirectoryMemory::mapAddressToDirectoryVersion(PhysAddress address) 122{ 123 if (m_num_directories_bits == 0) return 0; 124 int ret = address.bitSelect(RubySystem::getBlockSizeBits(), 125 RubySystem::getBlockSizeBits()+m_num_directories_bits-1); 126 return ret; 127} 128 129// Public method 130bool DirectoryMemory::isPresent(PhysAddress address) 131{ 132 bool ret = (mapAddressToDirectoryVersion(address) == m_version); 133 return ret; 134} 135 136int DirectoryMemory::mapAddressToLocalIdx(PhysAddress address) 137{ 138 int ret = address.getAddress() >> (RubySystem::getBlockSizeBits() + m_num_directories_bits); 139 return ret; 140} 141 142Directory_Entry& DirectoryMemory::lookup(PhysAddress address) 143{ 144 assert(isPresent(address)); 145 Directory_Entry* entry; 146 int idx = mapAddressToLocalIdx(address); 147 entry = m_entries[idx]; 148 if (entry == NULL) { 149 entry = new Directory_Entry; 150 entry->getDataBlk().assign(m_ram->getBlockPtr(address)); 151 m_entries[idx] = entry; 152 } 153 return (*entry); 154} 155/* 156Directory_Entry& DirectoryMemory::lookup(PhysAddress address) 157{ 158 assert(isPresent(address)); 159 Index index = address.memoryModuleIndex(); 160 161 if (index < 0 || index > m_size) { 162 WARN_EXPR(address.getAddress()); 163 WARN_EXPR(index); 164 WARN_EXPR(m_size); 165 ERROR_MSG("Directory Memory Assertion: accessing memory out of range."); 166 } 167 Directory_Entry* entry = m_entries[index]; 168 169 // allocate the directory entry on demand. 170 if (entry == NULL) { 171 entry = new Directory_Entry; 172 entry->getDataBlk().assign(m_ram->getBlockPtr(address)); 173 174 // store entry to the table 175 m_entries[index] = entry; 176 } 177 178 return (*entry); 179} 180*/ 181 182void DirectoryMemory::invalidateBlock(PhysAddress address) 183{ 184 /* 185 assert(isPresent(address)); 186 187 Index index = address.memoryModuleIndex(); 188 189 if (index < 0 || index > m_size) { 190 ERROR_MSG("Directory Memory Assertion: accessing memory out of range."); 191 } 192 193 if(m_entries[index] != NULL){ 194 delete m_entries[index]; 195 m_entries[index] = NULL; 196 } 197 */ 198} 199 200void DirectoryMemory::print(ostream& out) const 201{ 202 203} 204 205