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

request: split public and private flags into separate fields.

Browse source 
This frees up needed space for more public flags.  Also:
- remove unused Request accessor methods
- make Packet use public Request accessors, so it need not be a friend
This commit is contained in:
Steve Reinhardt 2009-04-20 18:40:00 -07:00
parent 9e9a34fed1
commit 7f8ea68a30
2 changed files with 87 additions and 103 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
src/mem/packet.hh
View file

@ -462,11 +462,16 @@ class Packet : public FastAlloc, public Printable
*/ */
Packet(Request *_req, MemCmd _cmd, NodeID _dest) Packet(Request *_req, MemCmd _cmd, NodeID _dest)
: flags(VALID_DST), cmd(_cmd), req(_req), data(NULL), : flags(VALID_DST), cmd(_cmd), req(_req), data(NULL),
addr(_req->paddr), size(_req->size), dest(_dest), time(curTick), dest(_dest), time(curTick), senderState(NULL)
senderState(NULL)
{ {
if (req->flags.isSet(Request::VALID_PADDR)) if (req->hasPaddr()) {
flags.set(VALID_ADDR|VALID_SIZE); addr = req->getPaddr();
flags.set(VALID_ADDR);
}
if (req->hasSize()) {
size = req->getSize();
flags.set(VALID_SIZE);
}
} }
/** /**
@ -476,11 +481,14 @@ class Packet : public FastAlloc, public Printable
*/ */
Packet(Request *_req, MemCmd _cmd, NodeID _dest, int _blkSize) Packet(Request *_req, MemCmd _cmd, NodeID _dest, int _blkSize)
: flags(VALID_DST), cmd(_cmd), req(_req), data(NULL), : flags(VALID_DST), cmd(_cmd), req(_req), data(NULL),
addr(_req->paddr & ~(_blkSize - 1)), size(_blkSize), dest(_dest), dest(_dest), time(curTick), senderState(NULL)
time(curTick), senderState(NULL)
{ {
if (req->flags.isSet(Request::VALID_PADDR)) if (req->hasPaddr()) {
flags.set(VALID_ADDR|VALID_SIZE); addr = req->getPaddr() & ~(_blkSize - 1);
flags.set(VALID_ADDR);
}
size = _blkSize;
flags.set(VALID_SIZE);
} }
/** /**
@ -526,11 +534,11 @@ class Packet : public FastAlloc, public Printable
void void
reinitFromRequest() reinitFromRequest()
{ {
assert(req->flags.isSet(Request::VALID_PADDR)); assert(req->hasPaddr());
flags = 0; flags = 0;
addr = req->paddr; addr = req->getPaddr();
size = req->size; size = req->getSize();
time = req->time; time = req->getTime();
flags.set(VALID_ADDR|VALID_SIZE); flags.set(VALID_ADDR|VALID_SIZE);
deleteData(); deleteData();

158
src/mem/request.hh
View file

@ -53,8 +53,6 @@ typedef Request* RequestPtr;
class Request : public FastAlloc class Request : public FastAlloc
{ {
friend class Packet;
public: public:
typedef uint32_t FlagsType; typedef uint32_t FlagsType;
typedef ::Flags<FlagsType> Flags; typedef ::Flags<FlagsType> Flags;
@ -98,23 +96,32 @@ class Request : public FastAlloc
/** This request is to a memory mapped register. */ /** This request is to a memory mapped register. */
static const FlagsType MMAPED_IPR = 0x00800000; static const FlagsType MMAPED_IPR = 0x00800000;
/** These flags are *not* cleared when a Request object is reused
(assigned a new address). */
static const FlagsType STICKY_FLAGS = INST_READ;
private: private:
static const FlagsType PUBLIC_FLAGS = 0x00FFFFFF; typedef uint8_t PrivateFlagsType;
static const FlagsType PRIVATE_FLAGS = 0xFF000000; typedef ::Flags<PrivateFlagsType> PrivateFlags;
/** Whether or not the size is valid. */ /** Whether or not the size is valid. */
static const FlagsType VALID_SIZE = 0x01000000; static const PrivateFlagsType VALID_SIZE = 0x00000001;
/** Whether or not paddr is valid (has been written yet). */ /** Whether or not paddr is valid (has been written yet). */
static const FlagsType VALID_PADDR = 0x02000000; static const PrivateFlagsType VALID_PADDR = 0x00000002;
/** Whether or not the vaddr & asid are valid. */ /** Whether or not the vaddr & asid are valid. */
static const FlagsType VALID_VADDR = 0x04000000; static const PrivateFlagsType VALID_VADDR = 0x00000004;
/** Whether or not the pc is valid. */ /** Whether or not the pc is valid. */
static const FlagsType VALID_PC = 0x10000000; static const PrivateFlagsType VALID_PC = 0x00000010;
/** Whether or not the context ID is valid. */ /** Whether or not the context ID is valid. */
static const FlagsType VALID_CONTEXT_ID = 0x20000000; static const PrivateFlagsType VALID_CONTEXT_ID = 0x00000020;
static const FlagsType VALID_THREAD_ID = 0x40000000; static const PrivateFlagsType VALID_THREAD_ID = 0x00000040;
/** Whether or not the sc result is valid. */ /** Whether or not the sc result is valid. */
static const FlagsType VALID_EXTRA_DATA = 0x80000000; static const PrivateFlagsType VALID_EXTRA_DATA = 0x00000080;
/** These flags are *not* cleared when a Request object is reused
(assigned a new address). */
static const PrivateFlagsType STICKY_PRIVATE_FLAGS =
VALID_CONTEXT_ID | VALID_THREAD_ID;
private: private:
/** /**
@ -133,6 +140,9 @@ class Request : public FastAlloc
/** Flag structure for the request. */ /** Flag structure for the request. */
Flags flags; Flags flags;
/** Private flags for field validity checking. */
PrivateFlags privateFlags;
/** /**
* The time this request was started. Used to calculate * The time this request was started. Used to calculate
* latencies. This field is set to curTick any time paddr or vaddr * latencies. This field is set to curTick any time paddr or vaddr
@ -177,8 +187,8 @@ class Request : public FastAlloc
Request(int asid, Addr vaddr, int size, Flags flags, Addr pc, Request(int asid, Addr vaddr, int size, Flags flags, Addr pc,
int cid, int tid) int cid, int tid)
{ {
setThreadContext(cid, tid);
setVirt(asid, vaddr, size, flags, pc); setVirt(asid, vaddr, size, flags, pc);
setThreadContext(cid, tid);
} }
~Request() {} // for FastAlloc ~Request() {} // for FastAlloc
@ -191,7 +201,7 @@ class Request : public FastAlloc
{ {
_contextId = context_id; _contextId = context_id;
_threadId = thread_id; _threadId = thread_id;
flags.set(VALID_CONTEXT_ID|VALID_THREAD_ID); privateFlags.set(VALID_CONTEXT_ID|VALID_THREAD_ID);
} }
/** /**
@ -206,9 +216,10 @@ class Request : public FastAlloc
size = _size; size = _size;
time = curTick; time = curTick;
flags.set(VALID_PADDR|VALID_SIZE); flags.clear(~STICKY_FLAGS);
flags.clear(VALID_VADDR|VALID_PC|VALID_EXTRA_DATA|MMAPED_IPR); flags.set(_flags);
flags.update(_flags, PUBLIC_FLAGS); privateFlags.clear(~STICKY_PRIVATE_FLAGS);
privateFlags.set(VALID_PADDR|VALID_SIZE);
} }
/** /**
@ -222,12 +233,14 @@ class Request : public FastAlloc
asid = _asid; asid = _asid;
vaddr = _vaddr; vaddr = _vaddr;
size = _size; size = _size;
flags = _flags;
pc = _pc; pc = _pc;
time = curTick; time = curTick;
flags.set(VALID_VADDR|VALID_SIZE|VALID_PC); flags.clear(~STICKY_FLAGS);
flags.clear(VALID_PADDR|VALID_EXTRA_DATA|MMAPED_IPR); flags.set(_flags);
flags.update(_flags, PUBLIC_FLAGS); privateFlags.clear(~STICKY_PRIVATE_FLAGS);
privateFlags.set(VALID_VADDR|VALID_SIZE|VALID_PC);
} }
/** /**
@ -239,9 +252,9 @@ class Request : public FastAlloc
void void
setPaddr(Addr _paddr) setPaddr(Addr _paddr)
{ {
assert(flags.isSet(VALID_VADDR)); assert(privateFlags.isSet(VALID_VADDR));
paddr = _paddr; paddr = _paddr;
flags.set(VALID_PADDR); privateFlags.set(VALID_PADDR);
} }
/** /**
@ -250,8 +263,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.isSet(VALID_VADDR)); assert(privateFlags.isSet(VALID_VADDR));
assert(flags.noneSet(VALID_PADDR)); assert(privateFlags.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;
@ -265,20 +278,32 @@ class Request : public FastAlloc
/** /**
* Accessor for paddr. * Accessor for paddr.
*/ */
bool
hasPaddr()
{
return privateFlags.isSet(VALID_PADDR);
}
Addr Addr
getPaddr() getPaddr()
{ {
assert(flags.isSet(VALID_PADDR)); assert(privateFlags.isSet(VALID_PADDR));
return paddr; return paddr;
} }
/** /**
* Accessor for size. * Accessor for size.
*/ */
bool
hasSize()
{
return privateFlags.isSet(VALID_SIZE);
}
int int
getSize() getSize()
{ {
assert(flags.isSet(VALID_SIZE)); assert(privateFlags.isSet(VALID_SIZE));
return size; return size;
} }
@ -286,70 +311,30 @@ class Request : public FastAlloc
Tick Tick
getTime() getTime()
{ {
assert(flags.isSet(VALID_PADDR|VALID_VADDR)); assert(privateFlags.isSet(VALID_PADDR|VALID_VADDR));
return time; return time;
} }
void
setTime(Tick when)
{
assert(flags.isSet(VALID_PADDR|VALID_VADDR));
time = when;
}
/** Accessor for flags. */ /** Accessor for flags. */
Flags Flags
getFlags() getFlags()
{ {
assert(flags.isSet(VALID_PADDR|VALID_VADDR)); assert(privateFlags.isSet(VALID_PADDR|VALID_VADDR));
return flags & PUBLIC_FLAGS; return flags;
} }
Flags
anyFlags(Flags _flags)
{
assert(flags.isSet(VALID_PADDR|VALID_VADDR));
assert(_flags.noneSet(~PUBLIC_FLAGS));
return flags.isSet(_flags);
}
Flags
allFlags(Flags _flags)
{
assert(flags.isSet(VALID_PADDR|VALID_VADDR));
assert(_flags.noneSet(~PUBLIC_FLAGS));
return flags.allSet(_flags);
}
/** Accessor for flags. */
void void
setFlags(Flags _flags) setFlags(Flags _flags)
{ {
assert(flags.isSet(VALID_PADDR|VALID_VADDR)); assert(privateFlags.isSet(VALID_PADDR|VALID_VADDR));
assert(_flags.noneSet(~PUBLIC_FLAGS));
flags.set(_flags); flags.set(_flags);
} }
void
clearFlags(Flags _flags)
{
assert(flags.isSet(VALID_PADDR|VALID_VADDR));
assert(_flags.noneSet(~PUBLIC_FLAGS));
flags.clear(_flags);
}
void
clearFlags()
{
assert(flags.isSet(VALID_PADDR|VALID_VADDR));
flags.clear(PUBLIC_FLAGS);
}
/** Accessor function for vaddr.*/ /** Accessor function for vaddr.*/
Addr Addr
getVaddr() getVaddr()
{ {
assert(flags.isSet(VALID_VADDR)); assert(privateFlags.isSet(VALID_VADDR));
return vaddr; return vaddr;
} }
@ -357,7 +342,7 @@ class Request : public FastAlloc
int int
getAsid() getAsid()
{ {
assert(flags.isSet(VALID_VADDR)); assert(privateFlags.isSet(VALID_VADDR));
return asid; return asid;
} }
@ -365,27 +350,18 @@ class Request : public FastAlloc
uint8_t uint8_t
getAsi() getAsi()
{ {
assert(flags.isSet(VALID_VADDR)); assert(privateFlags.isSet(VALID_VADDR));
return flags & ASI_BITS; return flags & ASI_BITS;
} }
/** Accessor function for asi.*/ /** Accessor function for MMAPED_IPR flag. */
void
setAsi(uint8_t a)
{
assert(flags.isSet(VALID_VADDR));
flags.update(a, ASI_BITS);
}
/** Accessor function for asi.*/
bool bool
isMmapedIpr() isMmapedIpr()
{ {
assert(flags.isSet(VALID_PADDR)); assert(privateFlags.isSet(VALID_PADDR));
return flags.isSet(MMAPED_IPR); return flags.isSet(MMAPED_IPR);
} }
/** Accessor function for asi.*/
void void
setMmapedIpr(bool r) setMmapedIpr(bool r)
{ {
@ -397,14 +373,14 @@ class Request : public FastAlloc
bool bool
extraDataValid() extraDataValid()
{ {
return flags.isSet(VALID_EXTRA_DATA); return privateFlags.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.isSet(VALID_EXTRA_DATA)); assert(privateFlags.isSet(VALID_EXTRA_DATA));
return extraData; return extraData;
} }
@ -413,20 +389,20 @@ class Request : public FastAlloc
setExtraData(uint64_t _extraData) setExtraData(uint64_t _extraData)
{ {
extraData = _extraData; extraData = _extraData;
flags.set(VALID_EXTRA_DATA); privateFlags.set(VALID_EXTRA_DATA);
} }
bool bool
hasContextId() const hasContextId() const
{ {
return flags.isSet(VALID_CONTEXT_ID); return privateFlags.isSet(VALID_CONTEXT_ID);
} }
/** Accessor function for context ID.*/ /** Accessor function for context ID.*/
int int
contextId() const contextId() const
{ {
assert(flags.isSet(VALID_CONTEXT_ID)); assert(privateFlags.isSet(VALID_CONTEXT_ID));
return _contextId; return _contextId;
} }
@ -434,21 +410,21 @@ class Request : public FastAlloc
int int
threadId() const threadId() const
{ {
assert(flags.isSet(VALID_THREAD_ID)); assert(privateFlags.isSet(VALID_THREAD_ID));
return _threadId; return _threadId;
} }
bool bool
hasPC() const hasPC() const
{ {
return flags.isSet(VALID_PC); return privateFlags.isSet(VALID_PC);
} }
/** Accessor function for pc.*/ /** Accessor function for pc.*/
Addr Addr
getPC() const getPC() const
{ {
assert(flags.isSet(VALID_PC)); assert(privateFlags.isSet(VALID_PC));
return pc; return pc;
} }