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/ruby/slicc_interface/AbstractController.hh"
  43 #include "mem/gems_common/util.hh"
  44
  45 int DirectoryMemory::m_num_directories = 0;
  46 int DirectoryMemory::m_num_directories_bits = 0;
  47 int DirectoryMemory::m_total_size_bytes = 0;
  48
  49 DirectoryMemory::DirectoryMemory(const string & name)
  50  : m_name(name)
  51 {
  52 }
  53
  54 void 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
  84 DirectoryMemory::~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
  94 void 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
 107 void 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
 121 int 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
 130 bool DirectoryMemory::isPresent(PhysAddress address)
 131 {
 132   bool ret = (mapAddressToDirectoryVersion(address) == m_version);
 133   return ret;
 134 }
 135
 136 int DirectoryMemory::mapAddressToLocalIdx(PhysAddress address)
 137 {
 138   int ret = address.getAddress() >> (RubySystem::getBlockSizeBits() + m_num_directories_bits);
 139   return ret;
 140 }
 141
 142 Directory_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 /*
 156 Directory_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
 182 void 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
 200 void DirectoryMemory::print(ostream& out) const
 201 {
 202
 203 }
 204