Blocked_NoTargets,
Blocked_NoWBBuffers,
Blocked_Coherence,
- Blocked_Copy,
NUM_BLOCKED_CAUSES
};
/** Prefetcher */
Prefetcher<TagStore, Buffering> *prefetcher;
- /** Do fast copies in this cache. */
- bool doCopy;
-
- /** Block on a delayed copy. */
- bool blockOnCopy;
-
/**
* The clock ratio of the outgoing bus.
* Used for calculating critical word first.
Packet * invalidatePkt;
Request *invalidateReq;
- /**
- * Temporarily move a block into a MSHR.
- * @todo Remove this when LSQ/SB are fixed and implemented in memtest.
- */
- void pseudoFill(Addr addr);
-
- /**
- * Temporarily move a block into an existing MSHR.
- * @todo Remove this when LSQ/SB are fixed and implemented in memtest.
- */
- void pseudoFill(MSHR *mshr);
-
public:
class Params
TagStore *tags;
Buffering *missQueue;
Coherence *coherence;
- bool doCopy;
- bool blockOnCopy;
BaseCache::Params baseParams;
Prefetcher<TagStore, Buffering> *prefetcher;
bool prefetchAccess;
int hitLatency;
Params(TagStore *_tags, Buffering *mq, Coherence *coh,
- bool do_copy, BaseCache::Params params,
+ BaseCache::Params params,
Prefetcher<TagStore, Buffering> *_prefetcher,
bool prefetch_access, int hit_latency)
- : tags(_tags), missQueue(mq), coherence(coh), doCopy(do_copy),
- blockOnCopy(false), baseParams(params),
+ : tags(_tags), missQueue(mq), coherence(coh),
+ baseParams(params),
prefetcher(_prefetcher), prefetchAccess(prefetch_access),
hitLatency(hit_latency)
{
*/
void handleResponse(Packet * &pkt);
- /**
- * Start handling a copy transaction.
- * @param pkt The copy request to perform.
- */
- void startCopy(Packet * &pkt);
-
- /**
- * Handle a delayed copy transaction.
- * @param pkt The delayed copy request to continue.
- * @param addr The address being responded to.
- * @param blk The block of the current response.
- * @param mshr The mshr being handled.
- */
- void handleCopy(Packet * &pkt, Addr addr, BlkType *blk, MSHR *mshr);
-
/**
* Selects a coherence message to forward to lower levels of the hierarchy.
* @return The coherence message to forward.
Param<bool> prioritizeRequests;
// SimObjectParam<Bus *> in_bus;
// SimObjectParam<Bus *> out_bus;
- Param<bool> do_copy;
SimObjectParam<CoherenceProtocol *> protocol;
Param<Addr> trace_addr;
Param<int> hash_delay;
/* INIT_PARAM_DFLT(in_bus, "incoming bus object", NULL),
INIT_PARAM(out_bus, "outgoing bus object"),
*/
- INIT_PARAM_DFLT(do_copy, "perform fast copies in the cache", false),
INIT_PARAM_DFLT(protocol, "coherence protocol to use in the cache", NULL),
INIT_PARAM_DFLT(trace_addr, "address to trace", 0),
BUILD_NULL_PREFETCHER(t, comp, b); \
} \
Cache<CacheTags<t, comp>, b, c>::Params params(tagStore, mq, coh, \
- do_copy, base_params, \
+ base_params, \
/*in_bus, out_bus,*/ pf, \
prefetch_access, hit_latency); \
Cache<CacheTags<t, comp>, b, c> *retval = \
prefetchAccess(params.prefetchAccess),
tags(params.tags), missQueue(params.missQueue),
coherence(params.coherence), prefetcher(params.prefetcher),
- doCopy(params.doCopy), blockOnCopy(params.blockOnCopy),
hitLatency(params.hitLatency)
{
tags->setCache(this);
}
}
-template<class TagStore, class Buffering, class Coherence>
-void
-Cache<TagStore,Buffering,Coherence>::pseudoFill(Addr addr)
-{
- // Need to temporarily move this blk into MSHRs
- MSHR *mshr = missQueue->allocateTargetList(addr);
- int lat;
- PacketList dummy;
- // Read the data into the mshr
- BlkType *blk = tags->handleAccess(mshr->pkt, lat, dummy, false);
- assert(dummy.empty());
- assert(mshr->pkt->flags & SATISFIED);
- // can overload order since it isn't used on non pending blocks
- mshr->order = blk->status;
- // temporarily remove the block from the cache.
- tags->invalidateBlk(addr);
-}
-
-template<class TagStore, class Buffering, class Coherence>
-void
-Cache<TagStore,Buffering,Coherence>::pseudoFill(MSHR *mshr)
-{
- // Need to temporarily move this blk into MSHRs
- assert(mshr->pkt->cmd == Packet::ReadReq);
- int lat;
- PacketList dummy;
- // Read the data into the mshr
- BlkType *blk = tags->handleAccess(mshr->pkt, lat, dummy, false);
- assert(dummy.empty());
- assert(mshr->pkt->flags & SATISFIED);
- // can overload order since it isn't used on non pending blocks
- mshr->order = blk->status;
- // temporarily remove the block from the cache.
- tags->invalidateBlk(mshr->pkt->getAddr());
-}
-
-
template<class TagStore, class Buffering, class Coherence>
Packet *
Cache<TagStore,Buffering,Coherence>::getCoherencePacket()
return mshr;
}
}
-
- //need to check destination address for copies.
- //TEMP NOT DOING COPIES
-#if 0
- if (mshr->pkt->cmd == Copy) {
- Addr dest = mshr->pkt->dest;
- if (dest < pkt->addr) {
- if (dest + mshr->pkt->size > pkt->addr) {
- return mshr;
- }
- } else {
- if (pkt->addr + pkt->size > dest) {
- return mshr;
- }
- }
- }
-#endif
}
return NULL;
}
PacketList &writebacks)
{
}
-
- /**
- * Unimplemented. Perform a cache block copy from block aligned addresses.
- * @param source The block aligned source address.
- * @param dest The block aligned destination adddress.
- * @param asid The address space ID.
- * @param writebacks List for any generated writeback pktuests.
- */
- void doCopy(Addr source, Addr dest, PacketList &writebacks)
- {
- }
-
- /**
- * Unimplemented.
- */
- void fixCopy(Packet * &pkt, PacketList &writebacks)
- {
- }
-
};
#endif
// can free data blocks
for (int i=num_subs; i < blk->numData; ++i){
// decrement reference count and compare to zero
- /**
- * @todo
- * Make this work with copying.
- */
if (--dataReferenceCount[blk->data_ptr[i]] == 0) {
freeDataBlock(blk->data_ptr[i]);
}
}
-/**
- * @todo This code can break if the src is evicted to get a tag for the dest.
- */
-void
-IIC::doCopy(Addr source, Addr dest, PacketList &writebacks)
-{
-//Copy unsuported now
-#if 0
- IICTag *dest_tag = findBlock(dest);
-
- if (dest_tag) {
- for (int i = 0; i < dest_tag->numData; ++i) {
- if (--dataReferenceCount[dest_tag->data_ptr[i]] == 0) {
- freeDataBlock(dest_tag->data_ptr[i]);
- }
- }
- // Reset replacement entry
- } else {
- dest_tag = getFreeTag(hash(dest), writebacks);
- dest_tag->re = (void*) repl->add(dest_tag - tagStore);
- dest_tag->set = hash(dest);
- dest_tag->tag = extractTag(dest);
- dest_tag->status = BlkValid | BlkWritable;
- }
- // Find the source tag here since it might move if we need to find a
- // tag for the destination.
- IICTag *src_tag = findBlock(source);
- assert(src_tag);
- assert(!cache->doData() || src_tag->size <= trivialSize
- || src_tag->numData > 0);
- // point dest to source data and inc counter
- for (int i = 0; i < src_tag->numData; ++i) {
- dest_tag->data_ptr[i] = src_tag->data_ptr[i];
- ++dataReferenceCount[dest_tag->data_ptr[i]];
- }
-
- // Maintain fast access data.
- memcpy(dest_tag->data, src_tag->data, blkSize);
-
- dest_tag->xc = src_tag->xc;
- dest_tag->size = src_tag->size;
- dest_tag->numData = src_tag->numData;
- if (src_tag->numData == 0) {
- // Data is stored in the trivial data, just copy it.
- memcpy(dest_tag->trivialData, src_tag->trivialData, src_tag->size);
- }
-
- dest_tag->status |= BlkDirty;
- if (dest_tag->size < blkSize) {
- dest_tag->status |= BlkCompressed;
- } else {
- dest_tag->status &= ~BlkCompressed;
- }
-#endif
-}
-
-void
-IIC::fixCopy(Packet * &pkt, PacketList &writebacks)
-{
-#if 0
- // if reference counter is greater than 1, do copy
- // else do write
- Addr blk_addr = blkAlign(pkt->getAddr);
- IICTag* blk = findBlock(blk_addr);
-
- if (blk->numData > 0 && dataReferenceCount[blk->data_ptr[0]] != 1) {
- // copy the data
- // Mark the block as referenced so it doesn't get replaced.
- blk->status |= BlkReferenced;
- for (int i = 0; i < blk->numData; ++i){
- unsigned long new_data = getFreeDataBlock(writebacks);
- // Need to refresh pointer
- /**
- * @todo Remove this refetch once we change IIC to pointer based
- */
- blk = findBlock(blk_addr);
- assert(blk);
- if (cache->doData()) {
- memcpy(&(dataBlks[new_data][0]),
- &(dataBlks[blk->data_ptr[i]][0]),
- subSize);
- }
- dataReferenceCount[blk->data_ptr[i]]--;
- dataReferenceCount[new_data]++;
- blk->data_ptr[i] = new_data;
- }
- }
-#endif
-}
-
void
IIC::cleanupRefs()
{
void writeData(IICTag *blk, uint8_t *data, int size,
PacketList & writebacks);
- /**
- * Perform a block aligned copy from the source address to the destination.
- * @param source The block-aligned source address.
- * @param dest The block-aligned destination address.
- * @param asid The address space DI.
- * @param writebacks List for any generated writeback pktuests.
- */
- void doCopy(Addr source, Addr dest, PacketList &writebacks);
-
- /**
- * If a block is currently marked copy on write, copy it before writing.
- * @param pkt The write request.
- * @param writebacks List for any generated writeback pktuests.
- */
- void fixCopy(Packet * &pkt, PacketList &writebacks);
-
/**
* Called at end of simulation to complete average block reference stats.
*/
}
}
-void
-LRU::doCopy(Addr source, Addr dest, PacketList &writebacks)
-{
- assert(source == blkAlign(source));
- assert(dest == blkAlign(dest));
- LRUBlk *source_blk = findBlock(source);
- assert(source_blk);
- LRUBlk *dest_blk = findBlock(dest);
- if (dest_blk == NULL) {
- // Need to do a replacement
- Request *search = new Request(dest,1,0);
- Packet * pkt = new Packet(search, Packet::ReadReq, -1);
- BlkList dummy_list;
- dest_blk = findReplacement(pkt, writebacks, dummy_list);
- if (dest_blk->isValid() && dest_blk->isModified()) {
- // Need to writeback data.
-/* pkt = buildWritebackReq(regenerateBlkAddr(dest_blk->tag,
- dest_blk->set),
- dest_blk->req->asid,
- dest_blk->xc,
- blkSize,
- dest_blk->data,
- dest_blk->size);
-*/
- Request *writebackReq = new Request(regenerateBlkAddr(dest_blk->tag,
- dest_blk->set),
- blkSize, 0);
- Packet *writeback = new Packet(writebackReq, Packet::Writeback, -1);
- writeback->allocate();
- memcpy(writeback->getPtr<uint8_t>(),dest_blk->data, blkSize);
- writebacks.push_back(writeback);
- }
- dest_blk->tag = extractTag(dest);
- delete search;
- delete pkt;
- }
- /**
- * @todo Can't assume the status once we have coherence on copies.
- */
-
- // Set this block as readable, writeable, and dirty.
- dest_blk->status = 7;
- memcpy(dest_blk->data, source_blk->data, blkSize);
-}
-
void
LRU::cleanupRefs()
{
blk->size = size;
}
- /**
- * Perform a block aligned copy from the source address to the destination.
- * @param source The block-aligned source address.
- * @param dest The block-aligned destination address.
- * @param asid The address space DI.
- * @param writebacks List for any generated writeback pktuests.
- */
- void doCopy(Addr source, Addr dest, PacketList &writebacks);
-
- /**
- * No impl.
- */
- void fixCopy(Packet * &pkt, PacketList &writebacks)
- {
- }
-
/**
* Called at end of simulation to complete average block reference stats.
*/
tagsInUse--;
}
-void
-Split::doCopy(Addr source, Addr dest, PacketList &writebacks)
-{
- if (lru->probe( source))
- lru->doCopy(source, dest, writebacks);
- else {
- if (lifo && lifo_net)
- lifo_net->doCopy(source, dest, writebacks);
- else if (lru_net)
- lru_net->doCopy(source, dest, writebacks);
- }
-}
-
void
Split::cleanupRefs()
{
blk->size = size;
}
- /**
- * Perform a block aligned copy from the source address to the destination.
- * @param source The block-aligned source address.
- * @param dest The block-aligned destination address.
- * @param asid The address space DI.
- * @param writebacks List for any generated writeback pktuests.
- */
- void doCopy(Addr source, Addr dest, PacketList &writebacks);
-
- /**
- * No impl.
- */
- void fixCopy(Packet * &pkt, PacketList &writebacks)
- {
- }
-
/**
* Called at end of simulation to complete average block reference stats.
*/
}
}
-void
-SplitLIFO::doCopy(Addr source, Addr dest, PacketList &writebacks)
-{
-//Copy Unsuported for now
-#if 0
- assert(source == blkAlign(source));
- assert(dest == blkAlign(dest));
- SplitBlk *source_blk = findBlock(source);
- assert(source_blk);
- SplitBlk *dest_blk = findBlock(dest);
- if (dest_blk == NULL) {
- // Need to do a replacement
- Packet * pkt = new Packet();
- pkt->paddr = dest;
- BlkList dummy_list;
- dest_blk = findReplacement(pkt, writebacks, dummy_list);
- if (dest_blk->isValid() && dest_blk->isModified()) {
- // Need to writeback data.
- pkt = buildWritebackReq(regenerateBlkAddr(dest_blk->tag,
- dest_blk->set),
- dest_blk->xc,
- blkSize,
- (cache->doData())?dest_blk->data:0,
- dest_blk->size);
- writebacks.push_back(pkt);
- }
- dest_blk->tag = extractTag(dest);
- /**
- * @todo Do we need to pass in the execution context, or can we
- * assume its the same?
- */
- assert(source_blk->xc);
- dest_blk->xc = source_blk->xc;
- }
- /**
- * @todo Can't assume the status once we have coherence on copies.
- */
-
- // Set this block as readable, writeable, and dirty.
- dest_blk->status = 7;
- if (cache->doData()) {
- memcpy(dest_blk->data, source_blk->data, blkSize);
- }
-#endif
-}
-
void
SplitLIFO::cleanupRefs()
{
blk->size = size;
}
- /**
- * Perform a block aligned copy from the source address to the destination.
- * @param source The block-aligned source address.
- * @param dest The block-aligned destination address.
- * @param asid The address space DI.
- * @param writebacks List for any generated writeback pktuests.
- */
- void doCopy(Addr source, Addr dest, PacketList &writebacks);
-
- /**
- * No impl.
- */
- void fixCopy(Packet * &pkt, PacketList &writebacks)
- {
- }
-
/**
* Called at end of simulation to complete average block reference stats.
*/
}
}
-void
-SplitLRU::doCopy(Addr source, Addr dest, PacketList &writebacks)
-{
-//Copy not supported for now
-#if 0
- assert(source == blkAlign(source));
- assert(dest == blkAlign(dest));
- SplitBlk *source_blk = findBlock(source);
- assert(source_blk);
- SplitBlk *dest_blk = findBlock(dest);
- if (dest_blk == NULL) {
- // Need to do a replacement
- Packet * pkt = new Packet();
- pkt->paddr = dest;
- BlkList dummy_list;
- dest_blk = findReplacement(pkt, writebacks, dummy_list);
- if (dest_blk->isValid() && dest_blk->isModified()) {
- // Need to writeback data.
- pkt = buildWritebackReq(regenerateBlkAddr(dest_blk->tag,
- dest_blk->set),
- dest_blk->xc,
- blkSize,
- (cache->doData())?dest_blk->data:0,
- dest_blk->size);
- writebacks.push_back(pkt);
- }
- dest_blk->tag = extractTag(dest);
- /**
- * @todo Do we need to pass in the execution context, or can we
- * assume its the same?
- */
- assert(source_blk->xc);
- dest_blk->xc = source_blk->xc;
- }
- /**
- * @todo Can't assume the status once we have coherence on copies.
- */
-
- // Set this block as readable, writeable, and dirty.
- dest_blk->status = 7;
- if (cache->doData()) {
- memcpy(dest_blk->data, source_blk->data, blkSize);
- }
-#endif
-}
-
void
SplitLRU::cleanupRefs()
{
blk->size = size;
}
- /**
- * Perform a block aligned copy from the source address to the destination.
- * @param source The block-aligned source address.
- * @param dest The block-aligned destination address.
- * @param asid The address space DI.
- * @param writebacks List for any generated writeback pktuests.
- */
- void doCopy(Addr source, Addr dest, PacketList &writebacks);
-
- /**
- * No impl.
- */
- void fixCopy(Packet * &pkt, PacketList &writebacks)
- {
- }
-
/**
* Called at end of simulation to complete average block reference stats.
*/
"This cache connects to a compressed memory")
compression_latency = Param.Latency('0ns',
"Latency in cycles of compression algorithm")
- do_copy = Param.Bool(False, "perform fast copies in the cache")
hash_delay = Param.Int(1, "time in cycles of hash access")
lifo = Param.Bool(False,
"whether this NIC partition should use LIFO repl. policy")
projects / gem5.git / commitdiff