sanchayanmaity/gem5
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Clean up the Range class and associated usages. The code was

Browse source 
never clear about whether the end of the range was inclusive
or exclusive.  Make it inclusive, but also provide a RangeSize()
function that will generate a Range based on a start and a size.
This, in combination with using the comparison operators, makes
almost all usages of the range not care how it is stored.

base/range.cc:
    Make the end of the range inclusive.

    start/end -> first/last
    (end seems too much like end() in stl)
base/range.hh:
    Make the end of the range inclusive.

    Fix all comparison operators so that they work correctly with
    an inclusive range.  Also, when comparing one range to another
    with <, <=, >, >=, we only look at the beginning of the range
    beacuse x <= y should be the same as x < y || x == y.  (This wasn't
    the case before.)

    Add a few functions for making a range:
    RangeSize is start and size
    RangeEx is start and end where end is exclusive
    RangeIn is start and end where end is inclusive

    start/end -> first/last
    (end seems too much like end() in stl)
dev/alpha_console.cc:
dev/baddev.cc:
dev/ide_ctrl.cc:
dev/ns_gige.cc:
dev/pciconfigall.cc:
dev/pcidev.cc:
dev/tsunami_cchip.cc:
dev/tsunami_io.cc:
dev/tsunami_pchip.cc:
dev/uart.cc:
    Use the RangeSize function to create a range.

--HG--
extra : convert_revision : 29a7eb7fce745680f1c77fefff456c2144bc3994
This commit is contained in:
Nathan Binkert 2004-10-22 01:34:40 -04:00
parent f267dc4a87
commit b881408ed7
12 changed files with 98 additions and 142 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
base/range.cc
View file

@ -34,12 +34,12 @@ using namespace std;
template <class T>
bool
__x_parse_range(const std::string &str, T &start, T &end)
__x_parse_range(const std::string &str, T &first, T &last)
{
std::vector<std::string> values;
tokenize(values, str, ':');
T thestart, theend;
T thefirst, thelast;
if (values.size() != 2)
return false;
@ -47,29 +47,29 @@ __x_parse_range(const std::string &str, T &start, T &end)
std::string s = values[0];
std::string e = values[1];
if (!to_number(s, thestart))
if (!to_number(s, thefirst))
return false;
bool increment = (e[0] == '+');
if (increment)
e = e.substr(1);
if (!to_number(e, theend))
if (!to_number(e, thelast))
return false;
if (increment)
theend += thestart;
thelast += thefirst - 1;
start = thestart;
end = theend;
first = thefirst;
last = thelast;
return true;
}
#define RANGE_PARSE(type) \
template<> bool \
__parse_range(const std::string &s, type &start, type &end) \
{ return __x_parse_range(s, start, end); }
__parse_range(const std::string &s, type &first, type &last) \
{ return __x_parse_range(s, first, last); }
RANGE_PARSE(unsigned long long);
RANGE_PARSE(signed long long);

119
base/range.hh
View file

@ -26,44 +26,32 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __RANGE_HH__
#define __RANGE_HH__
#ifndef __BASE_RANGE_HH__
#define __BASE_RANGE_HH__
#include <cassert>
#include <string>
/**
* @param s range string
* EndExclusive Ranges are in the following format:
* <range> := {<start_val>}:{<end>}
* <start> := <end_val> | +<delta>
*/
template <class T>
bool __parse_range(const std::string &s, T &start, T &end);
template <class T>
struct Range
{
private:
/**
* @param s range string
* Ranges are in the following format:
* <range> := {<start_val>}:{<end>}
* <end> := <end_val> | +<delta>
*/
void
parse(const std::string &s)
{
if (!__parse_range(s, start, end))
invalidate();
}
public:
T start;
T end;
public:
Range()
{
invalidate();
}
Range() { invalidate(); }
Range(T first, T second)
: start(first), end(second)
template <class U>
Range(const std::pair<U, U> &r)
: start(r.first), end(r.second)
{}
template <class U>
@ -71,14 +59,10 @@ struct Range
: start(r.start), end(r.end)
{}
template <class U>
Range(const std::pair<U, U> &r)
: start(r.first), end(r.second)
{}
Range(const std::string &s)
{
parse(s);
if (!__parse_range(s, start, end))
invalidate();
}
template <class U>
@ -99,32 +83,39 @@ struct Range
const Range &operator=(const std::string &s)
{
parse(s);
if (!__parse_range(s, start, end))
invalidate();
return *this;
}
void invalidate() { start = 0; end = 0; }
T size() const { return end - start; }
void invalidate() { start = 1; end = 0; }
T size() const { return end - start + 1; }
bool valid() const { return start < end; }
};
template <class T>
inline Range<T>
make_range(T start, T end)
{
return Range<T>(start, end);
}
template <class T>
inline std::ostream &
operator<<(std::ostream &o, const Range<T> &r)
{
// don't currently support output of invalid ranges
assert(r.valid());
o << r.start << ":" << r.end;
o << '[' << r.start << "," << r.end << ']';
return o;
}
template <class T>
inline Range<T>
RangeEx(T start, T end)
{ return std::make_pair(start, end - 1); }
template <class T>
inline Range<T>
RangeIn(T start, T end)
{ return std::make_pair(start, end); }
template <class T, class U>
inline Range<T>
RangeSize(T start, U size)
{ return std::make_pair(start, start + size - 1); }
////////////////////////////////////////////////////////////////////////
//
// Range to Range Comparisons
@ -139,7 +130,6 @@ template <class T, class U>
inline bool
operator==(const Range<T> &range1, const Range<U> &range2)
{
assert(range1.valid() && range2.valid());
return range1.start == range2.start && range1.end == range2.end;
}
@ -152,7 +142,6 @@ template <class T, class U>
inline bool
operator!=(const Range<T> &range1, const Range<U> &range2)
{
assert(range1.valid() && range2.valid());
return range1.start != range2.start || range1.end != range2.end;
}
@ -165,8 +154,7 @@ template <class T, class U>
inline bool
operator<(const Range<T> &range1, const Range<U> &range2)
{
assert(range1.valid() && range2.valid());
return range1.end <= range2.start;
return range1.start < range2.start;
}
/**
@ -179,8 +167,7 @@ template <class T, class U>
inline bool
operator<=(const Range<T> &range1, const Range<U> &range2)
{
assert(range1.valid() && range2.valid());
return range1.start <= range2.start && range1.end <= range2.end;
return range1.start <= range2.start;
}
/**
@ -192,8 +179,7 @@ template <class T, class U>
inline bool
operator>(const Range<T> &range1, const Range<U> &range2)
{
assert(range1.valid() && range2.valid());
return range1.start >= range2.end;
return range1.start > range2.start;
}
/**
@ -206,8 +192,7 @@ template <class T, class U>
inline bool
operator>=(const Range<T> &range1, const Range<U> &range2)
{
assert(range1.valid() && range2.valid());
return range1.start >= range2.start && range1.end >= range2.end;
return range1.start >= range2.start;
}
////////////////////////////////////////////////////////////////////////
@ -224,7 +209,6 @@ template <class T, class U>
inline bool
operator==(const T &pos, const Range<U> &range)
{
assert(range.valid());
return pos >= range.start && pos <= range.end;
}
@ -237,8 +221,7 @@ template <class T, class U>
inline bool
operator!=(const T &pos, const Range<U> &range)
{
assert(range.valid());
return pos < range.start || pos >= range.end;
return pos < range.start || pos > range.end;
}
/**
@ -250,7 +233,6 @@ template <class T, class U>
inline bool
operator<(const T &pos, const Range<U> &range)
{
assert(range.valid());
return pos < range.start;
}
@ -263,8 +245,7 @@ template <class T, class U>
inline bool
operator<=(const T &pos, const Range<U> &range)
{
assert(range.valid());
return pos < range.end;
return pos <= range.end;
}
/**
@ -276,8 +257,7 @@ template <class T, class U>
inline bool
operator>(const T &pos, const Range<U> &range)
{
assert(range.valid());
return pos >= range.end;
return pos > range.end;
}
/**
@ -289,7 +269,6 @@ template <class T, class U>
inline bool
operator>=(const T &pos, const Range<U> &range)
{
assert(range.valid());
return pos >= range.start;
}
@ -307,8 +286,7 @@ template <class T, class U>
inline bool
operator==(const Range<T> &range, const U &pos)
{
assert(range.valid());
return pos >= range.start && pos < range.end;
return pos >= range.start && pos <= range.end;
}
/**
@ -320,8 +298,7 @@ template <class T, class U>
inline bool
operator!=(const Range<T> &range, const U &pos)
{
assert(range.valid());
return pos < range.start || pos >= range.end;
return pos < range.start || pos > range.end;
}
/**
@ -333,8 +310,7 @@ template <class T, class U>
inline bool
operator<(const Range<T> &range, const U &pos)
{
assert(range.valid());
return range.end <= pos;
return range.end < pos;
}
/**
@ -346,7 +322,6 @@ template <class T, class U>
inline bool
operator<=(const Range<T> &range, const U &pos)
{
assert(range.valid());
return range.start <= pos;
}
@ -359,7 +334,6 @@ template <class T, class U>
inline bool
operator>(const Range<T> &range, const U &pos)
{
assert(range.valid());
return range.start > pos;
}
@ -372,8 +346,7 @@ template <class T, class U>
inline bool
operator>=(const Range<T> &range, const U &pos)
{
assert(range.valid());
return range.end > pos;
return range.end >= pos;
}
#endif // __RANGE_HH__
#endif // __BASE_RANGE_HH__

4
dev/alpha_console.cc
View file

@ -61,12 +61,12 @@ AlphaConsole::AlphaConsole(const string &name, SimConsole *cons, SimpleDisk *d,
HierParams *hier, Bus *bus)
: PioDevice(name), disk(d), console(cons), addr(a)
{
mmu->add_child(this, Range<Addr>(addr, addr + size));
mmu->add_child(this, RangeSize(addr, size));
if (bus) {
pioInterface = newPioInterface(name, hier, bus, this,
&AlphaConsole::cacheAccess);
pioInterface->addAddrRange(addr, addr + size);
pioInterface->addAddrRange(RangeSize(addr, size));
}
alphaAccess = new AlphaAccess;

4
dev/baddev.cc
View file

@ -50,12 +50,12 @@ BadDevice::BadDevice(const string &name, Addr a, MemoryController *mmu,
HierParams *hier, Bus *bus, const string &devicename)
: PioDevice(name), addr(a), devname(devicename)
{
mmu->add_child(this, Range<Addr>(addr, addr + size));
mmu->add_child(this, RangeSize(addr, size));
if (bus) {
pioInterface = newPioInterface(name, hier, bus, this,
&BadDevice::cacheAccess);
pioInterface->addAddrRange(addr, addr + size - 1);
pioInterface->addAddrRange(RangeSize(addr, size));
}
}

32
dev/ide_ctrl.cc
View file

@ -377,8 +377,8 @@ IdeController::WriteConfig(int offset, int size, uint32_t data)
if (BARAddrs[0] != 0) {
pri_cmd_addr = BARAddrs[0];
if (pioInterface)
pioInterface->addAddrRange(pri_cmd_addr,
pri_cmd_addr + pri_cmd_size - 1);
pioInterface->addAddrRange(RangeSize(pri_cmd_addr,
pri_cmd_size));
pri_cmd_addr &= PA_UNCACHED_MASK;
}
@ -388,8 +388,8 @@ IdeController::WriteConfig(int offset, int size, uint32_t data)
if (BARAddrs[1] != 0) {
pri_ctrl_addr = BARAddrs[1];
if (pioInterface)
pioInterface->addAddrRange(pri_ctrl_addr,
pri_ctrl_addr + pri_ctrl_size - 1);
pioInterface->addAddrRange(RangeSize(pri_ctrl_addr,
pri_ctrl_size));
pri_ctrl_addr &= PA_UNCACHED_MASK;
}
@ -399,8 +399,8 @@ IdeController::WriteConfig(int offset, int size, uint32_t data)
if (BARAddrs[2] != 0) {
sec_cmd_addr = BARAddrs[2];
if (pioInterface)
pioInterface->addAddrRange(sec_cmd_addr,
sec_cmd_addr + sec_cmd_size - 1);
pioInterface->addAddrRange(RangeSize(sec_cmd_addr,
sec_cmd_size));
sec_cmd_addr &= PA_UNCACHED_MASK;
}
@ -410,8 +410,8 @@ IdeController::WriteConfig(int offset, int size, uint32_t data)
if (BARAddrs[3] != 0) {
sec_ctrl_addr = BARAddrs[3];
if (pioInterface)
pioInterface->addAddrRange(sec_ctrl_addr,
sec_ctrl_addr + sec_ctrl_size - 1);
pioInterface->addAddrRange(RangeSize(sec_ctrl_addr,
sec_ctrl_size));
sec_ctrl_addr &= PA_UNCACHED_MASK;
}
@ -421,7 +421,7 @@ IdeController::WriteConfig(int offset, int size, uint32_t data)
if (BARAddrs[4] != 0) {
bmi_addr = BARAddrs[4];
if (pioInterface)
pioInterface->addAddrRange(bmi_addr, bmi_addr + bmi_size - 1);
pioInterface->addAddrRange(RangeSize(bmi_addr, bmi_size));
bmi_addr &= PA_UNCACHED_MASK;
}
@ -675,15 +675,11 @@ IdeController::unserialize(Checkpoint *cp, const std::string &section)
UNSERIALIZE_ARRAY(cmd_in_progress, 4);
if (pioInterface) {
pioInterface->addAddrRange(pri_cmd_addr, pri_cmd_addr +
pri_cmd_size - 1);
pioInterface->addAddrRange(pri_ctrl_addr, pri_ctrl_addr +
pri_ctrl_size - 1);
pioInterface->addAddrRange(sec_cmd_addr, sec_cmd_addr +
sec_cmd_size - 1);
pioInterface->addAddrRange(sec_ctrl_addr, sec_ctrl_addr +
sec_ctrl_size - 1);
pioInterface->addAddrRange(bmi_addr, bmi_addr + bmi_size - 1);
pioInterface->addAddrRange(RangeSize(pri_cmd_addr, pri_cmd_size));
pioInterface->addAddrRange(RangeSize(pri_ctrl_addr, pri_ctrl_size));
pioInterface->addAddrRange(RangeSize(sec_cmd_addr, sec_cmd_size));
pioInterface->addAddrRange(RangeSize(sec_ctrl_addr, sec_ctrl_size));
pioInterface->addAddrRange(RangeSize(bmi_addr, bmi_size));
}
}

10
dev/ns_gige.cc
View file

@ -344,8 +344,7 @@ NSGigE::WriteConfig(int offset, int size, uint32_t data)
case PCI0_BASE_ADDR0:
if (BARAddrs[0] != 0) {
if (pioInterface)
pioInterface->addAddrRange(BARAddrs[0],
BARAddrs[0] + BARSize[0] - 1);
pioInterface->addAddrRange(RangeSize(BARAddrs[0], BARSize[0]));
BARAddrs[0] &= PA_UNCACHED_MASK;
}
@ -353,8 +352,7 @@ NSGigE::WriteConfig(int offset, int size, uint32_t data)
case PCI0_BASE_ADDR1:
if (BARAddrs[1] != 0) {
if (pioInterface)
pioInterface->addAddrRange(BARAddrs[1],
BARAddrs[1] + BARSize[1] - 1);
pioInterface->addAddrRange(RangeSize(BARAddrs[1], BARSize[1]));
BARAddrs[1] &= PA_UNCACHED_MASK;
}
@ -2410,8 +2408,8 @@ NSGigE::unserialize(Checkpoint *cp, const std::string &section)
* re-add addrRanges to bus bridges
*/
if (pioInterface) {
pioInterface->addAddrRange(BARAddrs[0], BARAddrs[0] + BARSize[0] - 1);
pioInterface->addAddrRange(BARAddrs[1], BARAddrs[1] + BARSize[1] - 1);
pioInterface->addAddrRange(RangeSize(BARAddrs[0], BARSize[0]));
pioInterface->addAddrRange(RangeSize(BARAddrs[1], BARSize[1]));
}
}

4
dev/pciconfigall.cc
View file

@ -50,12 +50,12 @@ PciConfigAll::PciConfigAll(const string &name, Addr a, MemoryController *mmu,
HierParams *hier, Bus *bus, Tick pio_latency)
: PioDevice(name), addr(a)
{
mmu->add_child(this, Range<Addr>(addr, addr + size));
mmu->add_child(this, RangeSize(addr, size));
if (bus) {
pioInterface = newPioInterface(name, hier, bus, this,
&PciConfigAll::cacheAccess);
pioInterface->addAddrRange(addr, addr + size - 1);
pioInterface->addAddrRange(RangeSize(addr, size));
pioLatency = pio_latency * bus->clockRatio;
}

33
dev/pcidev.cc
View file

@ -184,21 +184,17 @@ PciDev::WriteConfig(int offset, int size, uint32_t data)
if (word_value & ~0x1) {
Addr base_addr = (word_value & ~0x1) + TSUNAMI_PCI0_IO;
Addr base_size = BARSize[barnum]-1;
Addr base_size = BARSize[barnum];
// It's never been set
if (BARAddrs[barnum] == 0)
mmu->add_child((FunctionalMemory *)this,
Range<Addr>(base_addr,
base_addr + base_size));
RangeSize(base_addr, base_size));
else
mmu->update_child((FunctionalMemory *)this,
Range<Addr>(BARAddrs[barnum],
BARAddrs[barnum] +
base_size),
Range<Addr>(base_addr,
base_addr +
base_size));
RangeSize(BARAddrs[barnum],
base_size),
RangeSize(base_addr, base_size));
BARAddrs[barnum] = base_addr;
}
@ -212,21 +208,17 @@ PciDev::WriteConfig(int offset, int size, uint32_t data)
Addr base_addr = (word_value & ~0x3) +
TSUNAMI_PCI0_MEMORY;
Addr base_size = BARSize[barnum]-1;
Addr base_size = BARSize[barnum];
// It's never been set
if (BARAddrs[barnum] == 0)
mmu->add_child((FunctionalMemory *)this,
Range<Addr>(base_addr,
base_addr + base_size));
RangeSize(base_addr, base_size));
else
mmu->update_child((FunctionalMemory *)this,
Range<Addr>(BARAddrs[barnum],
BARAddrs[barnum] +
base_size),
Range<Addr>(base_addr,
base_addr +
base_size));
RangeSize(BARAddrs[barnum],
base_size),
RangeSize(base_addr, base_size));
BARAddrs[barnum] = base_addr;
}
@ -273,10 +265,7 @@ PciDev::unserialize(Checkpoint *cp, const std::string &section)
// Add the MMU mappings for the BARs
for (int i=0; i < 6; i++) {
if (BARAddrs[i] != 0)
mmu->add_child((FunctionalMemory *)this,
Range<Addr>(BARAddrs[i],
BARAddrs[i] +
BARSize[i] - 1));
mmu->add_child(this, RangeSize(BARAddrs[i], BARSize[i]));
}
}

4
dev/tsunami_cchip.cc
View file

@ -53,7 +53,7 @@ TsunamiCChip::TsunamiCChip(const string &name, Tsunami *t, Addr a,
Tick pio_latency)
: PioDevice(name), addr(a), tsunami(t)
{
mmu->add_child(this, Range<Addr>(addr, addr + size));
mmu->add_child(this, RangeSize(addr, size));
for(int i=0; i < Tsunami::Max_CPUs; i++) {
dim[i] = 0;
@ -66,7 +66,7 @@ TsunamiCChip::TsunamiCChip(const string &name, Tsunami *t, Addr a,
if (bus) {
pioInterface = newPioInterface(name, hier, bus, this,
&TsunamiCChip::cacheAccess);
pioInterface->addAddrRange(addr, addr + size - 1);
pioInterface->addAddrRange(RangeSize(addr, size));
pioLatency = pio_latency * bus->clockRatio;
}

4
dev/tsunami_io.cc
View file

@ -164,12 +164,12 @@ TsunamiIO::TsunamiIO(const string &name, Tsunami *t, time_t init_time,
Tick pio_latency)
: PioDevice(name), addr(a), tsunami(t), rtc(t)
{
mmu->add_child(this, Range<Addr>(addr, addr + size));
mmu->add_child(this, RangeSize(addr, size));
if (bus) {
pioInterface = newPioInterface(name, hier, bus, this,
&TsunamiIO::cacheAccess);
pioInterface->addAddrRange(addr, addr + size - 1);
pioInterface->addAddrRange(RangeSize(addr, size));
pioLatency = pio_latency * bus->clockRatio;
}

4
dev/tsunami_pchip.cc
View file

@ -53,7 +53,7 @@ TsunamiPChip::TsunamiPChip(const string &name, Tsunami *t, Addr a,
Bus *bus, Tick pio_latency)
: PioDevice(name), addr(a), tsunami(t)
{
mmu->add_child(this, Range<Addr>(addr, addr + size));
mmu->add_child(this, RangeSize(addr, size));
for (int i = 0; i < 4; i++) {
wsba[i] = 0;
@ -64,7 +64,7 @@ TsunamiPChip::TsunamiPChip(const string &name, Tsunami *t, Addr a,
if (bus) {
pioInterface = newPioInterface(name, hier, bus, this,
&TsunamiPChip::cacheAccess);
pioInterface->addAddrRange(addr, addr + size - 1);
pioInterface->addAddrRange(RangeSize(addr, size));
pioLatency = pio_latency * bus->clockRatio;
}

4
dev/uart.cc
View file

@ -92,13 +92,13 @@ Uart::Uart(const string &name, SimConsole *c, MemoryController *mmu, Addr a,
: PioDevice(name), addr(a), size(s), cons(c), txIntrEvent(this, TX_INT),
rxIntrEvent(this, RX_INT), platform(p)
{
mmu->add_child(this, Range<Addr>(addr, addr + size));
mmu->add_child(this, RangeSize(addr, size));
if (bus) {
pioInterface = newPioInterface(name, hier, bus, this,
&Uart::cacheAccess);
pioInterface->addAddrRange(addr, addr + size - 1);
pioInterface->addAddrRange(RangeSize(addr, size));
pioLatency = pio_latency * bus->clockRatio;
}