Prefetcher.py revision 14013:aeb3ca1762bb 
1# Copyright (c) 2012, 2014, 2019 ARM Limited
2# All rights reserved.
3#
4# The license below extends only to copyright in the software and shall
5# not be construed as granting a license to any other intellectual
6# property including but not limited to intellectual property relating
7# to a hardware implementation of the functionality of the software
8# licensed hereunder.  You may use the software subject to the license
9# terms below provided that you ensure that this notice is replicated
10# unmodified and in its entirety in all distributions of the software,
11# modified or unmodified, in source code or in binary form.
12#
13# Copyright (c) 2005 The Regents of The University of Michigan
14# All rights reserved.
15#
16# Redistribution and use in source and binary forms, with or without
17# modification, are permitted provided that the following conditions are
18# met: redistributions of source code must retain the above copyright
19# notice, this list of conditions and the following disclaimer;
20# redistributions in binary form must reproduce the above copyright
21# notice, this list of conditions and the following disclaimer in the
22# documentation and/or other materials provided with the distribution;
23# neither the name of the copyright holders nor the names of its
24# contributors may be used to endorse or promote products derived from
25# this software without specific prior written permission.
26#
27# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
30# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
32# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
33# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
35# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
37# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38#
39# Authors: Ron Dreslinski
40#          Mitch Hayenga
41
42from m5.SimObject import *
43from m5.params import *
44from m5.proxy import *
45
46from m5.objects.ClockedObject import ClockedObject
47from m5.objects.IndexingPolicies import *
48from m5.objects.ReplacementPolicies import *
49
50class HWPProbeEvent(object):
51    def __init__(self, prefetcher, obj, *listOfNames):
52        self.obj = obj
53        self.prefetcher = prefetcher
54        self.names = listOfNames
55
56    def register(self):
57        if self.obj:
58            for name in self.names:
59                self.prefetcher.getCCObject().addEventProbe(
60                    self.obj.getCCObject(), name)
61
62class BasePrefetcher(ClockedObject):
63    type = 'BasePrefetcher'
64    abstract = True
65    cxx_header = "mem/cache/prefetch/base.hh"
66    cxx_exports = [
67        PyBindMethod("addEventProbe"),
68        PyBindMethod("addTLB"),
69    ]
70    sys = Param.System(Parent.any, "System this prefetcher belongs to")
71
72    # Get the block size from the parent (system)
73    block_size = Param.Int(Parent.cache_line_size, "Block size in bytes")
74
75    on_miss = Param.Bool(False, "Only notify prefetcher on misses")
76    on_read = Param.Bool(True, "Notify prefetcher on reads")
77    on_write = Param.Bool(True, "Notify prefetcher on writes")
78    on_data  = Param.Bool(True, "Notify prefetcher on data accesses")
79    on_inst  = Param.Bool(True, "Notify prefetcher on instruction accesses")
80    prefetch_on_access = Param.Bool(Parent.prefetch_on_access,
81        "Notify the hardware prefetcher on every access (not just misses)")
82    use_virtual_addresses = Param.Bool(False,
83        "Use virtual addresses for prefetching")
84
85    _events = []
86    def addEvent(self, newObject):
87        self._events.append(newObject)
88
89    # Override the normal SimObject::regProbeListeners method and
90    # register deferred event handlers.
91    def regProbeListeners(self):
92        for tlb in self._tlbs:
93            self.getCCObject().addTLB(tlb.getCCObject())
94        for event in self._events:
95           event.register()
96        self.getCCObject().regProbeListeners()
97
98    def listenFromProbe(self, simObj, *probeNames):
99        if not isinstance(simObj, SimObject):
100            raise TypeError("argument must be of SimObject type")
101        if len(probeNames) <= 0:
102            raise TypeError("probeNames must have at least one element")
103        self.addEvent(HWPProbeEvent(self, simObj, *probeNames))
104    _tlbs = []
105    def registerTLB(self, simObj):
106        if not isinstance(simObj, SimObject):
107            raise TypeError("argument must be a SimObject type")
108        self._tlbs.append(simObj)
109
110class MultiPrefetcher(BasePrefetcher):
111    type = 'MultiPrefetcher'
112    cxx_class = 'MultiPrefetcher'
113    cxx_header = 'mem/cache/prefetch/multi.hh'
114
115    prefetchers = VectorParam.BasePrefetcher([], "Array of prefetchers")
116
117class QueuedPrefetcher(BasePrefetcher):
118    type = "QueuedPrefetcher"
119    abstract = True
120    cxx_class = "QueuedPrefetcher"
121    cxx_header = "mem/cache/prefetch/queued.hh"
122    latency = Param.Int(1, "Latency for generated prefetches")
123    queue_size = Param.Int(32, "Maximum number of queued prefetches")
124    max_prefetch_requests_with_pending_translation = Param.Int(32,
125        "Maximum number of queued prefetches that have a missing translation")
126    queue_squash = Param.Bool(True, "Squash queued prefetch on demand access")
127    queue_filter = Param.Bool(True, "Don't queue redundant prefetches")
128    cache_snoop = Param.Bool(False, "Snoop cache to eliminate redundant request")
129
130    tag_prefetch = Param.Bool(True, "Tag prefetch with PC of generating access")
131
132class StridePrefetcher(QueuedPrefetcher):
133    type = 'StridePrefetcher'
134    cxx_class = 'StridePrefetcher'
135    cxx_header = "mem/cache/prefetch/stride.hh"
136
137    # Do not consult stride prefetcher on instruction accesses
138    on_inst = False
139
140    max_conf = Param.Int(7, "Maximum confidence level")
141    thresh_conf = Param.Int(4, "Threshold confidence level")
142    min_conf = Param.Int(0, "Minimum confidence level")
143    start_conf = Param.Int(4, "Starting confidence for new entries")
144
145    table_sets = Param.Int(16, "Number of sets in PC lookup table")
146    table_assoc = Param.Int(4, "Associativity of PC lookup table")
147    use_master_id = Param.Bool(True, "Use master id based history")
148
149    degree = Param.Int(4, "Number of prefetches to generate")
150
151    # Get replacement policy
152    replacement_policy = Param.BaseReplacementPolicy(RandomRP(),
153        "Replacement policy")
154
155class TaggedPrefetcher(QueuedPrefetcher):
156    type = 'TaggedPrefetcher'
157    cxx_class = 'TaggedPrefetcher'
158    cxx_header = "mem/cache/prefetch/tagged.hh"
159
160    degree = Param.Int(2, "Number of prefetches to generate")
161
162class IndirectMemoryPrefetcher(QueuedPrefetcher):
163    type = 'IndirectMemoryPrefetcher'
164    cxx_class = 'IndirectMemoryPrefetcher'
165    cxx_header = "mem/cache/prefetch/indirect_memory.hh"
166    pt_table_entries = Param.MemorySize("16",
167        "Number of entries of the Prefetch Table")
168    pt_table_assoc = Param.Unsigned(16, "Associativity of the Prefetch Table")
169    pt_table_indexing_policy = Param.BaseIndexingPolicy(
170        SetAssociative(entry_size = 1, assoc = Parent.pt_table_assoc,
171        size = Parent.pt_table_entries),
172        "Indexing policy of the pattern table")
173    pt_table_replacement_policy = Param.BaseReplacementPolicy(LRURP(),
174        "Replacement policy of the pattern table")
175    max_prefetch_distance = Param.Unsigned(16, "Maximum prefetch distance")
176    num_indirect_counter_bits = Param.Unsigned(3,
177        "Number of bits of the indirect counter")
178    ipd_table_entries = Param.MemorySize("4",
179        "Number of entries of the Indirect Pattern Detector")
180    ipd_table_assoc = Param.Unsigned(4,
181        "Associativity of the Indirect Pattern Detector")
182    ipd_table_indexing_policy = Param.BaseIndexingPolicy(
183        SetAssociative(entry_size = 1, assoc = Parent.ipd_table_assoc,
184        size = Parent.ipd_table_entries),
185        "Indexing policy of the Indirect Pattern Detector")
186    ipd_table_replacement_policy = Param.BaseReplacementPolicy(LRURP(),
187        "Replacement policy of the Indirect Pattern Detector")
188    shift_values = VectorParam.Int([2, 3, 4, -3], "Shift values to evaluate")
189    addr_array_len = Param.Unsigned(4, "Number of misses tracked")
190    prefetch_threshold = Param.Unsigned(2,
191        "Counter threshold to start the indirect prefetching")
192    stream_counter_threshold = Param.Unsigned(4,
193        "Counter threshold to enable the stream prefetcher")
194    streaming_distance = Param.Unsigned(4,
195        "Number of prefetches to generate when using the stream prefetcher")
196
197class SignaturePathPrefetcher(QueuedPrefetcher):
198    type = 'SignaturePathPrefetcher'
199    cxx_class = 'SignaturePathPrefetcher'
200    cxx_header = "mem/cache/prefetch/signature_path.hh"
201
202    signature_shift = Param.UInt8(3,
203        "Number of bits to shift when calculating a new signature");
204    signature_bits = Param.UInt16(12,
205        "Size of the signature, in bits");
206    signature_table_entries = Param.MemorySize("1024",
207        "Number of entries of the signature table")
208    signature_table_assoc = Param.Unsigned(2,
209        "Associativity of the signature table")
210    signature_table_indexing_policy = Param.BaseIndexingPolicy(
211        SetAssociative(entry_size = 1, assoc = Parent.signature_table_assoc,
212        size = Parent.signature_table_entries),
213        "Indexing policy of the signature table")
214    signature_table_replacement_policy = Param.BaseReplacementPolicy(LRURP(),
215        "Replacement policy of the signature table")
216
217    num_counter_bits = Param.UInt8(3,
218        "Number of bits of the saturating counters")
219    pattern_table_entries = Param.MemorySize("4096",
220        "Number of entries of the pattern table")
221    pattern_table_assoc = Param.Unsigned(1,
222        "Associativity of the pattern table")
223    strides_per_pattern_entry = Param.Unsigned(4,
224        "Number of strides stored in each pattern entry")
225    pattern_table_indexing_policy = Param.BaseIndexingPolicy(
226        SetAssociative(entry_size = 1, assoc = Parent.pattern_table_assoc,
227        size = Parent.pattern_table_entries),
228        "Indexing policy of the pattern table")
229    pattern_table_replacement_policy = Param.BaseReplacementPolicy(LRURP(),
230        "Replacement policy of the pattern table")
231
232    prefetch_confidence_threshold = Param.Float(0.5,
233        "Minimum confidence to issue prefetches")
234    lookahead_confidence_threshold = Param.Float(0.75,
235        "Minimum confidence to continue exploring lookahead entries")
236
237class SignaturePathPrefetcherV2(SignaturePathPrefetcher):
238    type = 'SignaturePathPrefetcherV2'
239    cxx_class = 'SignaturePathPrefetcherV2'
240    cxx_header = "mem/cache/prefetch/signature_path_v2.hh"
241
242    signature_table_entries = "256"
243    signature_table_assoc = 1
244    pattern_table_entries = "512"
245    pattern_table_assoc = 1
246    num_counter_bits = 4
247    prefetch_confidence_threshold = 0.25
248    lookahead_confidence_threshold = 0.25
249
250    global_history_register_entries = Param.MemorySize("8",
251        "Number of entries of global history register")
252    global_history_register_indexing_policy = Param.BaseIndexingPolicy(
253        SetAssociative(entry_size = 1,
254        assoc = Parent.global_history_register_entries,
255        size = Parent.global_history_register_entries),
256        "Indexing policy of the global history register")
257    global_history_register_replacement_policy = Param.BaseReplacementPolicy(
258        LRURP(), "Replacement policy of the global history register")
259
260class AccessMapPatternMatching(ClockedObject):
261    type = 'AccessMapPatternMatching'
262    cxx_class = 'AccessMapPatternMatching'
263    cxx_header = "mem/cache/prefetch/access_map_pattern_matching.hh"
264
265    block_size = Param.Unsigned(Parent.block_size,
266        "Cacheline size used by the prefetcher using this object")
267
268    limit_stride = Param.Unsigned(0,
269        "Limit the strides checked up to -X/X, if 0, disable the limit")
270    start_degree = Param.Unsigned(4,
271        "Initial degree (Maximum number of prefetches generated")
272    hot_zone_size = Param.MemorySize("2kB", "Memory covered by a hot zone")
273    access_map_table_entries = Param.MemorySize("256",
274        "Number of entries in the access map table")
275    access_map_table_assoc = Param.Unsigned(8,
276        "Associativity of the access map table")
277    access_map_table_indexing_policy = Param.BaseIndexingPolicy(
278        SetAssociative(entry_size = 1, assoc = Parent.access_map_table_assoc,
279        size = Parent.access_map_table_entries),
280        "Indexing policy of the access map table")
281    access_map_table_replacement_policy = Param.BaseReplacementPolicy(LRURP(),
282        "Replacement policy of the access map table")
283    high_coverage_threshold = Param.Float(0.25,
284        "A prefetch coverage factor bigger than this is considered high")
285    low_coverage_threshold = Param.Float(0.125,
286        "A prefetch coverage factor smaller than this is considered low")
287    high_accuracy_threshold = Param.Float(0.5,
288        "A prefetch accuracy factor bigger than this is considered high")
289    low_accuracy_threshold = Param.Float(0.25,
290        "A prefetch accuracy factor smaller than this is considered low")
291    high_cache_hit_threshold = Param.Float(0.875,
292        "A cache hit ratio bigger than this is considered high")
293    low_cache_hit_threshold = Param.Float(0.75,
294        "A cache hit ratio smaller than this is considered low")
295    epoch_cycles = Param.Cycles(256000, "Cycles in an epoch period")
296    offchip_memory_latency = Param.Latency("30ns",
297        "Memory latency used to compute the required memory bandwidth")
298
299class AMPMPrefetcher(QueuedPrefetcher):
300    type = 'AMPMPrefetcher'
301    cxx_class = 'AMPMPrefetcher'
302    cxx_header = "mem/cache/prefetch/access_map_pattern_matching.hh"
303    ampm = Param.AccessMapPatternMatching( AccessMapPatternMatching(),
304        "Access Map Pattern Matching object")
305
306class DeltaCorrelatingPredictionTables(SimObject):
307    type = 'DeltaCorrelatingPredictionTables'
308    cxx_class = 'DeltaCorrelatingPredictionTables'
309    cxx_header = "mem/cache/prefetch/delta_correlating_prediction_tables.hh"
310    deltas_per_entry = Param.Unsigned(20,
311        "Number of deltas stored in each table entry")
312    delta_bits = Param.Unsigned(12, "Bits per delta")
313    delta_mask_bits = Param.Unsigned(8,
314        "Lower bits to mask when comparing deltas")
315    table_entries = Param.MemorySize("128",
316        "Number of entries in the table")
317    table_assoc = Param.Unsigned(128,
318        "Associativity of the table")
319    table_indexing_policy = Param.BaseIndexingPolicy(
320        SetAssociative(entry_size = 1, assoc = Parent.table_assoc,
321        size = Parent.table_entries),
322        "Indexing policy of the table")
323    table_replacement_policy = Param.BaseReplacementPolicy(LRURP(),
324        "Replacement policy of the table")
325
326class DCPTPrefetcher(QueuedPrefetcher):
327    type = 'DCPTPrefetcher'
328    cxx_class = 'DCPTPrefetcher'
329    cxx_header = "mem/cache/prefetch/delta_correlating_prediction_tables.hh"
330    dcpt = Param.DeltaCorrelatingPredictionTables(
331        DeltaCorrelatingPredictionTables(),
332        "Delta Correlating Prediction Tables object")
333
334class IrregularStreamBufferPrefetcher(QueuedPrefetcher):
335    type = "IrregularStreamBufferPrefetcher"
336    cxx_class = "IrregularStreamBufferPrefetcher"
337    cxx_header = "mem/cache/prefetch/irregular_stream_buffer.hh"
338
339    num_counter_bits = Param.Unsigned(2,
340        "Number of bits of the confidence counter")
341    chunk_size = Param.Unsigned(256,
342        "Maximum number of addresses in a temporal stream")
343    degree = Param.Unsigned(4, "Number of prefetches to generate")
344    training_unit_assoc = Param.Unsigned(128,
345        "Associativity of the training unit")
346    training_unit_entries = Param.MemorySize("128",
347        "Number of entries of the training unit")
348    training_unit_indexing_policy = Param.BaseIndexingPolicy(
349        SetAssociative(entry_size = 1, assoc = Parent.training_unit_assoc,
350        size = Parent.training_unit_entries),
351        "Indexing policy of the training unit")
352    training_unit_replacement_policy = Param.BaseReplacementPolicy(LRURP(),
353        "Replacement policy of the training unit")
354
355    prefetch_candidates_per_entry = Param.Unsigned(16,
356        "Number of prefetch candidates stored in a SP-AMC entry")
357    address_map_cache_assoc = Param.Unsigned(128,
358        "Associativity of the PS/SP AMCs")
359    address_map_cache_entries = Param.MemorySize("128",
360        "Number of entries of the PS/SP AMCs")
361    ps_address_map_cache_indexing_policy = Param.BaseIndexingPolicy(
362        SetAssociative(entry_size = 1,
363        assoc = Parent.address_map_cache_assoc,
364        size = Parent.address_map_cache_entries),
365        "Indexing policy of the Physical-to-Structural Address Map Cache")
366    ps_address_map_cache_replacement_policy = Param.BaseReplacementPolicy(
367        LRURP(),
368        "Replacement policy of the Physical-to-Structural Address Map Cache")
369    sp_address_map_cache_indexing_policy = Param.BaseIndexingPolicy(
370        SetAssociative(entry_size = 1,
371        assoc = Parent.address_map_cache_assoc,
372        size = Parent.address_map_cache_entries),
373        "Indexing policy of the Structural-to-Physical Address Mao Cache")
374    sp_address_map_cache_replacement_policy = Param.BaseReplacementPolicy(
375        LRURP(),
376        "Replacement policy of the Structural-to-Physical Address Map Cache")
377
378class SlimAccessMapPatternMatching(AccessMapPatternMatching):
379    start_degree = 2
380    limit_stride = 4
381
382class SlimDeltaCorrelatingPredictionTables(DeltaCorrelatingPredictionTables):
383    table_entries = "256"
384    table_assoc = 256
385    deltas_per_entry = 9
386
387class SlimAMPMPrefetcher(QueuedPrefetcher):
388    type = 'SlimAMPMPrefetcher'
389    cxx_class = 'SlimAMPMPrefetcher'
390    cxx_header = "mem/cache/prefetch/slim_ampm.hh"
391
392    ampm = Param.AccessMapPatternMatching(SlimAccessMapPatternMatching(),
393        "Access Map Pattern Matching object")
394    dcpt = Param.DeltaCorrelatingPredictionTables(
395        SlimDeltaCorrelatingPredictionTables(),
396        "Delta Correlating Prediction Tables object")
397
398class BOPPrefetcher(QueuedPrefetcher):
399    type = "BOPPrefetcher"
400    cxx_class = "BOPPrefetcher"
401    cxx_header = "mem/cache/prefetch/bop.hh"
402    score_max = Param.Unsigned(31, "Max. score to update the best offset")
403    round_max = Param.Unsigned(100, "Max. round to update the best offset")
404    bad_score = Param.Unsigned(10, "Score at which the HWP is disabled")
405    rr_size = Param.Unsigned(64, "Number of entries of each RR bank")
406    tag_bits = Param.Unsigned(12, "Bits used to store the tag")
407    offset_list_size = Param.Unsigned(46,
408                "Number of entries in the offsets list")
409    negative_offsets_enable = Param.Bool(True,
410                "Initialize the offsets list also with negative values \
411                (i.e. the table will have half of the entries with positive \
412                offsets and the other half with negative ones)")
413    delay_queue_enable = Param.Bool(True, "Enable the delay queue")
414    delay_queue_size = Param.Unsigned(15,
415                "Number of entries in the delay queue")
416    delay_queue_cycles = Param.Cycles(60,
417                "Cycles to delay a write in the left RR table from the delay \
418                queue")
419
420class SBOOEPrefetcher(QueuedPrefetcher):
421    type = 'SBOOEPrefetcher'
422    cxx_class = 'SBOOEPrefetcher'
423    cxx_header = "mem/cache/prefetch/sbooe.hh"
424    latency_buffer_size = Param.Int(32, "Entries in the latency buffer")
425    sequential_prefetchers = Param.Int(9, "Number of sequential prefetchers")
426    sandbox_entries = Param.Int(1024, "Size of the address buffer")
427    score_threshold_pct = Param.Percent(25, "Min. threshold to issue a \
428        prefetch. The value is the percentage of sandbox entries to use")
429
430class STeMSPrefetcher(QueuedPrefetcher):
431    type = "STeMSPrefetcher"
432    cxx_class = "STeMSPrefetcher"
433    cxx_header = "mem/cache/prefetch/spatio_temporal_memory_streaming.hh"
434
435    spatial_region_size = Param.MemorySize("2kB",
436        "Memory covered by a hot zone")
437    active_generation_table_entries = Param.MemorySize("64",
438        "Number of entries in the active generation table")
439    active_generation_table_assoc = Param.Unsigned(64,
440        "Associativity of the active generation table")
441    active_generation_table_indexing_policy = Param.BaseIndexingPolicy(
442        SetAssociative(entry_size = 1,
443            assoc = Parent.active_generation_table_assoc,
444            size = Parent.active_generation_table_entries),
445        "Indexing policy of the active generation table")
446    active_generation_table_replacement_policy = Param.BaseReplacementPolicy(
447        LRURP(), "Replacement policy of the active generation table")
448
449    pattern_sequence_table_entries = Param.MemorySize("16384",
450        "Number of entries in the pattern sequence table")
451    pattern_sequence_table_assoc = Param.Unsigned(16384,
452        "Associativity of the pattern sequence table")
453    pattern_sequence_table_indexing_policy = Param.BaseIndexingPolicy(
454        SetAssociative(entry_size = 1,
455            assoc = Parent.pattern_sequence_table_assoc,
456            size = Parent.pattern_sequence_table_entries),
457        "Indexing policy of the pattern sequence table")
458    pattern_sequence_table_replacement_policy = Param.BaseReplacementPolicy(
459        LRURP(), "Replacement policy of the pattern sequence table")
460
461    region_miss_order_buffer_entries = Param.Unsigned(131072,
462        "Number of entries of the Region Miss Order Buffer")
463    reconstruction_entries = Param.Unsigned(256,
464        "Number of reconstruction entries")
465
466class HWPProbeEventRetiredInsts(HWPProbeEvent):
467    def register(self):
468        if self.obj:
469            for name in self.names:
470                self.prefetcher.getCCObject().addEventProbeRetiredInsts(
471                    self.obj.getCCObject(), name)
472
473class PIFPrefetcher(QueuedPrefetcher):
474    type = 'PIFPrefetcher'
475    cxx_class = 'PIFPrefetcher'
476    cxx_header = "mem/cache/prefetch/pif.hh"
477    cxx_exports = [
478        PyBindMethod("addEventProbeRetiredInsts"),
479    ]
480
481    prec_spatial_region_bits = Param.Unsigned(2,
482        "Number of preceding addresses in the spatial region")
483    succ_spatial_region_bits = Param.Unsigned(8,
484        "Number of subsequent addresses in the spatial region")
485    compactor_entries = Param.Unsigned(2, "Entries in the temp. compactor")
486    stream_address_buffer_entries = Param.Unsigned(7, "Entries in the SAB")
487    history_buffer_size = Param.Unsigned(16, "Entries in the history buffer")
488
489    index_entries = Param.MemorySize("64",
490        "Number of entries in the index")
491    index_assoc = Param.Unsigned(64,
492        "Associativity of the index")
493    index_indexing_policy = Param.BaseIndexingPolicy(
494        SetAssociative(entry_size = 1, assoc = Parent.index_assoc,
495        size = Parent.index_entries),
496        "Indexing policy of the index")
497    index_replacement_policy = Param.BaseReplacementPolicy(LRURP(),
498        "Replacement policy of the index")
499
500    def listenFromProbeRetiredInstructions(self, simObj):
501        if not isinstance(simObj, SimObject):
502            raise TypeError("argument must be of SimObject type")
503        self.addEvent(HWPProbeEventRetiredInsts(self, simObj,"RetiredInstsPC"))
504