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()) * (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       assert(0);
  67   }
  68   assert(m_controller != NULL);
  69
  70   m_num_entries = m_size_bytes / RubySystem::getBlockSizeBytes();
  71   m_entries = new Directory_Entry*[m_num_entries];
  72   for (int i=0; i < m_num_entries; i++)
  73     m_entries[i] = NULL;
  74
  75   m_ram = g_system_ptr->getMemoryVector();
  76
  77   m_num_directories++;
  78   m_num_directories_bits = log_int(m_num_directories);
  79   m_total_size_bytes += m_size_bytes;
  80 }
  81
  82 DirectoryMemory::~DirectoryMemory()
  83 {
  84   // free up all the directory entries
  85   for (int i=0;i<m_num_entries;i++)
  86     if (m_entries[i] != NULL)
  87       delete m_entries;
  88   if (m_entries != NULL)
  89     delete [] m_entries;
  90 }
  91
  92 void DirectoryMemory::printConfig(ostream& out) const
  93 {
  94   out << "DirectoryMemory module config: " << m_name << endl;
  95   out << "  controller: " << m_controller->getName() << endl;
  96   out << "  version: " << m_version << endl;
  97   out << "  memory_bits: " << m_size_bits << endl;
  98   out << "  memory_size_bytes: " << m_size_bytes << endl;
  99   out << "  memory_size_Kbytes: " << double(m_size_bytes) / (1<<10) << endl;
 100   out << "  memory_size_Mbytes: " << double(m_size_bytes) / (1<<20) << endl;
 101   out << "  memory_size_Gbytes: " << double(m_size_bytes) / (1<<30) << endl;
 102 }
 103
 104 // Static method
 105 void DirectoryMemory::printGlobalConfig(ostream & out)
 106 {
 107   out << "DirectoryMemory Global Config: " << endl;
 108   out << "  number of directory memories: " << m_num_directories << endl;
 109   if (m_num_directories > 1) {
 110     out << "  number of selection bits: " << m_num_directories_bits << endl;
 111     out << "  selection bits: " << RubySystem::getBlockSizeBits()+m_num_directories_bits-1
 112         << "-" << RubySystem::getBlockSizeBits() << endl;
 113   }
 114   out << "  total memory size bytes: " << m_total_size_bytes << endl;
 115   out << "  total memory size bits: " << log_int(m_total_size_bytes) << endl;
 116
 117 }
 118
 119 int DirectoryMemory::mapAddressToDirectoryVersion(PhysAddress address)
 120 {
 121   if (m_num_directories_bits == 0) return 0;
 122   int ret = address.bitSelect(RubySystem::getBlockSizeBits(),
 123                               RubySystem::getBlockSizeBits()+m_num_directories_bits-1);
 124   return ret;
 125 }
 126
 127 // Public method
 128 bool DirectoryMemory::isPresent(PhysAddress address)
 129 {
 130   bool ret = (mapAddressToDirectoryVersion(address) == m_version);
 131   return ret;
 132 }
 133
 134 int DirectoryMemory::mapAddressToLocalIdx(PhysAddress address)
 135 {
 136   int ret = address.getAddress() >> (RubySystem::getBlockSizeBits() + m_num_directories_bits);
 137   return ret;
 138 }
 139
 140 Directory_Entry& DirectoryMemory::lookup(PhysAddress address)
 141 {
 142   assert(isPresent(address));
 143   Directory_Entry* entry;
 144   int idx = mapAddressToLocalIdx(address);
 145   entry = m_entries[idx];
 146   if (entry == NULL) {
 147     entry = new Directory_Entry;
 148     entry->getDataBlk().assign(m_ram->getBlockPtr(address));
 149     m_entries[idx] = entry;
 150   }
 151   return (*entry);
 152 }
 153 /*
 154 Directory_Entry& DirectoryMemory::lookup(PhysAddress address)
 155 {
 156   assert(isPresent(address));
 157   Index index = address.memoryModuleIndex();
 158
 159   if (index < 0 || index > m_size) {
 160     WARN_EXPR(address.getAddress());
 161     WARN_EXPR(index);
 162     WARN_EXPR(m_size);
 163     ERROR_MSG("Directory Memory Assertion: accessing memory out of range.");
 164   }
 165   Directory_Entry* entry = m_entries[index];
 166
 167   // allocate the directory entry on demand.
 168   if (entry == NULL) {
 169     entry = new Directory_Entry;
 170     entry->getDataBlk().assign(m_ram->getBlockPtr(address));
 171
 172     // store entry to the table
 173     m_entries[index] = entry;
 174   }
 175
 176   return (*entry);
 177 }
 178 */
 179
 180 void DirectoryMemory::invalidateBlock(PhysAddress address)
 181 {
 182   /*
 183   assert(isPresent(address));
 184
 185   Index index = address.memoryModuleIndex();
 186
 187   if (index < 0 || index > m_size) {
 188     ERROR_MSG("Directory Memory Assertion: accessing memory out of range.");
 189   }
 190
 191   if(m_entries[index] != NULL){
 192     delete m_entries[index];
 193     m_entries[index] = NULL;
 194   }
 195   */
 196 }
 197
 198 void DirectoryMemory::print(ostream& out) const
 199 {
 200
 201 }
 202