/*
- * Copyright (c) 2012-2013, 2015 ARM Limited
+ * Copyright (c) 2012-2013, 2015-2016, 2018 ARM Limited
* All rights reserved.
*
* The license below extends only to copyright in the software and shall
#ifndef __MEM_CACHE_MSHR_HH__
#define __MEM_CACHE_MSHR_HH__
+#include <cassert>
+#include <iosfwd>
#include <list>
+#include <string>
#include "base/printable.hh"
+#include "base/types.hh"
+#include "mem/cache/queue_entry.hh"
#include "mem/packet.hh"
+#include "sim/core.hh"
-class CacheBlk;
-class MSHRQueue;
+class BaseCache;
/**
* Miss Status and handling Register. This class keeps all the information
* needed to handle a cache miss including a list of target requests.
* @sa \ref gem5MemorySystem "gem5 Memory System"
*/
-class MSHR : public Packet::SenderState, public Printable
+class MSHR : public QueueEntry, public Printable
{
/**
- * Consider the MSHRQueue a friend to avoid making everything public
+ * Consider the queues friends to avoid making everything public.
*/
+ template<typename Entry>
+ friend class Queue;
friend class MSHRQueue;
private:
- /** Cycle when ready to issue */
- Tick readyTime;
-
- /** True if the request is uncacheable */
- bool _isUncacheable;
-
/** Flag set by downstream caches */
bool downstreamPending;
public:
+ /** True if the entry is just a simple forward from an upper level */
+ bool isForward;
+
class Target {
public:
const Counter order; //!< Global order (for memory consistency mgmt)
const PacketPtr pkt; //!< Pending request packet.
const Source source; //!< Request from cpu, memory, or prefetcher?
- const bool markedPending; //!< Did we mark upstream MSHR
- //!< as downstreamPending?
+
+ /**
+ * We use this flag to track whether we have cleared the
+ * downstreamPending flag for the MSHR of the cache above
+ * where this packet originates from and guard noninitial
+ * attempts to clear it.
+ *
+ * The flag markedPending needs to be updated when the
+ * TargetList is in service which can be:
+ * 1) during the Target instantiation if the MSHR is in
+ * service and the target is not deferred,
+ * 2) when the MSHR becomes in service if the target is not
+ * deferred,
+ * 3) or when the TargetList is promoted (deferredTargets ->
+ * targets).
+ */
+ bool markedPending;
+
+ const bool allocOnFill; //!< Should the response servicing this
+ //!< target list allocate in the cache?
Target(PacketPtr _pkt, Tick _readyTime, Counter _order,
- Source _source, bool _markedPending)
+ Source _source, bool _markedPending, bool alloc_on_fill)
: recvTime(curTick()), readyTime(_readyTime), order(_order),
- pkt(_pkt), source(_source), markedPending(_markedPending)
+ pkt(_pkt), source(_source), markedPending(_markedPending),
+ allocOnFill(alloc_on_fill)
{}
};
public:
bool needsWritable;
bool hasUpgrade;
+ /** Set when the response should allocate on fill */
+ bool allocOnFill;
+ /**
+ * Determine whether there was at least one non-snooping
+ * target coming from another cache.
+ */
+ bool hasFromCache;
TargetList();
- void resetFlags() { needsWritable = hasUpgrade = false; }
- bool isReset() const { return !needsWritable && !hasUpgrade; }
+
+ /**
+ * Use the provided packet and the source to update the
+ * flags of this TargetList.
+ *
+ * @param pkt Packet considered for the flag update
+ * @param source Indicates the source of the packet
+ * @param alloc_on_fill Whether the pkt would allocate on a fill
+ */
+ void updateFlags(PacketPtr pkt, Target::Source source,
+ bool alloc_on_fill);
+
+ void resetFlags() {
+ needsWritable = false;
+ hasUpgrade = false;
+ allocOnFill = false;
+ hasFromCache = false;
+ }
+
+ /**
+ * Goes through the list of targets and uses them to populate
+ * the flags of this TargetList. When the function returns the
+ * flags are consistent with the properties of packets in the
+ * list.
+ */
+ void populateFlags();
+
+ /**
+ * Tests if the flags of this TargetList have their default
+ * values.
+ */
+ bool isReset() const {
+ return !needsWritable && !hasUpgrade && !allocOnFill &&
+ !hasFromCache;
+ }
+
+ /**
+ * Add the specified packet in the TargetList. This function
+ * stores information related to the added packet and updates
+ * accordingly the flags.
+ *
+ * @param pkt Packet considered for adding
+ * @param readTime Tick at which the packet is processed by this cache
+ * @param order A counter giving a unique id to each target
+ * @param source Indicates the source agent of the packet
+ * @param markPending Set for deferred targets or pending MSHRs
+ * @param alloc_on_fill Whether it should allocate on a fill
+ */
void add(PacketPtr pkt, Tick readyTime, Counter order,
- Target::Source source, bool markPending);
+ Target::Source source, bool markPending,
+ bool alloc_on_fill);
+
+ /**
+ * Convert upgrades to the equivalent request if the cache line they
+ * refer to would have been invalid (Upgrade -> ReadEx, SC* -> Fail).
+ * Used to rejig ordering between targets waiting on an MSHR. */
void replaceUpgrades();
+
void clearDownstreamPending();
- bool checkFunctional(PacketPtr pkt);
+ void clearDownstreamPending(iterator begin, iterator end);
+ bool trySatisfyFunctional(PacketPtr pkt);
void print(std::ostream &os, int verbosity,
const std::string &prefix) const;
};
typedef std::list<MSHR *> List;
/** MSHR list iterator. */
typedef List::iterator Iterator;
- /** MSHR list const_iterator. */
- typedef List::const_iterator ConstIterator;
-
- /** Pointer to queue containing this MSHR. */
- MSHRQueue *queue;
-
- /** Order number assigned by the miss queue. */
- Counter order;
-
- /** Block aligned address of the MSHR. */
- Addr blkAddr;
-
- /** Block size of the cache. */
- unsigned blkSize;
-
- /** True if the request targets the secure memory space. */
- bool isSecure;
-
- /** True if the request has been sent to the bus. */
- bool inService;
-
- /** True if the request is just a simple forward from an upper level */
- bool isForward;
-
- /** Keep track of whether we should allocate on fill or not */
- bool allocOnFill;
/** The pending* and post* flags are only valid if inService is
* true. Using the accessor functions lets us detect if these
/** True if we need to get a writable copy of the block. */
bool needsWritable() const { return targets.needsWritable; }
+ bool isCleaning() const {
+ PacketPtr pkt = targets.front().pkt;
+ return pkt->isClean();
+ }
+
bool isPendingModified() const {
assert(inService); return pendingModified;
}
assert(inService); return postDowngrade;
}
- private:
+ bool sendPacket(BaseCache &cache);
- /** Data buffer (if needed). Currently used only for pending
- * upgrade handling. */
- uint8_t *data;
+ bool allocOnFill() const {
+ return targets.allocOnFill;
+ }
+
+ /**
+ * Determine if there are non-deferred requests from other caches
+ *
+ * @return true if any of the targets is from another cache
+ */
+ bool hasFromCache() const {
+ return targets.hasFromCache;
+ }
+
+ private:
+ /**
+ * Promotes deferred targets that satisfy a predicate
+ *
+ * Deferred targets are promoted to the target list if they
+ * satisfy a given condition. The operation stops at the first
+ * deferred target that doesn't satisfy the condition.
+ *
+ * @param pred A condition on a Target
+ */
+ void promoteIf(const std::function<bool (Target &)>& pred);
/**
* Pointer to this MSHR on the ready list.
public:
- bool isUncacheable() const { return _isUncacheable; }
-
/**
* Allocate a miss to this MSHR.
* @param blk_addr The address of the block.
void allocate(Addr blk_addr, unsigned blk_size, PacketPtr pkt,
Tick when_ready, Counter _order, bool alloc_on_fill);
- bool markInService(bool pending_modified_resp);
+ void markInService(bool pending_modified_resp);
void clearDownstreamPending();
int getNumTargets() const
{ return targets.size() + deferredTargets.size(); }
+ /**
+ * Extracts the subset of the targets that can be serviced given a
+ * received response. This function returns the targets list
+ * unless the response is a ReadRespWithInvalidate. The
+ * ReadRespWithInvalidate is only invalidating response that its
+ * invalidation was not expected when the request (a
+ * ReadSharedReq) was sent out. For ReadRespWithInvalidate we can
+ * safely service only the first FromCPU target and all FromSnoop
+ * targets (inform all snoopers that we no longer have the block).
+ *
+ * @param pkt The response from the downstream memory
+ */
+ TargetList extractServiceableTargets(PacketPtr pkt);
+
/**
* Returns true if there are targets left.
* @return true if there are targets
targets.pop_front();
}
- bool isForwardNoResponse() const
- {
- if (getNumTargets() != 1)
- return false;
- const Target *tgt = &targets.front();
- return tgt->source == Target::FromCPU && !tgt->pkt->needsResponse();
- }
-
bool promoteDeferredTargets();
+ /**
+ * Promotes deferred targets that do not require writable
+ *
+ * Move targets from the deferred targets list to the target list
+ * starting from the first deferred target until the first target
+ * that is a cache maintenance operation or needs a writable copy
+ * of the block
+ */
+ void promoteReadable();
+
+ /**
+ * Promotes deferred targets that do not require writable
+ *
+ * Requests in the deferred target list are moved to the target
+ * list up until the first target that is a cache maintenance
+ * operation or needs a writable copy of the block
+ */
void promoteWritable();
- bool checkFunctional(PacketPtr pkt);
+ bool trySatisfyFunctional(PacketPtr pkt);
/**
* Prints the contents of this MSHR for debugging.
projects / gem5.git / blobdiff