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

flags: Change naming of functions to be clearer

Browse source
This commit is contained in:
Nathan Binkert 2008-12-06 14:18:18 -08:00
parent dd788a23c9
commit e141cb7441
5 changed files with 67 additions and 69 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/arch/alpha/faults.cc
View file

@ -144,7 +144,7 @@ DtbFault::invoke(ThreadContext *tc)
// read, like the EV5). The EV6 approach is cleaner and seems to // read, like the EV5). The EV6 approach is cleaner and seems to
// work with EV5 PAL code, but not the other way around. // work with EV5 PAL code, but not the other way around.
if (!tc->misspeculating() && if (!tc->misspeculating() &&
reqFlags.none(Request::VPTE|Request::NO_FAULT)) { reqFlags.noneSet(Request::VPTE|Request::NO_FAULT)) {
// set VA register with faulting address // set VA register with faulting address
tc->setMiscRegNoEffect(IPR_VA, vaddr); tc->setMiscRegNoEffect(IPR_VA, vaddr);

12
src/base/flags.hh
View file

@ -59,12 +59,12 @@ class Flags
return *this; return *this;
} }
bool any() const { return _flags; } bool isSet() const { return _flags; }
bool any(Type flags) const { return (_flags & flags); } bool isSet(Type flags) const { return (_flags & flags); }
bool all() const { return !(~_flags); } bool allSet() const { return !(~_flags); }
bool all(Type flags) const { return (_flags & flags) == flags; } bool allSet(Type flags) const { return (_flags & flags) == flags; }
bool none() const { return _flags == 0; } bool noneSet() const { return _flags == 0; }
bool none(Type flags) const { return (_flags & flags) == 0; } bool noneSet(Type flags) const { return (_flags & flags) == 0; }
void clear() { _flags = 0; } void clear() { _flags = 0; }
void clear(Type flags) { _flags &= ~flags; } void clear(Type flags) { _flags &= ~flags; }
void set(Type flags) { _flags |= flags; } void set(Type flags) { _flags |= flags; }

42
src/mem/packet.hh
View file

@ -407,15 +407,15 @@ class Packet : public FastAlloc, public Printable
// Snoop flags // Snoop flags
void assertMemInhibit() { flags.set(MEM_INHIBIT); } void assertMemInhibit() { flags.set(MEM_INHIBIT); }
bool memInhibitAsserted() { return flags.any(MEM_INHIBIT); } bool memInhibitAsserted() { return flags.isSet(MEM_INHIBIT); }
void assertShared() { flags.set(SHARED); } void assertShared() { flags.set(SHARED); }
bool sharedAsserted() { return flags.any(SHARED); } bool sharedAsserted() { return flags.isSet(SHARED); }
// Special control flags // Special control flags
void setExpressSnoop() { flags.set(EXPRESS_SNOOP); } void setExpressSnoop() { flags.set(EXPRESS_SNOOP); }
bool isExpressSnoop() { return flags.any(EXPRESS_SNOOP); } bool isExpressSnoop() { return flags.isSet(EXPRESS_SNOOP); }
void setSupplyExclusive() { flags.set(SUPPLY_EXCLUSIVE); } void setSupplyExclusive() { flags.set(SUPPLY_EXCLUSIVE); }
bool isSupplyExclusive() { return flags.any(SUPPLY_EXCLUSIVE); } bool isSupplyExclusive() { return flags.isSet(SUPPLY_EXCLUSIVE); }
// Network error conditions... encapsulate them as methods since // Network error conditions... encapsulate them as methods since
// their encoding keeps changing (from result field to command // their encoding keeps changing (from result field to command
@ -439,19 +439,19 @@ class Packet : public FastAlloc, public Printable
void copyError(Packet *pkt) { assert(pkt->isError()); cmd = pkt->cmd; } void copyError(Packet *pkt) { assert(pkt->isError()); cmd = pkt->cmd; }
/// Accessor function to get the source index of the packet. /// Accessor function to get the source index of the packet.
NodeID getSrc() const { assert(flags.any(VALID_SRC)); return src; } NodeID getSrc() const { assert(flags.isSet(VALID_SRC)); return src; }
/// Accessor function to set the source index of the packet. /// Accessor function to set the source index of the packet.
void setSrc(NodeID _src) { src = _src; flags.set(VALID_SRC); } void setSrc(NodeID _src) { src = _src; flags.set(VALID_SRC); }
/// Reset source field, e.g. to retransmit packet on different bus. /// Reset source field, e.g. to retransmit packet on different bus.
void clearSrc() { flags.clear(VALID_SRC); } void clearSrc() { flags.clear(VALID_SRC); }
/// Accessor function for the destination index of the packet. /// Accessor function for the destination index of the packet.
NodeID getDest() const { assert(flags.any(VALID_DST)); return dest; } NodeID getDest() const { assert(flags.isSet(VALID_DST)); return dest; }
/// Accessor function to set the destination index of the packet. /// Accessor function to set the destination index of the packet.
void setDest(NodeID _dest) { dest = _dest; flags.set(VALID_DST); } void setDest(NodeID _dest) { dest = _dest; flags.set(VALID_DST); }
Addr getAddr() const { assert(flags.all(VALID_ADDR)); return addr; } Addr getAddr() const { assert(flags.isSet(VALID_ADDR)); return addr; }
int getSize() const { assert(flags.all(VALID_SIZE)); return size; } int getSize() const { assert(flags.isSet(VALID_SIZE)); return size; }
Addr getOffset(int blkSize) const { return getAddr() & (Addr)(blkSize - 1); } Addr getOffset(int blkSize) const { return getAddr() & (Addr)(blkSize - 1); }
/** /**
@ -465,7 +465,7 @@ class Packet : public FastAlloc, public Printable
addr(_req->paddr), size(_req->size), dest(_dest), time(curTick), addr(_req->paddr), size(_req->size), dest(_dest), time(curTick),
senderState(NULL) senderState(NULL)
{ {
if (req->flags.any(Request::VALID_PADDR)) if (req->flags.isSet(Request::VALID_PADDR))
flags.set(VALID_ADDR|VALID_SIZE); flags.set(VALID_ADDR|VALID_SIZE);
} }
@ -479,7 +479,7 @@ class Packet : public FastAlloc, public Printable
addr(_req->paddr & ~(_blkSize - 1)), size(_blkSize), dest(_dest), addr(_req->paddr & ~(_blkSize - 1)), size(_blkSize), dest(_dest),
time(curTick), senderState(NULL) time(curTick), senderState(NULL)
{ {
if (req->flags.any(Request::VALID_PADDR)) if (req->flags.isSet(Request::VALID_PADDR))
flags.set(VALID_ADDR|VALID_SIZE); flags.set(VALID_ADDR|VALID_SIZE);
} }
@ -492,7 +492,7 @@ class Packet : public FastAlloc, public Printable
*/ */
Packet(Packet *pkt, bool clearFlags = false) Packet(Packet *pkt, bool clearFlags = false)
: cmd(pkt->cmd), req(pkt->req), : cmd(pkt->cmd), req(pkt->req),
data(pkt->flags.any(STATIC_DATA) ? pkt->data : NULL), data(pkt->flags.isSet(STATIC_DATA) ? pkt->data : NULL),
addr(pkt->addr), size(pkt->size), src(pkt->src), dest(pkt->dest), addr(pkt->addr), size(pkt->size), src(pkt->src), dest(pkt->dest),
time(curTick), senderState(pkt->senderState) time(curTick), senderState(pkt->senderState)
{ {
@ -526,7 +526,7 @@ class Packet : public FastAlloc, public Printable
void void
reinitFromRequest() reinitFromRequest()
{ {
assert(req->flags.any(Request::VALID_PADDR)); assert(req->flags.isSet(Request::VALID_PADDR));
flags = 0; flags = 0;
addr = req->paddr; addr = req->paddr;
size = req->size; size = req->size;
@ -551,7 +551,7 @@ class Packet : public FastAlloc, public Printable
cmd = cmd.responseCommand(); cmd = cmd.responseCommand();
dest = src; dest = src;
flags.set(VALID_DST, flags.any(VALID_SRC)); flags.set(VALID_DST, flags.isSet(VALID_SRC));
flags.clear(VALID_SRC); flags.clear(VALID_SRC);
} }
@ -590,7 +590,7 @@ class Packet : public FastAlloc, public Printable
void void
dataStatic(T *p) dataStatic(T *p)
{ {
assert(flags.none(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA)); assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA));
data = (PacketDataPtr)p; data = (PacketDataPtr)p;
flags.set(STATIC_DATA); flags.set(STATIC_DATA);
} }
@ -603,7 +603,7 @@ class Packet : public FastAlloc, public Printable
void void
dataDynamicArray(T *p) dataDynamicArray(T *p)
{ {
assert(flags.none(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA)); assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA));
data = (PacketDataPtr)p; data = (PacketDataPtr)p;
flags.set(DYNAMIC_DATA|ARRAY_DATA); flags.set(DYNAMIC_DATA|ARRAY_DATA);
} }
@ -616,7 +616,7 @@ class Packet : public FastAlloc, public Printable
void void
dataDynamic(T *p) dataDynamic(T *p)
{ {
assert(flags.none(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA)); assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA));
data = (PacketDataPtr)p; data = (PacketDataPtr)p;
flags.set(DYNAMIC_DATA); flags.set(DYNAMIC_DATA);
} }
@ -628,7 +628,7 @@ class Packet : public FastAlloc, public Printable
T* T*
getPtr() getPtr()
{ {
assert(flags.any(STATIC_DATA|DYNAMIC_DATA)); assert(flags.isSet(STATIC_DATA|DYNAMIC_DATA));
return (T*)data; return (T*)data;
} }
@ -689,9 +689,9 @@ class Packet : public FastAlloc, public Printable
void void
deleteData() deleteData()
{ {
if (flags.any(ARRAY_DATA)) if (flags.isSet(ARRAY_DATA))
delete [] data; delete [] data;
else if (flags.any(DYNAMIC_DATA)) else if (flags.isSet(DYNAMIC_DATA))
delete data; delete data;
flags.clear(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA); flags.clear(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA);
@ -703,11 +703,11 @@ class Packet : public FastAlloc, public Printable
allocate() allocate()
{ {
if (data) { if (data) {
assert(flags.any(STATIC_DATA|DYNAMIC_DATA)); assert(flags.isSet(STATIC_DATA|DYNAMIC_DATA));
return; return;
} }
assert(flags.none(STATIC_DATA|DYNAMIC_DATA)); assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
flags.set(DYNAMIC_DATA|ARRAY_DATA); flags.set(DYNAMIC_DATA|ARRAY_DATA);
data = new uint8_t[getSize()]; data = new uint8_t[getSize()];
} }

4
src/mem/packet_access.hh
View file

@ -46,7 +46,7 @@ template <typename T>
inline T inline T
Packet::get() Packet::get()
{ {
assert(flags.any(STATIC_DATA|DYNAMIC_DATA)); assert(flags.isSet(STATIC_DATA|DYNAMIC_DATA));
assert(sizeof(T) <= size); assert(sizeof(T) <= size);
return TheISA::gtoh(*(T*)data); return TheISA::gtoh(*(T*)data);
} }
@ -56,7 +56,7 @@ template <typename T>
inline void inline void
Packet::set(T v) Packet::set(T v)
{ {
assert(flags.any(STATIC_DATA|DYNAMIC_DATA)); assert(flags.isSet(STATIC_DATA|DYNAMIC_DATA));
assert(sizeof(T) <= size); assert(sizeof(T) <= size);
*(T*)data = TheISA::htog(v); *(T*)data = TheISA::htog(v);
} }

76
src/mem/request.hh
View file

@ -230,7 +230,7 @@ class Request : public FastAlloc
void void
setPaddr(Addr _paddr) setPaddr(Addr _paddr)
{ {
assert(flags.any(VALID_VADDR)); assert(flags.isSet(VALID_VADDR));
paddr = _paddr; paddr = _paddr;
flags.set(VALID_PADDR); flags.set(VALID_PADDR);
} }
@ -241,8 +241,8 @@ class Request : public FastAlloc
*/ */
void splitOnVaddr(Addr split_addr, RequestPtr &req1, RequestPtr &req2) void splitOnVaddr(Addr split_addr, RequestPtr &req1, RequestPtr &req2)
{ {
assert(flags.any(VALID_VADDR)); assert(flags.isSet(VALID_VADDR));
assert(flags.none(VALID_PADDR)); assert(flags.noneSet(VALID_PADDR));
assert(split_addr > vaddr && split_addr < vaddr + size); assert(split_addr > vaddr && split_addr < vaddr + size);
req1 = new Request; req1 = new Request;
*req1 = *this; *req1 = *this;
@ -259,7 +259,7 @@ class Request : public FastAlloc
Addr Addr
getPaddr() getPaddr()
{ {
assert(flags.any(VALID_PADDR)); assert(flags.isSet(VALID_PADDR));
return paddr; return paddr;
} }
@ -269,7 +269,7 @@ class Request : public FastAlloc
int int
getSize() getSize()
{ {
assert(flags.any(VALID_SIZE)); assert(flags.isSet(VALID_SIZE));
return size; return size;
} }
@ -277,64 +277,62 @@ class Request : public FastAlloc
Tick Tick
getTime() getTime()
{ {
assert(flags.any(VALID_PADDR|VALID_VADDR)); assert(flags.isSet(VALID_PADDR|VALID_VADDR));
return time; return time;
} }
void void
setTime(Tick when) setTime(Tick when)
{ {
assert(flags.any(VALID_PADDR|VALID_VADDR)); assert(flags.isSet(VALID_PADDR|VALID_VADDR));
time = when; time = when;
} }
void resetTime() { setTime(curTick); }
/** Accessor for flags. */ /** Accessor for flags. */
Flags Flags
getFlags() getFlags()
{ {
assert(flags.any(VALID_PADDR|VALID_VADDR)); assert(flags.isSet(VALID_PADDR|VALID_VADDR));
return flags & PUBLIC_FLAGS; return flags & PUBLIC_FLAGS;
} }
Flags Flags
anyFlags(Flags _flags) anyFlags(Flags _flags)
{ {
assert(flags.any(VALID_PADDR|VALID_VADDR)); assert(flags.isSet(VALID_PADDR|VALID_VADDR));
assert(_flags.none(~PUBLIC_FLAGS)); assert(_flags.noneSet(~PUBLIC_FLAGS));
return flags.any(_flags); return flags.isSet(_flags);
} }
Flags Flags
allFlags(Flags _flags) allFlags(Flags _flags)
{ {
assert(flags.any(VALID_PADDR|VALID_VADDR)); assert(flags.isSet(VALID_PADDR|VALID_VADDR));
assert(_flags.none(~PUBLIC_FLAGS)); assert(_flags.noneSet(~PUBLIC_FLAGS));
return flags.all(_flags); return flags.allSet(_flags);
} }
/** Accessor for flags. */ /** Accessor for flags. */
void void
setFlags(Flags _flags) setFlags(Flags _flags)
{ {
assert(flags.any(VALID_PADDR|VALID_VADDR)); assert(flags.isSet(VALID_PADDR|VALID_VADDR));
assert(_flags.none(~PUBLIC_FLAGS)); assert(_flags.noneSet(~PUBLIC_FLAGS));
flags.set(_flags); flags.set(_flags);
} }
void void
clearFlags(Flags _flags) clearFlags(Flags _flags)
{ {
assert(flags.any(VALID_PADDR|VALID_VADDR)); assert(flags.isSet(VALID_PADDR|VALID_VADDR));
assert(_flags.none(~PUBLIC_FLAGS)); assert(_flags.noneSet(~PUBLIC_FLAGS));
flags.clear(_flags); flags.clear(_flags);
} }
void void
clearFlags() clearFlags()
{ {
assert(flags.any(VALID_PADDR|VALID_VADDR)); assert(flags.isSet(VALID_PADDR|VALID_VADDR));
flags.clear(PUBLIC_FLAGS); flags.clear(PUBLIC_FLAGS);
} }
@ -342,7 +340,7 @@ class Request : public FastAlloc
Addr Addr
getVaddr() getVaddr()
{ {
assert(flags.any(VALID_VADDR)); assert(flags.isSet(VALID_VADDR));
return vaddr; return vaddr;
} }
@ -350,7 +348,7 @@ class Request : public FastAlloc
int int
getAsid() getAsid()
{ {
assert(flags.any(VALID_VADDR)); assert(flags.isSet(VALID_VADDR));
return asid; return asid;
} }
@ -358,7 +356,7 @@ class Request : public FastAlloc
uint8_t uint8_t
getAsi() getAsi()
{ {
assert(flags.any(VALID_VADDR)); assert(flags.isSet(VALID_VADDR));
return flags & ASI_BITS; return flags & ASI_BITS;
} }
@ -366,7 +364,7 @@ class Request : public FastAlloc
void void
setAsi(uint8_t a) setAsi(uint8_t a)
{ {
assert(flags.any(VALID_VADDR)); assert(flags.isSet(VALID_VADDR));
flags.update(a, ASI_BITS); flags.update(a, ASI_BITS);
} }
@ -374,8 +372,8 @@ class Request : public FastAlloc
bool bool
isMmapedIpr() isMmapedIpr()
{ {
assert(flags.any(VALID_PADDR)); assert(flags.isSet(VALID_PADDR));
return flags.any(MMAPED_IPR); return flags.isSet(MMAPED_IPR);
} }
/** Accessor function for asi.*/ /** Accessor function for asi.*/
@ -390,14 +388,14 @@ class Request : public FastAlloc
bool bool
extraDataValid() extraDataValid()
{ {
return flags.any(VALID_EXTRA_DATA); return flags.isSet(VALID_EXTRA_DATA);
} }
/** Accessor function for store conditional return value.*/ /** Accessor function for store conditional return value.*/
uint64_t uint64_t
getExtraData() const getExtraData() const
{ {
assert(flags.any(VALID_EXTRA_DATA)); assert(flags.isSet(VALID_EXTRA_DATA));
return extraData; return extraData;
} }
@ -413,7 +411,7 @@ class Request : public FastAlloc
int int
contextId() const contextId() const
{ {
assert(flags.any(VALID_CONTEXT_ID)); assert(flags.isSet(VALID_CONTEXT_ID));
return _contextId; return _contextId;
} }
@ -421,7 +419,7 @@ class Request : public FastAlloc
int int
threadId() const threadId() const
{ {
assert(flags.any(VALID_THREAD_ID)); assert(flags.isSet(VALID_THREAD_ID));
return _threadId; return _threadId;
} }
@ -429,27 +427,27 @@ class Request : public FastAlloc
Addr Addr
getPC() const getPC() const
{ {
assert(flags.any(VALID_PC)); assert(flags.isSet(VALID_PC));
return pc; return pc;
} }
/** Accessor Function to Check Cacheability. */ /** Accessor Function to Check Cacheability. */
bool isUncacheable() const { return flags.any(UNCACHEABLE); } bool isUncacheable() const { return flags.isSet(UNCACHEABLE); }
bool isInstRead() const { return flags.any(INST_READ); } bool isInstRead() const { return flags.isSet(INST_READ); }
bool isLocked() const { return flags.any(LOCKED); } bool isLocked() const { return flags.isSet(LOCKED); }
bool isSwap() const { return flags.any(MEM_SWAP|MEM_SWAP_COND); } bool isSwap() const { return flags.isSet(MEM_SWAP|MEM_SWAP_COND); }
bool isCondSwap() const { return flags.any(MEM_SWAP_COND); } bool isCondSwap() const { return flags.isSet(MEM_SWAP_COND); }
bool bool
isMisaligned() const isMisaligned() const
{ {
if (flags.any(NO_ALIGN_FAULT)) if (flags.isSet(NO_ALIGN_FAULT))
return false; return false;
if ((vaddr & 0x1)) if ((vaddr & 0x1))
return true; return true;
if (flags.any(NO_HALF_WORD_ALIGN_FAULT)) if (flags.isSet(NO_HALF_WORD_ALIGN_FAULT))
return false; return false;
if ((vaddr & 0x2)) if ((vaddr & 0x2))