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