configs/ruby/GPU_RfO.py

72     def create(self, options):
73         self.size = MemorySize(options.tcc_size)
74         self.size.value += (options.num_compute_units *
77         self.start_index_bit = math.log(options.cacheline_size, 2) + \
79         self.replacement_policy = PseudoLRUReplacementPolicy()
83     def create(self, options):
84         self.size = MemorySize(options.l1d_size)
85         self.assoc = options.l1d_assoc
86         self.replacement_policy = PseudoLRUReplacementPolicy()
90     def create(self, options):
91         self.size = MemorySize(options.l1i_size)
92         self.assoc = options.l1i_assoc
93         self.replacement_policy = PseudoLRUReplacementPolicy()
97     def create(self, options):
98         self.size = MemorySize(options.l2_size)
99         self.assoc = options.l2_assoc
100         self.replacement_policy = PseudoLRUReplacementPolicy()
105     def create(self, options, ruby_system, system):
106         self.version = self.versionCount()
108         self.L1Icache = L1ICache()
109         self.L1Icache.create(options)
110         self.L1D0cache = L1DCache()
111         self.L1D0cache.create(options)
112         self.L1D1cache = L1DCache()
113         self.L1D1cache.create(options)
114         self.L2cache = L2Cache()
115         self.L2cache.create(options)
117         self.sequencer = RubySequencer()
118         self.sequencer.version = self.seqCount()
119         self.sequencer.icache = self.L1Icache
120         self.sequencer.dcache = self.L1D0cache
121         self.sequencer.ruby_system = ruby_system
122         self.sequencer.coreid = 0
123         self.sequencer.is_cpu_sequencer = True
125         self.sequencer1 = RubySequencer()
126         self.sequencer1.version = self.seqCount()
127         self.sequencer1.icache = self.L1Icache
128         self.sequencer1.dcache = self.L1D1cache
129         self.sequencer1.ruby_system = ruby_system
130         self.sequencer1.coreid = 1
131         self.sequencer1.is_cpu_sequencer = True
134         self.mandatory_queue_latency = 2
136         self.issue_latency = options.cpu_to_dir_latency
137         self.send_evictions = send_evicts(options)
139         self.ruby_system = ruby_system
142             self.recycle_latency = options.recycle_latency
150     def create(self, options):
151         self.size = MemorySize(options.tcp_size)
152         self.replacement_policy = PseudoLRUReplacementPolicy()
156     def create(self, options, ruby_system, system):
157         self.version = self.versionCount()
159         self.L1cache = TCPCache(tagAccessLatency = options.TCP_latency)
160         self.L1cache.resourceStalls = options.no_resource_stalls
161         self.L1cache.create(options)
163         self.coalescer = RubyGPUCoalescer()
164         self.coalescer.version = self.seqCount()
165         self.coalescer.icache = self.L1cache
166         self.coalescer.dcache = self.L1cache
167         self.coalescer.ruby_system = ruby_system
168         self.coalescer.support_inst_reqs = False
169         self.coalescer.is_cpu_sequencer = False
170         self.coalescer.max_outstanding_requests = options.simds_per_cu * \
174         self.sequencer = RubySequencer()
175         self.sequencer.version = self.seqCount()
176         self.sequencer.icache = self.L1cache
177         self.sequencer.dcache = self.L1cache
178         self.sequencer.ruby_system = ruby_system
179         self.sequencer.is_cpu_sequencer = True
181         self.use_seq_not_coal = False
183         self.ruby_system = ruby_system
186             self.recycle_latency = options.recycle_latency
188     def createCP(self, options, ruby_system, system):
189         self.version = self.versionCount()
191         self.L1cache = TCPCache(tagAccessLatency = options.TCP_latency)
192         self.L1cache.resourceStalls = options.no_resource_stalls
193         self.L1cache.create(options)
195         self.coalescer = RubyGPUCoalescer()
196         self.coalescer.version = self.seqCount()
197         self.coalescer.icache = self.L1cache
198         self.coalescer.dcache = self.L1cache
199         self.coalescer.ruby_system = ruby_system
200         self.coalescer.support_inst_reqs = False
201         self.coalescer.is_cpu_sequencer = False
203         self.sequencer = RubySequencer()
204         self.sequencer.version = self.seqCount()
205         self.sequencer.icache = self.L1cache
206         self.sequencer.dcache = self.L1cache
207         self.sequencer.ruby_system = ruby_system
208         self.sequencer.is_cpu_sequencer = True
210         self.use_seq_not_coal = True
212         self.ruby_system = ruby_system
215             self.recycle_latency = options.recycle_latency
224     def create(self, options):
225         self.replacement_policy = PseudoLRUReplacementPolicy()
229     def create(self, options, ruby_system, system):
230         self.version = self.versionCount()
232         self.L1cache = SQCCache()
233         self.L1cache.create(options)
234         self.L1cache.resourceStalls = options.no_resource_stalls
236         self.sequencer = RubySequencer()
238         self.sequencer.version = self.seqCount()
239         self.sequencer.icache = self.L1cache
240         self.sequencer.dcache = self.L1cache
241         self.sequencer.ruby_system = ruby_system
242         self.sequencer.support_data_reqs = False
243         self.sequencer.is_cpu_sequencer = False
245         self.ruby_system = ruby_system
248             self.recycle_latency = options.recycle_latency
250     def createCP(self, options, ruby_system, system):
251         self.version = self.versionCount()
253         self.L1cache = SQCCache()
254         self.L1cache.create(options)
255         self.L1cache.resourceStalls = options.no_resource_stalls
257         self.sequencer = RubySequencer()
259         self.sequencer.version = self.seqCount()
260         self.sequencer.icache = self.L1cache
261         self.sequencer.dcache = self.L1cache
262         self.sequencer.ruby_system = ruby_system
263         self.sequencer.support_data_reqs = False
265         self.ruby_system = ruby_system
268             self.recycle_latency = options.recycle_latency
276     def create(self, options):
277         self.size = MemorySize(options.tcc_size)
278         self.size = self.size / options.num_tccs
279         self.dataArrayBanks = 256 / options.num_tccs #number of data banks
280         self.tagArrayBanks = 256 / options.num_tccs #number of tag banks
281         if ((self.size.value / long(self.assoc)) < 128):
282             self.size.value = long(128 * self.assoc)
283         self.start_index_bit = math.log(options.cacheline_size, 2) + \
285         self.replacement_policy = PseudoLRUReplacementPolicy()
288     def create(self, options, ruby_system, system):
289         self.version = self.versionCount()
290         self.L2cache = TCC()
291         self.L2cache.create(options)
292         self.l2_response_latency = options.TCC_latency
294         self.number_of_TBEs = 2048
296         self.ruby_system = ruby_system
299             self.recycle_latency = options.recycle_latency
301     def connectWireBuffers(self, req_to_tccdir, resp_to_tccdir,
304         self.w_reqToTCCDir = req_to_tccdir
305         self.w_respToTCCDir = resp_to_tccdir
306         self.w_TCCUnblockToTCCDir = tcc_unblock_to_tccdir
307         self.w_reqToTCC = req_to_tcc
308         self.w_probeToTCC = probe_to_tcc
309         self.w_respToTCC = resp_to_tcc
312     def create(self, options, ruby_system, system):
313         self.version = self.versionCount()
315         self.directory = TccDirCache()
316         self.directory.create(options)
318         self.number_of_TBEs = 1024
320         self.ruby_system = ruby_system
323             self.recycle_latency = options.recycle_latency
325     def connectWireBuffers(self, req_to_tccdir, resp_to_tccdir,
328         self.w_reqToTCCDir = req_to_tccdir
329         self.w_respToTCCDir = resp_to_tccdir
330         self.w_TCCUnblockToTCCDir = tcc_unblock_to_tccdir
331         self.w_reqToTCC = req_to_tcc
332         self.w_probeToTCC = probe_to_tcc
333         self.w_respToTCC = resp_to_tcc
340     def create(self, options, ruby_system, system):
341         self.size = MemorySize(options.l3_size)
342         self.size.value /= options.num_dirs
343         self.dataArrayBanks /= options.num_dirs
344         self.tagArrayBanks /= options.num_dirs
345         self.dataArrayBanks /= options.num_dirs
346         self.tagArrayBanks /= options.num_dirs
347         self.dataAccessLatency = options.l3_data_latency
348         self.tagAccessLatency = options.l3_tag_latency
349         self.resourceStalls = options.no_resource_stalls
350         self.replacement_policy = PseudoLRUReplacementPolicy()
353     def create(self, options, ruby_system, system):
354         self.version = self.versionCount()
355         self.L3cache = L3Cache()
356         self.L3cache.create(options, ruby_system, system)
358         self.l3_response_latency = max(self.L3cache.dataAccessLatency,
359                                        self.L3cache.tagAccessLatency)
360         self.ruby_system = ruby_system
363             self.recycle_latency = options.recycle_latency
365     def connectWireBuffers(self, req_to_dir, resp_to_dir, l3_unblock_to_dir,
367         self.reqToDir = req_to_dir
368         self.respToDir = resp_to_dir
369         self.l3UnblockToDir = l3_unblock_to_dir
370         self.reqToL3 = req_to_l3
371         self.probeToL3 = probe_to_l3
372         self.respToL3 = resp_to_l3
375     def create(self, options, dir_ranges, ruby_system, system):
376         self.version = self.versionCount()
378         self.response_latency = 30
380         self.addr_ranges = dir_ranges
381         self.directory = RubyDirectoryMemory()
383         self.L3CacheMemory = L3Cache()
384         self.L3CacheMemory.create(options, ruby_system, system)
386         self.l3_hit_latency = max(self.L3CacheMemory.dataAccessLatency,
387                                   self.L3CacheMemory.tagAccessLatency)
389         self.number_of_TBEs = options.num_tbes
391         self.ruby_system = ruby_system
394             self.recycle_latency = options.recycle_latency
396     def connectWireBuffers(self, req_to_dir, resp_to_dir, l3_unblock_to_dir,
398         self.reqToDir = req_to_dir
399         self.respToDir = resp_to_dir
400         self.l3UnblockToDir = l3_unblock_to_dir
401         self.reqToL3 = req_to_l3
402         self.probeToL3 = probe_to_l3
403         self.respToL3 = resp_to_l3