1 2/* 3 * Copyright (c) 1999 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 * $Id$ 32 */ 33 34#ifndef ADDRESS_H 35#define ADDRESS_H 36 37#include <iomanip> 38 39#include "base/hashmap.hh" 40#include "mem/ruby/common/Global.hh" 41#include "mem/ruby/system/System.hh" 42#include "mem/ruby/system/NodeID.hh" 43#include "mem/ruby/system/MachineID.hh" 44 45const int ADDRESS_WIDTH = 64; // address width in bytes 46 47class Address; 48typedef Address PhysAddress; 49typedef Address VirtAddress; 50 51class Address { 52public: 53 // Constructors 54 Address() { m_address = 0; } 55 explicit Address(physical_address_t address) { m_address = address; } 56 57 Address(const Address& obj); 58 Address& operator=(const Address& obj); 59 60 // Destructor 61 // ~Address(); 62 63 // Public Methods 64 65 void setAddress(physical_address_t address) { m_address = address; } 66 physical_address_t getAddress() const {return m_address;} 67 // selects bits inclusive 68 physical_address_t bitSelect(int small, int big) const;
| 1 2/* 3 * Copyright (c) 1999 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 * $Id$ 32 */ 33 34#ifndef ADDRESS_H 35#define ADDRESS_H 36 37#include <iomanip> 38 39#include "base/hashmap.hh" 40#include "mem/ruby/common/Global.hh" 41#include "mem/ruby/system/System.hh" 42#include "mem/ruby/system/NodeID.hh" 43#include "mem/ruby/system/MachineID.hh" 44 45const int ADDRESS_WIDTH = 64; // address width in bytes 46 47class Address; 48typedef Address PhysAddress; 49typedef Address VirtAddress; 50 51class Address { 52public: 53 // Constructors 54 Address() { m_address = 0; } 55 explicit Address(physical_address_t address) { m_address = address; } 56 57 Address(const Address& obj); 58 Address& operator=(const Address& obj); 59 60 // Destructor 61 // ~Address(); 62 63 // Public Methods 64 65 void setAddress(physical_address_t address) { m_address = address; } 66 physical_address_t getAddress() const {return m_address;} 67 // selects bits inclusive 68 physical_address_t bitSelect(int small, int big) const;
|
| 69 physical_address_t bitRemove(int small, int big) const;
|
69 physical_address_t maskLowOrderBits(int number) const; 70 physical_address_t maskHighOrderBits(int number) const; 71 physical_address_t shiftLowOrderBits(int number) const; 72 physical_address_t getLineAddress() const 73 { return bitSelect(RubySystem::getBlockSizeBits(), ADDRESS_WIDTH); } 74 physical_address_t getOffset() const 75 { return bitSelect(0, RubySystem::getBlockSizeBits()-1); } 76 77 void makeLineAddress() { m_address = maskLowOrderBits(RubySystem::getBlockSizeBits()); } 78 // returns the next stride address based on line address 79 void makeNextStrideAddress( int stride) { 80 m_address = maskLowOrderBits(RubySystem::getBlockSizeBits()) 81 + RubySystem::getBlockSizeBytes()*stride; 82 } 83 int getBankSetNum() const; 84 int getBankSetDist() const; 85 86 Index memoryModuleIndex() const; 87 88 void print(ostream& out) const; 89 void output(ostream& out) const; 90 void input(istream& in); 91 92 void setOffset( int offset ){ 93 // first, zero out the offset bits 94 makeLineAddress(); 95 m_address |= (physical_address_t) offset; 96 } 97 98private: 99 // Private Methods 100 101 // Private copy constructor and assignment operator 102 // Address(const Address& obj); 103 // Address& operator=(const Address& obj); 104 105 // Data Members (m_ prefix) 106 physical_address_t m_address; 107}; 108 109inline 110Address line_address(const Address& addr) { Address temp(addr); temp.makeLineAddress(); return temp; } 111 112// Output operator declaration 113ostream& operator<<(ostream& out, const Address& obj); 114// comparison operator declaration 115bool operator==(const Address& obj1, const Address& obj2); 116bool operator!=(const Address& obj1, const Address& obj2); 117bool operator<(const Address& obj1, const Address& obj2); 118/* Address& operator=(const physical_address_t address); */ 119 120inline 121bool operator<(const Address& obj1, const Address& obj2) 122{ 123 return obj1.getAddress() < obj2.getAddress(); 124} 125 126// ******************* Definitions ******************* 127 128// Output operator definition 129inline 130ostream& operator<<(ostream& out, const Address& obj) 131{ 132 obj.print(out); 133 out << flush; 134 return out; 135} 136 137inline 138bool operator==(const Address& obj1, const Address& obj2) 139{ 140 return (obj1.getAddress() == obj2.getAddress()); 141} 142 143inline 144bool operator!=(const Address& obj1, const Address& obj2) 145{ 146 return (obj1.getAddress() != obj2.getAddress()); 147} 148 149inline 150physical_address_t Address::bitSelect(int small, int big) const // rips bits inclusive 151{ 152 physical_address_t mask; 153 assert((unsigned)big >= (unsigned)small); 154 155 if (big >= ADDRESS_WIDTH - 1) { 156 return (m_address >> small); 157 } else { 158 mask = ~((physical_address_t)~0 << (big + 1)); 159 // FIXME - this is slow to manipulate a 64-bit number using 32-bits 160 physical_address_t partial = (m_address & mask); 161 return (partial >> small); 162 } 163} 164
| 70 physical_address_t maskLowOrderBits(int number) const; 71 physical_address_t maskHighOrderBits(int number) const; 72 physical_address_t shiftLowOrderBits(int number) const; 73 physical_address_t getLineAddress() const 74 { return bitSelect(RubySystem::getBlockSizeBits(), ADDRESS_WIDTH); } 75 physical_address_t getOffset() const 76 { return bitSelect(0, RubySystem::getBlockSizeBits()-1); } 77 78 void makeLineAddress() { m_address = maskLowOrderBits(RubySystem::getBlockSizeBits()); } 79 // returns the next stride address based on line address 80 void makeNextStrideAddress( int stride) { 81 m_address = maskLowOrderBits(RubySystem::getBlockSizeBits()) 82 + RubySystem::getBlockSizeBytes()*stride; 83 } 84 int getBankSetNum() const; 85 int getBankSetDist() const; 86 87 Index memoryModuleIndex() const; 88 89 void print(ostream& out) const; 90 void output(ostream& out) const; 91 void input(istream& in); 92 93 void setOffset( int offset ){ 94 // first, zero out the offset bits 95 makeLineAddress(); 96 m_address |= (physical_address_t) offset; 97 } 98 99private: 100 // Private Methods 101 102 // Private copy constructor and assignment operator 103 // Address(const Address& obj); 104 // Address& operator=(const Address& obj); 105 106 // Data Members (m_ prefix) 107 physical_address_t m_address; 108}; 109 110inline 111Address line_address(const Address& addr) { Address temp(addr); temp.makeLineAddress(); return temp; } 112 113// Output operator declaration 114ostream& operator<<(ostream& out, const Address& obj); 115// comparison operator declaration 116bool operator==(const Address& obj1, const Address& obj2); 117bool operator!=(const Address& obj1, const Address& obj2); 118bool operator<(const Address& obj1, const Address& obj2); 119/* Address& operator=(const physical_address_t address); */ 120 121inline 122bool operator<(const Address& obj1, const Address& obj2) 123{ 124 return obj1.getAddress() < obj2.getAddress(); 125} 126 127// ******************* Definitions ******************* 128 129// Output operator definition 130inline 131ostream& operator<<(ostream& out, const Address& obj) 132{ 133 obj.print(out); 134 out << flush; 135 return out; 136} 137 138inline 139bool operator==(const Address& obj1, const Address& obj2) 140{ 141 return (obj1.getAddress() == obj2.getAddress()); 142} 143 144inline 145bool operator!=(const Address& obj1, const Address& obj2) 146{ 147 return (obj1.getAddress() != obj2.getAddress()); 148} 149 150inline 151physical_address_t Address::bitSelect(int small, int big) const // rips bits inclusive 152{ 153 physical_address_t mask; 154 assert((unsigned)big >= (unsigned)small); 155 156 if (big >= ADDRESS_WIDTH - 1) { 157 return (m_address >> small); 158 } else { 159 mask = ~((physical_address_t)~0 << (big + 1)); 160 // FIXME - this is slow to manipulate a 64-bit number using 32-bits 161 physical_address_t partial = (m_address & mask); 162 return (partial >> small); 163 } 164} 165
|
| 166// removes bits inclusive
|
165inline
| 167inline
|
| 168physical_address_t Address::bitRemove(int small, int big) const 169{ 170 physical_address_t mask; 171 assert((unsigned)big >= (unsigned)small); 172 173 if (small >= ADDRESS_WIDTH - 1) { 174 return m_address; 175 } else if (big >= ADDRESS_WIDTH - 1) { 176 mask = (physical_address_t)~0 >> small; 177 return (m_address & mask); 178 } else if (small == 0) { 179 mask = (physical_address_t)~0 << big; 180 return (m_address & mask); 181 } else { 182 mask = ~((physical_address_t)~0 << small); 183 physical_address_t lower_bits = m_address & mask; 184 mask = (physical_address_t)~0 << (big + 1); 185 physical_address_t higher_bits = m_address & mask; 186 187 // 188 // Shift the valid high bits over the removed section 189 // 190 higher_bits = higher_bits >> (big - small); 191 return (higher_bits | lower_bits); 192 } 193} 194 195inline
|
166physical_address_t Address::maskLowOrderBits(int number) const 167{ 168 physical_address_t mask; 169 170 if (number >= ADDRESS_WIDTH - 1) { 171 mask = ~0; 172 } else { 173 mask = (physical_address_t)~0 << number; 174 } 175 return (m_address & mask); 176} 177 178inline 179physical_address_t Address::maskHighOrderBits(int number) const 180{ 181 physical_address_t mask; 182 183 if (number >= ADDRESS_WIDTH - 1) { 184 mask = ~0; 185 } else { 186 mask = (physical_address_t)~0 >> number; 187 } 188 return (m_address & mask); 189} 190 191inline 192physical_address_t Address::shiftLowOrderBits(int number) const 193{ 194 return (m_address >> number); 195} 196 197inline 198integer_t Address::memoryModuleIndex() const 199{ 200 integer_t index = bitSelect(RubySystem::getBlockSizeBits()+RubySystem::getMemorySizeBits(), ADDRESS_WIDTH); 201 assert (index >= 0); 202 return index; 203 204 // Index indexHighPortion = address.bitSelect(MEMORY_SIZE_BITS-1, PAGE_SIZE_BITS+NUMBER_OF_MEMORY_MODULE_BITS); 205 // Index indexLowPortion = address.bitSelect(DATA_BLOCK_BITS, PAGE_SIZE_BITS-1); 206 207 //Index index = indexLowPortion | (indexHighPortion << (PAGE_SIZE_BITS - DATA_BLOCK_BITS)); 208 209 /* 210 Round-robin mapping of addresses, at page size granularity 211 212ADDRESS_WIDTH MEMORY_SIZE_BITS PAGE_SIZE_BITS DATA_BLOCK_BITS 213 | | | | 214 \ / \ / \ / \ / 0 215 ----------------------------------------------------------------------- 216 | unused |xxxxxxxxxxxxxxx| |xxxxxxxxxxxxxxx| | 217 | |xxxxxxxxxxxxxxx| |xxxxxxxxxxxxxxx| | 218 ----------------------------------------------------------------------- 219 indexHighPortion indexLowPortion 220 <-------> 221 NUMBER_OF_MEMORY_MODULE_BITS 222 */ 223} 224 225inline 226void Address::print(ostream& out) const 227{ 228 using namespace std; 229 out << "[" << hex << "0x" << m_address << "," << " line 0x" << maskLowOrderBits(RubySystem::getBlockSizeBits()) << dec << "]" << flush; 230} 231 232class Address; 233namespace __hash_namespace { 234 template <> struct hash<Address> 235 { 236 size_t operator()(const Address &s) const { return (size_t) s.getAddress(); } 237 }; 238} 239namespace std { 240 template <> struct equal_to<Address> 241 { 242 bool operator()(const Address& s1, const Address& s2) const { return s1 == s2; } 243 }; 244} 245 246#endif //ADDRESS_H 247
| 196physical_address_t Address::maskLowOrderBits(int number) const 197{ 198 physical_address_t mask; 199 200 if (number >= ADDRESS_WIDTH - 1) { 201 mask = ~0; 202 } else { 203 mask = (physical_address_t)~0 << number; 204 } 205 return (m_address & mask); 206} 207 208inline 209physical_address_t Address::maskHighOrderBits(int number) const 210{ 211 physical_address_t mask; 212 213 if (number >= ADDRESS_WIDTH - 1) { 214 mask = ~0; 215 } else { 216 mask = (physical_address_t)~0 >> number; 217 } 218 return (m_address & mask); 219} 220 221inline 222physical_address_t Address::shiftLowOrderBits(int number) const 223{ 224 return (m_address >> number); 225} 226 227inline 228integer_t Address::memoryModuleIndex() const 229{ 230 integer_t index = bitSelect(RubySystem::getBlockSizeBits()+RubySystem::getMemorySizeBits(), ADDRESS_WIDTH); 231 assert (index >= 0); 232 return index; 233 234 // Index indexHighPortion = address.bitSelect(MEMORY_SIZE_BITS-1, PAGE_SIZE_BITS+NUMBER_OF_MEMORY_MODULE_BITS); 235 // Index indexLowPortion = address.bitSelect(DATA_BLOCK_BITS, PAGE_SIZE_BITS-1); 236 237 //Index index = indexLowPortion | (indexHighPortion << (PAGE_SIZE_BITS - DATA_BLOCK_BITS)); 238 239 /* 240 Round-robin mapping of addresses, at page size granularity 241 242ADDRESS_WIDTH MEMORY_SIZE_BITS PAGE_SIZE_BITS DATA_BLOCK_BITS 243 | | | | 244 \ / \ / \ / \ / 0 245 ----------------------------------------------------------------------- 246 | unused |xxxxxxxxxxxxxxx| |xxxxxxxxxxxxxxx| | 247 | |xxxxxxxxxxxxxxx| |xxxxxxxxxxxxxxx| | 248 ----------------------------------------------------------------------- 249 indexHighPortion indexLowPortion 250 <-------> 251 NUMBER_OF_MEMORY_MODULE_BITS 252 */ 253} 254 255inline 256void Address::print(ostream& out) const 257{ 258 using namespace std; 259 out << "[" << hex << "0x" << m_address << "," << " line 0x" << maskLowOrderBits(RubySystem::getBlockSizeBits()) << dec << "]" << flush; 260} 261 262class Address; 263namespace __hash_namespace { 264 template <> struct hash<Address> 265 { 266 size_t operator()(const Address &s) const { return (size_t) s.getAddress(); } 267 }; 268} 269namespace std { 270 template <> struct equal_to<Address> 271 { 272 bool operator()(const Address& s1, const Address& s2) const { return s1 == s2; } 273 }; 274} 275 276#endif //ADDRESS_H 277
|