X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmem%2Fruby%2Fcommon%2FAddress.hh;h=d47ff9ac5d9e69f503a0a7b1ac9e3a46733c978f;hb=16ac48e6a419b75e6a9e86fab9cd2fd62ef9a574;hp=73327e617f6d390a207e621de2cf5018ab551854;hpb=a0651b8f6127c8b7994a165b525e93d87c470d20;p=gem5.git

diff --git a/src/mem/ruby/common/Address.hh b/src/mem/ruby/common/Address.hh
index 73327e617..d47ff9ac5 100644
--- a/src/mem/ruby/common/Address.hh
+++ b/src/mem/ruby/common/Address.hh
@@ -29,15 +29,14 @@
 #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;
@@ -61,46 +60,22 @@ class Address
     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)
@@ -128,11 +103,11 @@ operator<(const Address& obj1, const Address& obj2)
     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;
 }
 
@@ -150,10 +125,10 @@ operator!=(const Address& obj1, const Address& obj2)
 
 // 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);
@@ -167,11 +142,11 @@ Address::bitSelect(int small, int big) const
 
 // 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) {
@@ -187,13 +162,13 @@ Address::bitRemove(int small, int big) const
         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;
 
@@ -206,7 +181,7 @@ Address::maskLowOrderBits(int number) const
 }
 
 inline physical_address_t
-Address::maskHighOrderBits(int number) const
+Address::maskHighOrderBits(unsigned int number) const
 {
     physical_address_t mask;
 
@@ -219,56 +194,14 @@ Address::maskHighOrderBits(int number) const
 }
 
 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
@@ -277,7 +210,7 @@ template <> struct hash<Address>
         return (size_t)s.getAddress();
     }
 };
-/* namespace __hash_namespace */ }
+__hash_namespace_end
 
 namespace std {
 template <> struct equal_to<Address>
@@ -288,6 +221,6 @@ template <> struct equal_to<Address>
         return s1 == s2;
     }
 };
-/* namespace std */ }
+} // namespace std
 
 #endif // __MEM_RUBY_COMMON_ADDRESS_HH__