DirectoryMemory.cc revision 7039 
1/*
2 * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include "mem/gems_common/util.hh"
30#include "mem/ruby/slicc_interface/RubySlicc_Util.hh"
31#include "mem/ruby/system/DirectoryMemory.hh"
32#include "mem/ruby/system/System.hh"
33
34int DirectoryMemory::m_num_directories = 0;
35int DirectoryMemory::m_num_directories_bits = 0;
36uint64_t DirectoryMemory::m_total_size_bytes = 0;
37int DirectoryMemory::m_numa_high_bit = 0;
38
39DirectoryMemory::DirectoryMemory(const Params *p)
40    : SimObject(p)
41{
42    m_version = p->version;
43    m_size_bytes = p->size;
44    m_size_bits = log_int(m_size_bytes);
45    m_num_entries = 0;
46    m_use_map = p->use_map;
47    m_map_levels = p->map_levels;
48    m_numa_high_bit = p->numa_high_bit;
49}
50
51void
52DirectoryMemory::init()
53{
54    m_num_entries = m_size_bytes / RubySystem::getBlockSizeBytes();
55
56    if (m_use_map) {
57        int entry_bits = log_int(m_num_entries);
58        assert(entry_bits >= m_map_levels);
59        m_sparseMemory = new SparseMemory(entry_bits, m_map_levels);
60    } else {
61        m_entries = new Directory_Entry*[m_num_entries];
62        for (int i = 0; i < m_num_entries; i++)
63            m_entries[i] = NULL;
64        m_ram = g_system_ptr->getMemoryVector();
65    }
66
67    m_num_directories++;
68    m_num_directories_bits = log_int(m_num_directories);
69    m_total_size_bytes += m_size_bytes;
70
71    if (m_numa_high_bit == 0) {
72        m_numa_high_bit = RubySystem::getMemorySizeBits();
73    }
74    assert(m_numa_high_bit != 0);
75}
76
77DirectoryMemory::~DirectoryMemory()
78{
79    // free up all the directory entries
80    if (m_entries != NULL) {
81        for (uint64 i = 0; i < m_num_entries; i++) {
82            if (m_entries[i] != NULL) {
83                delete m_entries[i];
84            }
85        }
86        delete [] m_entries;
87    } else if (m_use_map) {
88        delete m_sparseMemory;
89    }
90}
91
92void
93DirectoryMemory::printConfig(ostream& out) const
94{
95    out << "DirectoryMemory module config: " << m_name << endl
96        << "  version: " << m_version << endl
97        << "  memory_bits: " << m_size_bits << endl
98        << "  memory_size_bytes: " << m_size_bytes << endl
99        << "  memory_size_Kbytes: " << double(m_size_bytes) / (1<<10) << endl
100        << "  memory_size_Mbytes: " << double(m_size_bytes) / (1<<20) << endl
101        << "  memory_size_Gbytes: " << double(m_size_bytes) / (1<<30) << endl;
102}
103
104// Static method
105void
106DirectoryMemory::printGlobalConfig(ostream & out)
107{
108    out << "DirectoryMemory Global Config: " << endl;
109    out << "  number of directory memories: " << m_num_directories << endl;
110    if (m_num_directories > 1) {
111        out << "  number of selection bits: " << m_num_directories_bits << endl
112            << "  selection bits: " << m_numa_high_bit
113            << "-" << m_numa_high_bit-m_num_directories_bits
114            << endl;
115    }
116    out << "  total memory size bytes: " << m_total_size_bytes << endl;
117    out << "  total memory bits: " << log_int(m_total_size_bytes) << endl;
118}
119
120uint64
121DirectoryMemory::mapAddressToDirectoryVersion(PhysAddress address)
122{
123    if (m_num_directories_bits == 0)
124        return 0;
125
126    uint64 ret = address.bitSelect(m_numa_high_bit - m_num_directories_bits,
127                                   m_numa_high_bit);
128    return ret;
129}
130
131bool
132DirectoryMemory::isPresent(PhysAddress address)
133{
134    bool ret = (mapAddressToDirectoryVersion(address) == m_version);
135    return ret;
136}
137
138uint64
139DirectoryMemory::mapAddressToLocalIdx(PhysAddress address)
140{
141    uint64 ret = address.bitRemove(m_numa_high_bit - m_num_directories_bits,
142                                   m_numa_high_bit)
143        >> (RubySystem::getBlockSizeBits());
144    return ret;
145}
146
147Directory_Entry&
148DirectoryMemory::lookup(PhysAddress address)
149{
150    assert(isPresent(address));
151    Directory_Entry* entry;
152    uint64 idx;
153    DEBUG_EXPR(CACHE_COMP, HighPrio, address);
154
155    if (m_use_map) {
156        if (m_sparseMemory->exist(address)) {
157            entry = m_sparseMemory->lookup(address);
158            assert(entry != NULL);
159        } else {
160            // Note: SparseMemory internally creates a new Directory Entry
161            m_sparseMemory->add(address);
162            entry = m_sparseMemory->lookup(address);
163        }
164    } else {
165        idx = mapAddressToLocalIdx(address);
166        assert(idx < m_num_entries);
167        entry = m_entries[idx];
168
169        if (entry == NULL) {
170            entry = new Directory_Entry();
171            entry->getDataBlk().assign(m_ram->getBlockPtr(address));
172            m_entries[idx] = entry;
173        }
174    }
175
176    return *entry;
177}
178
179#if 0
180Directory_Entry&
181DirectoryMemory::lookup(PhysAddress address)
182{
183    assert(isPresent(address));
184    Index index = address.memoryModuleIndex();
185
186    if (index < 0 || index > m_size) {
187        WARN_EXPR(address.getAddress());
188        WARN_EXPR(index);
189        WARN_EXPR(m_size);
190        ERROR_MSG("Directory Memory Assertion: accessing memory out of range");
191    }
192    Directory_Entry* entry = m_entries[index];
193
194    // allocate the directory entry on demand.
195    if (entry == NULL) {
196        entry = new Directory_Entry;
197        entry->getDataBlk().assign(m_ram->getBlockPtr(address));
198
199        // store entry to the table
200        m_entries[index] = entry;
201    }
202
203    return *entry;
204}
205#endif
206
207void
208DirectoryMemory::invalidateBlock(PhysAddress address)
209{
210    if (m_use_map) {
211        assert(m_sparseMemory->exist(address));
212        m_sparseMemory->remove(address);
213    }
214#if 0
215    else {
216        assert(isPresent(address));
217
218        Index index = address.memoryModuleIndex();
219
220        if (index < 0 || index > m_size) {
221            ERROR_MSG("Directory Memory Assertion: "
222                      "accessing memory out of range.");
223        }
224
225        if (m_entries[index] != NULL){
226            delete m_entries[index];
227            m_entries[index] = NULL;
228        }
229    }
230#endif
231}
232
233void
234DirectoryMemory::print(ostream& out) const
235{
236}
237
238void
239DirectoryMemory::printStats(ostream& out) const
240{
241    if (m_use_map) {
242        m_sparseMemory->printStats(out);
243    }
244}
245
246DirectoryMemory *
247RubyDirectoryMemoryParams::create()
248{
249    return new DirectoryMemory(this);
250}
251