PersistentTable.cc revision 7055
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/system/PersistentTable.hh" 31 32using namespace std; 33 34// randomize so that handoffs are not locality-aware 35#if 0 36int persistent_randomize[] = {0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 37 10, 14, 3, 7, 11, 15}; 38int persistent_randomize[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 39 10, 11, 12, 13, 14, 15}; 40#endif 41 42PersistentTable::PersistentTable() 43{ 44 m_map_ptr = new Map<Address, PersistentTableEntry>; 45} 46 47PersistentTable::~PersistentTable() 48{ 49 delete m_map_ptr; 50 m_map_ptr = NULL; 51} 52 53void 54PersistentTable::persistentRequestLock(const Address& address, 55 MachineID locker, 56 AccessType type) 57{ 58#if 0 59 if (locker == m_chip_ptr->getID()) 60 cout << "Chip " << m_chip_ptr->getID() << ": " << llocker 61 << " requesting lock for " << address << endl; 62 63 MachineID locker = (MachineID) persistent_randomize[llocker]; 64#endif 65 66 assert(address == line_address(address)); 67 if (!m_map_ptr->exist(address)) { 68 // Allocate if not present 69 PersistentTableEntry entry; 70 entry.m_starving.add(locker); 71 if (type == AccessType_Write) { 72 entry.m_request_to_write.add(locker); 73 } 74 m_map_ptr->add(address, entry); 75 } else { 76 PersistentTableEntry& entry = m_map_ptr->lookup(address); 77 78 // 79 // Make sure we're not already in the locked set 80 // 81 assert(!(entry.m_starving.isElement(locker))); 82 83 entry.m_starving.add(locker); 84 if (type == AccessType_Write) { 85 entry.m_request_to_write.add(locker); 86 } 87 assert(entry.m_marked.isSubset(entry.m_starving)); 88 } 89} 90 91void 92PersistentTable::persistentRequestUnlock(const Address& address, 93 MachineID unlocker) 94{ 95#if 0 96 if (unlocker == m_chip_ptr->getID()) 97 cout << "Chip " << m_chip_ptr->getID() << ": " << uunlocker 98 << " requesting unlock for " << address << endl; 99 100 MachineID unlocker = (MachineID) persistent_randomize[uunlocker]; 101#endif 102 103 assert(address == line_address(address)); 104 assert(m_map_ptr->exist(address)); 105 PersistentTableEntry& entry = m_map_ptr->lookup(address); 106 107 // 108 // Make sure we're in the locked set 109 // 110 assert(entry.m_starving.isElement(unlocker)); 111 assert(entry.m_marked.isSubset(entry.m_starving)); 112 entry.m_starving.remove(unlocker); 113 entry.m_marked.remove(unlocker); 114 entry.m_request_to_write.remove(unlocker); 115 assert(entry.m_marked.isSubset(entry.m_starving)); 116 117 // Deallocate if empty 118 if (entry.m_starving.isEmpty()) { 119 assert(entry.m_marked.isEmpty()); 120 m_map_ptr->erase(address); 121 } 122} 123 124bool 125PersistentTable::okToIssueStarving(const Address& address, 126 MachineID machId) const 127{ 128 assert(address == line_address(address)); 129 if (!m_map_ptr->exist(address)) { 130 // No entry present 131 return true; 132 } else if (m_map_ptr->lookup(address).m_starving.isElement(machId)) { 133 // We can't issue another lockdown until are previous unlock 134 // has occurred 135 return false; 136 } else { 137 return m_map_ptr->lookup(address).m_marked.isEmpty(); 138 } 139} 140 141MachineID 142PersistentTable::findSmallest(const Address& address) const 143{ 144 assert(address == line_address(address)); 145 assert(m_map_ptr->exist(address)); 146 const PersistentTableEntry& entry = m_map_ptr->lookup(address); 147 return entry.m_starving.smallestElement(); 148} 149 150AccessType 151PersistentTable::typeOfSmallest(const Address& address) const 152{ 153 assert(address == line_address(address)); 154 assert(m_map_ptr->exist(address)); 155 const PersistentTableEntry& entry = m_map_ptr->lookup(address); 156 if (entry.m_request_to_write. 157 isElement(entry.m_starving.smallestElement())) { 158 return AccessType_Write; 159 } else { 160 return AccessType_Read; 161 } 162} 163 164void 165PersistentTable::markEntries(const Address& address) 166{ 167 assert(address == line_address(address)); 168 if (m_map_ptr->exist(address)) { 169 PersistentTableEntry& entry = m_map_ptr->lookup(address); 170 171 // None should be marked 172 assert(entry.m_marked.isEmpty()); 173 174 // Mark all the nodes currently in the table 175 entry.m_marked = entry.m_starving; 176 } 177} 178 179bool 180PersistentTable::isLocked(const Address& address) const 181{ 182 assert(address == line_address(address)); 183 184 // If an entry is present, it must be locked 185 return m_map_ptr->exist(address); 186} 187 188int 189PersistentTable::countStarvingForAddress(const Address& address) const 190{ 191 if (m_map_ptr->exist(address)) { 192 PersistentTableEntry& entry = m_map_ptr->lookup(address); 193 return (entry.m_starving.count()); 194 } else { 195 return 0; 196 } 197} 198 199int 200PersistentTable::countReadStarvingForAddress(const Address& address) const 201{ 202 if (m_map_ptr->exist(address)) { 203 PersistentTableEntry& entry = m_map_ptr->lookup(address); 204 return (entry.m_starving.count() - entry.m_request_to_write.count()); 205 } else { 206 return 0; 207 } 208} 209 210void 211PersistentTable::print(ostream& out) const 212{ 213} 214 215