#ifndef __MEM_RUBY_COMMON_ADDRESS_HH__
#define __MEM_RUBY_COMMON_ADDRESS_HH__
+#include <cassert>
#include <iomanip>
+#include <iostream>
#include "base/hashmap.hh"
-#include "mem/ruby/common/Global.hh"
-#include "mem/ruby/system/MachineID.hh"
-#include "mem/ruby/system/NodeID.hh"
-#include "mem/ruby/system/System.hh"
+#include "mem/ruby/common/TypeDefines.hh"
-const int ADDRESS_WIDTH = 64; // address width in bytes
+const uint32_t ADDRESS_WIDTH = 64; // address width in bytes
class Address;
typedef Address PhysAddress;
void setAddress(physical_address_t address) { m_address = address; }
physical_address_t getAddress() const {return m_address;}
// selects bits inclusive
- physical_address_t bitSelect(int small, int big) const;
- physical_address_t bitRemove(int small, int big) const;
- physical_address_t maskLowOrderBits(int number) const;
- physical_address_t maskHighOrderBits(int number) const;
- physical_address_t shiftLowOrderBits(int number) const;
-
- physical_address_t
- getLineAddress() const
- {
- return bitSelect(RubySystem::getBlockSizeBits(), ADDRESS_WIDTH);
- }
-
- physical_address_t
- getOffset() const
- {
- return bitSelect(0, RubySystem::getBlockSizeBits() - 1);
- }
-
- void
- makeLineAddress()
- {
- m_address = maskLowOrderBits(RubySystem::getBlockSizeBits());
- }
-
- // returns the next stride address based on line address
- void
- makeNextStrideAddress(int stride)
- {
- m_address = maskLowOrderBits(RubySystem::getBlockSizeBits())
- + RubySystem::getBlockSizeBytes()*stride;
- }
+ physical_address_t bitSelect(unsigned int small, unsigned int big) const;
+ physical_address_t bitRemove(unsigned int small, unsigned int big) const;
+ physical_address_t maskLowOrderBits(unsigned int number) const;
+ physical_address_t maskHighOrderBits(unsigned int number) const;
+ physical_address_t shiftLowOrderBits(unsigned int number) const;
- int getBankSetNum() const;
- int getBankSetDist() const;
+ physical_address_t getLineAddress() const;
+ physical_address_t getOffset() const;
+ void makeLineAddress();
+ void makeNextStrideAddress(int stride);
- Index memoryModuleIndex() const;
+ int64 memoryModuleIndex() const;
- void print(ostream& out) const;
- void output(ostream& out) const;
- void input(istream& in);
+ void print(std::ostream& out) const;
+ void output(std::ostream& out) const;
+ void input(std::istream& in);
void
setOffset(int offset)
return obj1.getAddress() < obj2.getAddress();
}
-inline ostream&
-operator<<(ostream& out, const Address& obj)
+inline std::ostream&
+operator<<(std::ostream& out, const Address& obj)
{
obj.print(out);
- out << flush;
+ out << std::flush;
return out;
}
// rips bits inclusive
inline physical_address_t
-Address::bitSelect(int small, int big) const
+Address::bitSelect(unsigned int small, unsigned int big) const
{
physical_address_t mask;
- assert((unsigned)big >= (unsigned)small);
+ assert(big >= small);
if (big >= ADDRESS_WIDTH - 1) {
return (m_address >> small);
// removes bits inclusive
inline physical_address_t
-Address::bitRemove(int small, int big) const
+Address::bitRemove(unsigned int small, unsigned int big) const
{
physical_address_t mask;
- assert((unsigned)big >= (unsigned)small);
-
+ assert(big >= small);
+
if (small >= ADDRESS_WIDTH - 1) {
return m_address;
} else if (big >= ADDRESS_WIDTH - 1) {
physical_address_t higher_bits = m_address & mask;
// Shift the valid high bits over the removed section
- higher_bits = higher_bits >> (big - small);
+ higher_bits = higher_bits >> (big - small + 1);
return (higher_bits | lower_bits);
}
}
inline physical_address_t
-Address::maskLowOrderBits(int number) const
+Address::maskLowOrderBits(unsigned int number) const
{
physical_address_t mask;
}
inline physical_address_t
-Address::maskHighOrderBits(int number) const
+Address::maskHighOrderBits(unsigned int number) const
{
physical_address_t mask;
}
inline physical_address_t
-Address::shiftLowOrderBits(int number) const
+Address::shiftLowOrderBits(unsigned int number) const
{
return (m_address >> number);
}
-inline integer_t
-Address::memoryModuleIndex() const
-{
- integer_t index =
- bitSelect(RubySystem::getBlockSizeBits() +
- RubySystem::getMemorySizeBits(), ADDRESS_WIDTH);
- assert (index >= 0);
- return index;
-
- // Index indexHighPortion =
- // address.bitSelect(MEMORY_SIZE_BITS - 1,
- // PAGE_SIZE_BITS + NUMBER_OF_MEMORY_MODULE_BITS);
- // Index indexLowPortion =
- // address.bitSelect(DATA_BLOCK_BITS, PAGE_SIZE_BITS - 1);
- //
- // Index index = indexLowPortion |
- // (indexHighPortion << (PAGE_SIZE_BITS - DATA_BLOCK_BITS));
-
- /*
- Round-robin mapping of addresses, at page size granularity
-
-ADDRESS_WIDTH MEMORY_SIZE_BITS PAGE_SIZE_BITS DATA_BLOCK_BITS
- | | | |
- \ / \ / \ / \ / 0
- -----------------------------------------------------------------------
- | unused |xxxxxxxxxxxxxxx| |xxxxxxxxxxxxxxx| |
- | |xxxxxxxxxxxxxxx| |xxxxxxxxxxxxxxx| |
- -----------------------------------------------------------------------
- indexHighPortion indexLowPortion
- <------->
- NUMBER_OF_MEMORY_MODULE_BITS
- */
-}
-
-inline void
-Address::print(ostream& out) const
-{
- using namespace std;
- out << "[" << hex << "0x" << m_address << "," << " line 0x"
- << maskLowOrderBits(RubySystem::getBlockSizeBits()) << dec << "]"
- << flush;
-}
+Address next_stride_address(const Address& addr, int stride);
-class Address;
-namespace __hash_namespace {
+__hash_namespace_begin
template <> struct hash<Address>
{
size_t
return (size_t)s.getAddress();
}
};
-/* namespace __hash_namespace */ }
+__hash_namespace_end
namespace std {
template <> struct equal_to<Address>
return s1 == s2;
}
};
-/* namespace std */ }
+} // namespace std
#endif // __MEM_RUBY_COMMON_ADDRESS_HH__
projects / gem5.git / blobdiff