src/mem/ruby/system/DirectoryMemory.cc

   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/gems_common/util.hh"
  43
  44 int DirectoryMemory::m_num_directories = 0;
  45 int DirectoryMemory::m_num_directories_bits = 0;
  46 uint64_t DirectoryMemory::m_total_size_bytes = 0;
  47 int DirectoryMemory::m_numa_high_bit = 0;
  48
  49 DirectoryMemory::DirectoryMemory(const Params *p)
  50     : SimObject(p)
  51 {
  52     m_version = p->version;
  53     m_size_bytes = p->size;
  54     m_size_bits = log_int(m_size_bytes);
  55     m_num_entries = 0;
  56     m_use_map = p->use_map;
  57     m_map_levels = p->map_levels;
  58     m_numa_high_bit = p->numa_high_bit;
  59 }
  60
  61 void DirectoryMemory::init()
  62 {
  63   m_num_entries = m_size_bytes / RubySystem::getBlockSizeBytes();
  64
  65   if (m_use_map) {
  66       int entry_bits = log_int(m_num_entries);
  67       assert(entry_bits >= m_map_levels);
  68       m_sparseMemory = new SparseMemory(entry_bits, m_map_levels);
  69   } else {
  70       m_entries = new Directory_Entry*[m_num_entries];
  71       for (int i=0; i < m_num_entries; i++)
  72           m_entries[i] = NULL;
  73       m_ram = g_system_ptr->getMemoryVector();
  74   }
  75
  76   m_num_directories++;
  77   m_num_directories_bits = log_int(m_num_directories);
  78   m_total_size_bytes += m_size_bytes;
  79
  80   if (m_numa_high_bit == 0) {
  81       m_numa_high_bit = RubySystem::getMemorySizeBits();
  82   }
  83   assert(m_numa_high_bit != 0);
  84 }
  85
  86 DirectoryMemory::~DirectoryMemory()
  87 {
  88   // free up all the directory entries
  89   if (m_entries != NULL) {
  90       for (uint64 i = 0; i < m_num_entries; i++) {
  91           if (m_entries[i] != NULL) {
  92               delete m_entries[i];
  93           }
  94       }
  95       delete [] m_entries;
  96   } else if (m_use_map) {
  97       delete m_sparseMemory;
  98   }
  99 }
 100
 101 void DirectoryMemory::printConfig(ostream& out) const
 102 {
 103   out << "DirectoryMemory module config: " << m_name << endl;
 104   out << "  version: " << m_version << endl;
 105   out << "  memory_bits: " << m_size_bits << endl;
 106   out << "  memory_size_bytes: " << m_size_bytes << endl;
 107   out << "  memory_size_Kbytes: " << double(m_size_bytes) / (1<<10) << endl;
 108   out << "  memory_size_Mbytes: " << double(m_size_bytes) / (1<<20) << endl;
 109   out << "  memory_size_Gbytes: " << double(m_size_bytes) / (1<<30) << endl;
 110 }
 111
 112 // Static method
 113 void DirectoryMemory::printGlobalConfig(ostream & out)
 114 {
 115   out << "DirectoryMemory Global Config: " << endl;
 116   out << "  number of directory memories: " << m_num_directories << endl;
 117   if (m_num_directories > 1) {
 118     out << "  number of selection bits: " << m_num_directories_bits << endl;
 119     out << "  selection bits: " << m_numa_high_bit
 120         << "-" << m_numa_high_bit-m_num_directories_bits
 121         << endl;
 122   }
 123   out << "  total memory size bytes: " << m_total_size_bytes << endl;
 124   out << "  total memory bits: " << log_int(m_total_size_bytes) << endl;
 125
 126 }
 127
 128 uint64 DirectoryMemory::mapAddressToDirectoryVersion(PhysAddress address)
 129 {
 130   if (m_num_directories_bits == 0) return 0;
 131   uint64 ret = address.bitSelect(m_numa_high_bit - m_num_directories_bits,
 132                                  m_numa_high_bit);
 133   return ret;
 134 }
 135
 136 // Public method
 137 bool DirectoryMemory::isPresent(PhysAddress address)
 138 {
 139   bool ret = (mapAddressToDirectoryVersion(address) == m_version);
 140   return ret;
 141 }
 142
 143 uint64 DirectoryMemory::mapAddressToLocalIdx(PhysAddress address)
 144 {
 145     uint64 ret = address.bitRemove(m_numa_high_bit - m_num_directories_bits,
 146                                    m_numa_high_bit)
 147         >> (RubySystem::getBlockSizeBits());
 148     return ret;
 149 }
 150
 151 Directory_Entry& DirectoryMemory::lookup(PhysAddress address)
 152 {
 153   assert(isPresent(address));
 154   Directory_Entry* entry;
 155   uint64 idx;
 156   DEBUG_EXPR(CACHE_COMP, HighPrio, address);
 157
 158   if (m_use_map) {
 159     if (m_sparseMemory->exist(address)) {
 160       entry = m_sparseMemory->lookup(address);
 161       assert(entry != NULL);
 162     } else {
 163       //
 164       // Note: SparseMemory internally creates a new Directory Entry
 165       //
 166       m_sparseMemory->add(address);
 167       entry = m_sparseMemory->lookup(address);
 168     }
 169   } else {
 170     idx = mapAddressToLocalIdx(address);
 171     assert(idx < m_num_entries);
 172     entry = m_entries[idx];
 173
 174     if (entry == NULL) {
 175       entry = new Directory_Entry();
 176       entry->getDataBlk().assign(m_ram->getBlockPtr(address));
 177       m_entries[idx] = entry;
 178     }
 179   }
 180
 181   return (*entry);
 182 }
 183 /*
 184 Directory_Entry& DirectoryMemory::lookup(PhysAddress address)
 185 {
 186   assert(isPresent(address));
 187   Index index = address.memoryModuleIndex();
 188
 189   if (index < 0 || index > m_size) {
 190     WARN_EXPR(address.getAddress());
 191     WARN_EXPR(index);
 192     WARN_EXPR(m_size);
 193     ERROR_MSG("Directory Memory Assertion: accessing memory out of range.");
 194   }
 195   Directory_Entry* entry = m_entries[index];
 196
 197   // allocate the directory entry on demand.
 198   if (entry == NULL) {
 199     entry = new Directory_Entry;
 200     entry->getDataBlk().assign(m_ram->getBlockPtr(address));
 201
 202     // store entry to the table
 203     m_entries[index] = entry;
 204   }
 205
 206   return (*entry);
 207 }
 208 */
 209
 210 void DirectoryMemory::invalidateBlock(PhysAddress address)
 211 {
 212
 213   if (m_use_map) {
 214     assert(m_sparseMemory->exist(address));
 215     m_sparseMemory->remove(address);
 216   }
 217   /*
 218   else {
 219     assert(isPresent(address));
 220
 221     Index index = address.memoryModuleIndex();
 222
 223     if (index < 0 || index > m_size) {
 224       ERROR_MSG("Directory Memory Assertion: accessing memory out of range.");
 225     }
 226
 227     if(m_entries[index] != NULL){
 228       delete m_entries[index];
 229       m_entries[index] = NULL;
 230     }
 231   }
 232   */
 233
 234
 235 }
 236
 237 void DirectoryMemory::print(ostream& out) const
 238 {
 239
 240 }
 241
 242 void DirectoryMemory::printStats(ostream& out) const
 243 {
 244     if (m_use_map) {
 245         m_sparseMemory->printStats(out);
 246     }
 247 }
 248
 249 DirectoryMemory *
 250 RubyDirectoryMemoryParams::create()
 251 {
 252     return new DirectoryMemory(this);
 253 }