from Ruby import send_evicts
#
-# Note: the L1 Cache latency is only used by the sequencer on fast path hits
+# Declare caches used by the protocol
#
-class L0Cache(RubyCache):
- latency = 1
-
-class L1Cache(RubyCache):
- latency = 5
-
-#
-# Note: the L2 Cache latency is not currently used
-#
-class L2Cache(RubyCache):
- latency = 15
+class L0Cache(RubyCache): pass
+class L1Cache(RubyCache): pass
+class L2Cache(RubyCache): pass
def define_options(parser):
parser.add_option("--num-clusters", type="int", default=1,
from Ruby import send_evicts
#
-# Note: the L1 Cache latency is only used by the sequencer on fast path hits
+# Declare caches used by the protocol
#
-class L1Cache(RubyCache):
- latency = 3
-
-#
-# Note: the L2 Cache latency is not currently used
-#
-class L2Cache(RubyCache):
- latency = 15
+class L1Cache(RubyCache): pass
+class L2Cache(RubyCache): pass
def define_options(parser):
return
from Ruby import send_evicts
#
-# Note: the cache latency is only used by the sequencer on fast path hits
+# Declare caches used by the protocol
#
-class Cache(RubyCache):
- latency = 3
+class Cache(RubyCache): pass
def define_options(parser):
return
from Ruby import send_evicts
#
-# Note: the L1 Cache latency is only used by the sequencer on fast path hits
+# Declare caches used by the protocol
#
-class L1Cache(RubyCache):
- latency = 3
-
-#
-# Note: the L2 Cache latency is not currently used
-#
-class L2Cache(RubyCache):
- latency = 15
+class L1Cache(RubyCache): pass
+class L2Cache(RubyCache): pass
def define_options(parser):
return
from Ruby import send_evicts
#
-# Note: the L1 Cache latency is only used by the sequencer on fast path hits
+# Declare caches used by the protocol
#
-class L1Cache(RubyCache):
- latency = 2
-
-#
-# Note: the L2 Cache latency is not currently used
-#
-class L2Cache(RubyCache):
- latency = 10
+class L1Cache(RubyCache): pass
+class L2Cache(RubyCache): pass
def define_options(parser):
parser.add_option("--l1-retries", type="int", default=1,
from Ruby import send_evicts
#
-# Note: the L1 Cache latency is only used by the sequencer on fast path hits
+# Declare caches used by the protocol
#
-class L1Cache(RubyCache):
- latency = 2
-
-#
-# Note: the L2 Cache latency is not currently used
-#
-class L2Cache(RubyCache):
- latency = 10
-
+class L1Cache(RubyCache): pass
+class L2Cache(RubyCache): pass
#
-# Probe filter is a cache, latency is not used
+# Probe filter is a cache
#
-class ProbeFilter(RubyCache):
- latency = 1
+class ProbeFilter(RubyCache): pass
def define_options(parser):
parser.add_option("--allow-atomic-migration", action="store_true",
from Ruby import create_topology
#
-# Note: the cache latency is only used by the sequencer on fast path hits
+# Declare caches used by the protocol
#
-class Cache(RubyCache):
- latency = 3
+class Cache(RubyCache): pass
def define_options(parser):
return
cxx_class = 'CacheMemory'
cxx_header = "mem/ruby/structures/CacheMemory.hh"
size = Param.MemorySize("capacity in bytes");
- latency = Param.Cycles("");
assoc = Param.Int("");
replacement_policy = Param.ReplacementPolicy(PseudoLRUReplacementPolicy(),
"")
p->start_index_bit, p->ruby_system)
{
m_cache_size = p->size;
- m_latency = p->latency;
m_cache_assoc = p->assoc;
m_replacementPolicy_ptr = p->replacement_policy;
m_replacementPolicy_ptr->setCache(this);
AbstractCacheEntry* lookup(const Address& address);
const AbstractCacheEntry* lookup(const Address& address) const;
- Cycles getLatency() const { return m_latency; }
Cycles getTagLatency() const { return tagArray.getLatency(); }
Cycles getDataLatency() const { return dataArray.getLatency(); }
CacheMemory& operator=(const CacheMemory& obj);
private:
- Cycles m_latency;
-
// Data Members (m_prefix)
bool m_is_instruction_only_cache;
m_instCache_ptr = p->icache;
m_dataCache_ptr = p->dcache;
+ m_data_cache_hit_latency = p->dcache_hit_latency;
+ m_inst_cache_hit_latency = p->icache_hit_latency;
m_max_outstanding_requests = p->max_outstanding_requests;
m_deadlock_threshold = p->deadlock_threshold;
assert(m_deadlock_threshold > 0);
assert(m_instCache_ptr != NULL);
assert(m_dataCache_ptr != NULL);
+ assert(m_data_cache_hit_latency > 0);
+ assert(m_inst_cache_hit_latency > 0);
m_usingNetworkTester = p->using_network_tester;
}
msg->getPhysicalAddress(),
RubyRequestType_to_string(secondary_type));
- Cycles latency(0); // initialzed to an null value
-
+ // The Sequencer currently assesses instruction and data cache hit latency
+ // for the top-level caches at the beginning of a memory access.
+ // TODO: Eventually, this latency should be moved to represent the actual
+ // cache access latency portion of the memory access. This will require
+ // changing cache controller protocol files to assess the latency on the
+ // access response path.
+ Cycles latency(0); // Initialize to zero to catch misconfigured latency
if (secondary_type == RubyRequestType_IFETCH)
- latency = m_instCache_ptr->getLatency();
+ latency = m_inst_cache_hit_latency;
else
- latency = m_dataCache_ptr->getLatency();
+ latency = m_data_cache_hit_latency;
// Send the message to the cache controller
assert(latency > 0);
CacheMemory* m_dataCache_ptr;
CacheMemory* m_instCache_ptr;
+ // The cache access latency for top-level caches (L0/L1). These are
+ // currently assessed at the beginning of each memory access through the
+ // sequencer.
+ // TODO: Migrate these latencies into top-level cache controllers.
+ Cycles m_data_cache_hit_latency;
+ Cycles m_inst_cache_hit_latency;
+
typedef m5::hash_map<Address, SequencerRequest*> RequestTable;
RequestTable m_writeRequestTable;
RequestTable m_readRequestTable;
icache = Param.RubyCache("")
dcache = Param.RubyCache("")
+ # Cache latencies currently assessed at the beginning of each access
+ # NOTE: Setting these values to a value greater than one will result in
+ # O3 CPU pipeline bubbles and negatively impact performance
+ # TODO: Latencies should be migrated into each top-level cache controller
+ icache_hit_latency = Param.Cycles(1, "Inst cache hit latency")
+ dcache_hit_latency = Param.Cycles(1, "Data cache hit latency")
max_outstanding_requests = Param.Int(16,
"max requests (incl. prefetches) outstanding")
deadlock_threshold = Param.Cycles(500000,
projects / gem5.git / commitdiff