src/mem/ruby/common/Address.cc

   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/ruby/common/Address.hh"
  30 #include "mem/ruby/system/System.hh"
  31
  32 physical_address_t
  33 Address::getLineAddress() const
  34 {
  35     return bitSelect(RubySystem::getBlockSizeBits(), ADDRESS_WIDTH);
  36 }
  37
  38 physical_address_t
  39 Address::getOffset() const
  40 {
  41     return bitSelect(0, RubySystem::getBlockSizeBits() - 1);
  42 }
  43
  44 void
  45 Address::makeLineAddress()
  46 {
  47     m_address = maskLowOrderBits(RubySystem::getBlockSizeBits());
  48 }
  49
  50 // returns the next stride address based on line address
  51 void
  52 Address::makeNextStrideAddress(int stride)
  53 {
  54     m_address = maskLowOrderBits(RubySystem::getBlockSizeBits())
  55         + RubySystem::getBlockSizeBytes()*stride;
  56 }
  57
  58 integer_t
  59 Address::memoryModuleIndex() const
  60 {
  61     integer_t index =
  62         bitSelect(RubySystem::getBlockSizeBits() +
  63                   RubySystem::getMemorySizeBits(), ADDRESS_WIDTH);
  64     assert (index >= 0);
  65     return index;
  66
  67     // Index indexHighPortion =
  68     //     address.bitSelect(MEMORY_SIZE_BITS - 1,
  69     //                       PAGE_SIZE_BITS + NUMBER_OF_MEMORY_MODULE_BITS);
  70     // Index indexLowPortion =
  71     //     address.bitSelect(DATA_BLOCK_BITS, PAGE_SIZE_BITS - 1);
  72     //
  73     // Index index = indexLowPortion |
  74     //     (indexHighPortion << (PAGE_SIZE_BITS - DATA_BLOCK_BITS));
  75
  76     /*
  77       Round-robin mapping of addresses, at page size granularity
  78
  79 ADDRESS_WIDTH    MEMORY_SIZE_BITS        PAGE_SIZE_BITS  DATA_BLOCK_BITS
  80   |                    |                       |               |
  81  \ /                  \ /                     \ /             \ /       0
  82   -----------------------------------------------------------------------
  83   |       unused        |xxxxxxxxxxxxxxx|       |xxxxxxxxxxxxxxx|       |
  84   |                     |xxxxxxxxxxxxxxx|       |xxxxxxxxxxxxxxx|       |
  85   -----------------------------------------------------------------------
  86                         indexHighPortion         indexLowPortion
  87                                         <------->
  88                                NUMBER_OF_MEMORY_MODULE_BITS
  89     */
  90 }
  91
  92 void
  93 Address::print(std::ostream& out) const
  94 {
  95     using namespace std;
  96     out << "[" << hex << "0x" << m_address << "," << " line 0x"
  97         << maskLowOrderBits(RubySystem::getBlockSizeBits()) << dec << "]"
  98         << flush;
  99 }
 100
 101 void
 102 Address::output(std::ostream& out) const
 103 {
 104     // Note: this outputs addresses in the form "ffff", not "0xffff".
 105     // This code should always be able to write out addresses in a
 106     // format that can be read in by the below input() method.  Please
 107     // don't change this without talking to Milo first.
 108     out << std::hex << m_address << std::dec;
 109 }
 110
 111 void
 112 Address::input(std::istream& in)
 113 {
 114     // Note: this only works with addresses in the form "ffff", not
 115     // "0xffff".  This code should always be able to read in addresses
 116     // written out by the above output() method.  Please don't change
 117     // this without talking to Milo first.
 118     in >> std::hex >> m_address >> std::dec;
 119 }
 120
 121 Address::Address(const Address& obj)
 122 {
 123     m_address = obj.m_address;
 124 }
 125
 126 Address&
 127 Address::operator=(const Address& obj)
 128 {
 129     if (this == &obj) {
 130         // assert(false);
 131     } else {
 132         m_address = obj.m_address;
 133     }
 134     return *this;
 135 }
 136