base,mem: Support AtomicOpFunctor in the classic memory system
AtomicOpFunctor can be used to implement atomic memory operations.
AtomicOpFunctor is captured inside a memory request and executed directly
in the memory hierarchy in a single step.
This patch enables AtomicOpFunctor pointers to be included in a memory
request and executed in a single step in the classic cache system.
This patch also makes the copy constructor of Request class do a deep
copy of AtomicOpFunctor object. This prevents a copy of a Request object
from accessing a deleted AtomicOpFunctor object.
Change-Id: I6649532b37f711e55f4552ad26893efeb300dd37
Reviewed-on: https://gem5-review.googlesource.com/8185
Reviewed-by: Nikos Nikoleris <nikos.nikoleris@arm.com>
Maintainer: Nikos Nikoleris <nikos.nikoleris@arm.com>
diff --git a/src/base/types.hh b/src/base/types.hh
index 05a29f8..d07c370 100644
--- a/src/base/types.hh
+++ b/src/base/types.hh
@@ -191,6 +191,7 @@
struct AtomicOpFunctor
{
virtual void operator()(uint8_t *p) = 0;
+ virtual AtomicOpFunctor* clone() = 0;
virtual ~AtomicOpFunctor() {}
};
@@ -198,6 +199,7 @@
struct TypedAtomicOpFunctor : public AtomicOpFunctor
{
void operator()(uint8_t *p) { execute((T *)p); }
+ virtual AtomicOpFunctor* clone() = 0;
virtual void execute(T * p) = 0;
};
diff --git a/src/mem/cache/base.cc b/src/mem/cache/base.cc
index e43c3d9..a510bac 100644
--- a/src/mem/cache/base.cc
+++ b/src/mem/cache/base.cc
@@ -836,7 +836,22 @@
// Check RMW operations first since both isRead() and
// isWrite() will be true for them
if (pkt->cmd == MemCmd::SwapReq) {
- cmpAndSwap(blk, pkt);
+ if (pkt->isAtomicOp()) {
+ // extract data from cache and save it into the data field in
+ // the packet as a return value from this atomic op
+
+ int offset = tags->extractBlkOffset(pkt->getAddr());
+ uint8_t *blk_data = blk->data + offset;
+ std::memcpy(pkt->getPtr<uint8_t>(), blk_data, pkt->getSize());
+
+ // execute AMO operation
+ (*(pkt->getAtomicOp()))(blk_data);
+
+ // set block status to dirty
+ blk->status |= BlkDirty;
+ } else {
+ cmpAndSwap(blk, pkt);
+ }
} else if (pkt->isWrite()) {
// we have the block in a writable state and can go ahead,
// note that the line may be also be considered writable in
diff --git a/src/mem/packet.hh b/src/mem/packet.hh
index 5bc466b..5c04112 100644
--- a/src/mem/packet.hh
+++ b/src/mem/packet.hh
@@ -841,7 +841,7 @@
{
if (req->isLLSC())
return MemCmd::StoreCondReq;
- else if (req->isSwap())
+ else if (req->isSwap() || req->isAtomic())
return MemCmd::SwapReq;
else if (req->isCacheInvalidate()) {
return req->isCacheClean() ? MemCmd::CleanInvalidReq :
diff --git a/src/mem/request.hh b/src/mem/request.hh
index 1615a64..189d160 100644
--- a/src/mem/request.hh
+++ b/src/mem/request.hh
@@ -445,12 +445,30 @@
Request(int asid, Addr vaddr, unsigned size, Flags flags, MasterID mid,
Addr pc, ContextID cid, AtomicOpFunctor *atomic_op)
- : atomicOpFunctor(atomic_op)
{
- setVirt(asid, vaddr, size, flags, mid, pc);
+ setVirt(asid, vaddr, size, flags, mid, pc, atomic_op);
setContext(cid);
}
+ Request(const Request& other)
+ : _paddr(other._paddr), _size(other._size),
+ _masterId(other._masterId),
+ _flags(other._flags),
+ _memSpaceConfigFlags(other._memSpaceConfigFlags),
+ privateFlags(other.privateFlags),
+ _time(other._time),
+ _taskId(other._taskId), _asid(other._asid), _vaddr(other._vaddr),
+ _extraData(other._extraData), _contextId(other._contextId),
+ _pc(other._pc), _reqInstSeqNum(other._reqInstSeqNum),
+ translateDelta(other.translateDelta),
+ accessDelta(other.accessDelta), depth(other.depth)
+ {
+ if (other.atomicOpFunctor)
+ atomicOpFunctor = (other.atomicOpFunctor)->clone();
+ else
+ atomicOpFunctor = nullptr;
+ }
+
~Request()
{
if (hasAtomicOpFunctor()) {
@@ -474,7 +492,7 @@
*/
void
setVirt(int asid, Addr vaddr, unsigned size, Flags flags, MasterID mid,
- Addr pc)
+ Addr pc, AtomicOpFunctor *amo_op = nullptr)
{
_asid = asid;
_vaddr = vaddr;
@@ -490,6 +508,7 @@
depth = 0;
accessDelta = 0;
translateDelta = 0;
+ atomicOpFunctor = amo_op;
}
/**