addr_range.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2012, 2014, 2017-2019, 2021 Arm Limited
 * All rights reserved
 *
 * The license below extends only to copyright in the software and shall
 * not be construed as granting a license to any other intellectual
 * property including but not limited to intellectual property relating
 * to a hardware implementation of the functionality of the software
 * licensed hereunder.  You may use the software subject to the license
 * terms below provided that you ensure that this notice is replicated
 * unmodified and in its entirety in all distributions of the software,
 * modified or unmodified, in source code or in binary form.
 *
 * Copyright (c) 2002-2005 The Regents of The University of Michigan
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef __BASE_ADDR_RANGE_HH__
#define __BASE_ADDR_RANGE_HH__
 
#include <algorithm>
#include <iterator>
#include <list>
#include <vector>
 
#include "base/bitfield.hh"
#include "base/cprintf.hh"
#include "base/logging.hh"
#include "base/types.hh"
 
namespace gem5
{
 
class AddrRange;

typedef std::list<AddrRange> AddrRangeList;

class AddrRange
{
 
  private:

    Addr _start;
    Addr _end;

    std::vector<Addr> masks;

    uint8_t intlvMatch;
 
  protected:
    struct Dummy {};
 
    // The dummy parameter Dummy distinguishes this from the other two argument
    // constructor which takes two Addrs.
    template <class Iterator>
    AddrRange(Dummy, Iterator begin_it, Iterator end_it)
        : _start(1), _end(0), intlvMatch(0)
    {
        if (begin_it != end_it) {
            // get the values from the first one and check the others
            _start = begin_it->_start;
            _end = begin_it->_end;
            masks = begin_it->masks;
            intlvMatch = begin_it->intlvMatch;
        }
 
        auto count = std::distance(begin_it, end_it);
        // either merge if got all ranges or keep this equal to the single
        // interleaved range
        if (count > 1) {
            fatal_if(count != (1ULL << masks.size()),
                    "Got %d ranges spanning %d interleaving bits.",
                    count, masks.size());
 
            uint8_t match = 0;
            for (auto it = begin_it; it != end_it; it++) {
                fatal_if(!mergesWith(*it),
                        "Can only merge ranges with the same start, end "
                        "and interleaving bits, %s %s.", to_string(),
                        it->to_string());
 
                fatal_if(it->intlvMatch != match,
                        "Expected interleave match %d but got %d when "
                        "merging.", match, it->intlvMatch);
                ++match;
            }
            masks.clear();
            intlvMatch = 0;
        }
    }
 
  public:

    AddrRange()
        : _start(1), _end(0), intlvMatch(0)
    {}

    AddrRange(Addr _start, Addr _end, const std::vector<Addr> &_masks,
              uint8_t _intlv_match)
        : _start(_start), _end(_end), masks(_masks),
          intlvMatch(_intlv_match)
    {
        // sanity checks
        fatal_if(!masks.empty() && _intlv_match >= 1ULL << masks.size(),
                 "Match value %d does not fit in %d interleaving bits\n",
                 _intlv_match, masks.size());
    }

    AddrRange(Addr _start, Addr _end, uint8_t _intlv_high_bit,
              uint8_t _xor_high_bit, uint8_t _intlv_bits,
              uint8_t _intlv_match)
        : _start(_start), _end(_end), masks(_intlv_bits),
          intlvMatch(_intlv_match)
    {
        // sanity checks
        fatal_if(_intlv_bits && _intlv_match >= 1ULL << _intlv_bits,
                 "Match value %d does not fit in %d interleaving bits\n",
                 _intlv_match, _intlv_bits);
 
        // ignore the XOR bits if not interleaving
        if (_intlv_bits && _xor_high_bit) {
            if (_xor_high_bit == _intlv_high_bit) {
                fatal("XOR and interleave high bit must be different\n");
            }  else if (_xor_high_bit > _intlv_high_bit) {
                if ((_xor_high_bit - _intlv_high_bit) < _intlv_bits)
                    fatal("XOR and interleave high bit must be at least "
                          "%d bits apart\n", _intlv_bits);
            } else {
                if ((_intlv_high_bit - _xor_high_bit) < _intlv_bits) {
                    fatal("Interleave and XOR high bit must be at least "
                          "%d bits apart\n", _intlv_bits);
                }
            }
        }
 
        for (auto i = 0; i < _intlv_bits; i++) {
            uint8_t bit1 = _intlv_high_bit - i;
            Addr mask = (1ULL << bit1);
            if (_xor_high_bit) {
                uint8_t bit2 = _xor_high_bit - i;
                mask |= (1ULL << bit2);
            }
            masks[_intlv_bits - i - 1] = mask;
        }
    }
 
    AddrRange(Addr _start, Addr _end)
        : _start(_start), _end(_end), intlvMatch(0)
    {}

    AddrRange(std::vector<AddrRange> ranges)
        : AddrRange(Dummy{}, ranges.begin(), ranges.end())
    {}
    AddrRange(std::list<AddrRange> ranges)
        : AddrRange(Dummy{}, ranges.begin(), ranges.end())
    {}

    bool interleaved() const { return masks.size() > 0; }

    uint64_t
    granularity() const
    {
        if (interleaved()) {
            auto combined_mask = 0;
            for (auto mask: masks) {
                combined_mask |= mask;
            }
            const uint8_t lowest_bit = ctz64(combined_mask);
            return 1ULL << lowest_bit;
        } else {
            return size();
        }
    }

    uint32_t stripes() const { return 1ULL << masks.size(); }

    Addr
    size() const
    {
        return (_end - _start) >> masks.size();
    }

    bool valid() const { return _start <= _end; }

    Addr start() const { return _start; }

    Addr end() const { return _end; }

    std::string
    to_string() const
    {
        if (interleaved()) {
            std::string str;
            for (unsigned int i = 0; i < masks.size(); i++) {
                str += " ";
                Addr mask = masks[i];
                while (mask) {
                    auto bit = ctz64(mask);
                    mask &= ~(1ULL << bit);
                    str += csprintf("a[%d]^", bit);
                }
                str += csprintf("\b=%d", bits(intlvMatch, i));
            }
            return csprintf("[%#llx:%#llx]%s", _start, _end, str);
        } else {
            return csprintf("[%#llx:%#llx]", _start, _end);
        }
    }

    bool
    mergesWith(const AddrRange& r) const
    {
        return r._start == _start && r._end == _end &&
            r.masks == masks;
    }

    bool
    intersects(const AddrRange& r) const
    {
        if (_start >= r._end || _end <= r._start) {
            // start with the simple case of no overlap at all,
            // applicable even if we have interleaved ranges
            return false;
        } else if (!interleaved() && !r.interleaved()) {
            // if neither range is interleaved, we are done
            return true;
        }
 
        // now it gets complicated, focus on the cases we care about
        if (r.size() == 1) {
            // keep it simple and check if the address is within
            // this range
            return contains(r.start());
        } else if (mergesWith(r)) {
            // restrict the check to ranges that belong to the
            // same chunk
            return intlvMatch == r.intlvMatch;
        } else {
            panic("Cannot test intersection of %s and %s\n",
                  to_string(), r.to_string());
        }
    }

    bool
    isSubset(const AddrRange& r) const
    {
        if (interleaved())
            panic("Cannot test subset of interleaved range %s\n", to_string());
 
        // This address range is not interleaved and therefore it
        // suffices to check the upper bound, the lower bound and
        // whether it would fit in a continuous segment of the input
        // addr range.
        if (r.interleaved()) {
          if (r.contains(_start) && size() <= r.granularity()) {
            // simplify checking for 1 element ranges
            // no need to re-check r.contains(_end -1) if
            // it is the same as _start
            if (_start == _end - 1) {
              return true;
            }
            //otherwise check if it also contains the end.
            return r.contains(_end -1);
          }
          return false;
        } else {
 
            if (_end <= _start){
                // Special case: if our range wraps around that is
                // _end is 2^64 so it wraps to 0.
                // In this case we will be a subset only if r._end
                // also wraps around.
                return _start >= r._start && r._end == 0;
            } else if (r._end <= r._start){
                // Special case: if r wraps around that is
                // r._end is 2^64 so it wraps to 0.
                // In this case we will be a subset only if our _start
                // is within r._start/ _end does not matter
                // because r wraps around.
                return _start >= r._start;
            } else {
                // Normal case: Check if our range is completely within 'r'.
                return _start >= r._start && _end <= r._end;
            }
 
        }
    }

    bool
    contains(const Addr& a) const
    {
        // check if the address is in the range and if there is either
        // no interleaving, or with interleaving also if the selected
        // bits from the address match the interleaving value
        bool in_range = a >= _start && a < _end;
        if (in_range) {
            auto sel = 0;
            for (unsigned int i = 0; i < masks.size(); i++) {
                Addr masked = a & masks[i];
                // The result of an xor operation is 1 if the number
                // of bits set is odd or 0 othersize, thefore it
                // suffices to count the number of bits set to
                // determine the i-th bit of sel.
                sel |= (popCount(masked) % 2) << i;
            }
            return sel == intlvMatch;
        }
        return false;
    }

    inline Addr
    removeIntlvBits(Addr a) const
    {
        // Directly return the address if the range is not interleaved
        // to prevent undefined behavior.
        if (!interleaved()) {
            return a;
        }
 
        // Get the LSB set from each mask
        auto masks_lsb = std::make_unique<int[]>(masks.size());
        for (unsigned int i = 0; i < masks.size(); i++) {
            masks_lsb[i] = ctz64(masks[i]);
        }
 
        // we need to sort the list of bits we will discard as we
        // discard them one by one starting.
        std::sort(masks_lsb.get(), masks_lsb.get() + masks.size());
 
        for (unsigned int i = 0; i < masks.size(); i++) {
            const int intlv_bit = masks_lsb[i];
            if (intlv_bit > 0) {
                // on every iteration we remove one bit from the input
                // address, and therefore the lowest invtl_bit has
                // also shifted to the right by i positions.
                a = insertBits(a >> 1, intlv_bit - i - 1, 0, a);
            } else {
                a >>= 1;
            }
        }
        return a;
    }

    inline Addr
    addIntlvBits(Addr a) const
    {
        // Directly return the address if the range is not interleaved
        // to prevent undefined behavior.
        if (!interleaved()) {
            return a;
        }
 
        // Get the LSB set from each mask
        auto masks_lsb = std::make_unique<int[]>(masks.size());
        for (unsigned int i = 0; i < masks.size(); i++) {
            masks_lsb[i] = ctz64(masks[i]);
        }
 
        // Add bits one-by-one from the LSB side.
        std::sort(masks_lsb.get(), masks_lsb.get() + masks.size());
        for (unsigned int i = 0; i < masks.size(); i++) {
            const int intlv_bit = masks_lsb[i];
            if (intlv_bit > 0) {
                // on every iteration we add one bit from the input
                // address, but the lowest invtl_bit in the iteration is
                // always in the right position because they are sorted
                // increasingly from the LSB
                a = insertBits(a << 1, intlv_bit - 1, 0, a);
            } else {
                a <<= 1;
            }
        }
 
        for (unsigned int i = 0; i < masks.size(); i++) {
            const int lsb = ctz64(masks[i]);
            const Addr intlv_bit = bits(intlvMatch, i);
            // Calculate the mask ignoring the LSB
            const Addr masked = a & masks[i] & ~(1 << lsb);
            // Set the LSB of the mask to whatever satisfies the selector bit
            a = insertBits(a, lsb, intlv_bit ^ popCount(masked));
        }
 
        return a;
    }

    Addr
    getOffset(const Addr& a) const
    {
        bool in_range = a >= _start && a < _end;
        if (!in_range) {
            return MaxAddr;
        }
        if (interleaved()) {
            return removeIntlvBits(a) - removeIntlvBits(_start);
        } else {
            return a - _start;
        }
    }

    AddrRangeList
    exclude(const AddrRangeList &exclude_ranges) const
    {
        assert(!interleaved());
 
        auto sorted_ranges = exclude_ranges;
        sorted_ranges.sort();
 
        std::list<AddrRange> ranges;
 
        Addr next_start = start();
        for (const auto &e : sorted_ranges) {
            assert(!e.interleaved());
            if (!intersects(e)) {
                continue;
            }
 
            if (e.start() <= next_start) {
                if (e.end() < end()) {
                    if (next_start < e.end()) {
                        next_start = e.end();
                    }
                } else {
                    return ranges;
                }
            } else {
                ranges.push_back(AddrRange(next_start, e.start()));
                if (e.end() < end()) {
                    next_start = e.end();
                } else {
                    return ranges;
                }
            }
        }
 
        if (next_start < end()) {
            ranges.push_back(AddrRange(next_start, end()));
        }
 
        return ranges;
    }
 
    AddrRangeList
    exclude(const AddrRange &excluded_range) const
    {
        return exclude(AddrRangeList{excluded_range});
    }

    bool
    operator<(const AddrRange& r) const
    {
        if (_start != r._start) {
            return _start < r._start;
        } else {
            // For now assume that the end is also the same.
            // If both regions are interleaved, assume same interleaving,
            // and compare intlvMatch values.
            // Otherwise, return true if this address range is interleaved.
            if (interleaved() && r.interleaved()) {
                return intlvMatch < r.intlvMatch;
            } else {
                return interleaved();
            }
        }
    }

    bool
    operator==(const AddrRange& r) const
    {
        if (_start != r._start)    return false;
        if (_end != r._end)      return false;
        if (masks != r.masks)         return false;
        if (intlvMatch != r.intlvMatch)   return false;
 
        return true;
    }

    bool
    operator!=(const AddrRange& r) const
    {
        return !(*this == r);
    }

    AddrRange
    operator&(const AddrRange& r) const
    {
        panic_if(this->interleaved() || r.interleaved(),
                 "Cannot calculate intersection of interleaved ranges.");
        Addr start = std::max(this->_start, r._start);
        Addr end = std::min(this->_end, r._end);
        if (end <= start) {
            return AddrRange(0, 0);
        }
        return AddrRange(start, end);
    }
};
 
static inline AddrRangeList
operator-(const AddrRange &range, const AddrRangeList &to_exclude)
{
    return range.exclude(to_exclude);
}
 
static inline AddrRangeList
operator-(const AddrRange &range, const AddrRange &to_exclude)
{
    return range.exclude(to_exclude);
}
 
static inline AddrRangeList
exclude(const AddrRangeList &base, AddrRangeList to_exclude)
{
    to_exclude.sort();
 
    AddrRangeList ret;
    for (const auto &range: base)
        ret.splice(ret.end(), range.exclude(to_exclude));
 
    return ret;
}
 
static inline AddrRangeList
exclude(const AddrRangeList &base, const AddrRange &to_exclude)
{
    return exclude(base, AddrRangeList{to_exclude});
}
 
static inline AddrRangeList
operator-(const AddrRangeList &base, const AddrRangeList &to_exclude)
{
    return exclude(base, to_exclude);
}
 
static inline AddrRangeList
operator-=(AddrRangeList &base, const AddrRangeList &to_exclude)
{
    base = base - to_exclude;
    return base;
}
 
static inline AddrRangeList
operator-(const AddrRangeList &base, const AddrRange &to_exclude)
{
    return exclude(base, to_exclude);
}
 
static inline AddrRangeList
operator-=(AddrRangeList &base, const AddrRange &to_exclude)
{
    base = base - to_exclude;
    return base;
}

inline AddrRange
RangeEx(Addr start, Addr end)
{
    return AddrRange(start, end);
}

inline AddrRange
RangeIn(Addr start, Addr end)
{
    return AddrRange(start, end + 1);
}

inline AddrRange
RangeSize(Addr start, Addr size)
{
    return AddrRange(start, start + size);
}
 
} // namespace gem5
 
#endif // __BASE_ADDR_RANGE_HH__