configs/ruby/GPU_VIPER_Region.py

75     def create(self, size, assoc, options):
76         self.size = MemorySize(size)
77         self.assoc = assoc
78         self.replacement_policy = PseudoLRUReplacementPolicy()
85     def create(self, size, assoc, options):
86         self.size = MemorySize(size)
87         self.assoc = assoc
88         self.replacement_policy = PseudoLRUReplacementPolicy()
92     def create(self, options, ruby_system, system):
93         self.version = self.versionCount()
95         self.L1Icache = L1Cache()
96         self.L1Icache.create(options.l1i_size, options.l1i_assoc, options)
97         self.L1D0cache = L1Cache()
98         self.L1D0cache.create(options.l1d_size, options.l1d_assoc, options)
99         self.L1D1cache = L1Cache()
100         self.L1D1cache.create(options.l1d_size, options.l1d_assoc, options)
101         self.L2cache = L2Cache()
102         self.L2cache.create(options.l2_size, options.l2_assoc, options)
104         self.sequencer = RubySequencer()
105         self.sequencer.version = self.seqCount()
106         self.sequencer.icache = self.L1Icache
107         self.sequencer.dcache = self.L1D0cache
108         self.sequencer.ruby_system = ruby_system
109         self.sequencer.coreid = 0
110         self.sequencer.is_cpu_sequencer = True
112         self.sequencer1 = RubySequencer()
113         self.sequencer1.version = self.seqCount()
114         self.sequencer1.icache = self.L1Icache
115         self.sequencer1.dcache = self.L1D1cache
116         self.sequencer1.ruby_system = ruby_system
117         self.sequencer1.coreid = 1
118         self.sequencer1.is_cpu_sequencer = True
120         self.issue_latency = 1
121         self.send_evictions = send_evicts(options)
123         self.ruby_system = ruby_system
126             self.recycle_latency = options.recycle_latency
135     def create(self, options):
136         self.size = MemorySize(options.tcp_size)
137         self.dataArrayBanks = 16
138         self.tagArrayBanks = 16
139         self.dataAccessLatency = 4
140         self.tagAccessLatency = 1
141         self.resourceStalls = options.no_tcc_resource_stalls
142         self.replacement_policy = PseudoLRUReplacementPolicy(assoc = self.assoc)
146     def create(self, options, ruby_system, system):
147         self.version = self.versionCount()
148         self.L1cache = TCPCache(dataAccessLatency = options.TCP_latency)
149         self.L1cache.create(options)
150         self.issue_latency = 1
152         self.coalescer = VIPERCoalescer()
153         self.coalescer.version = self.seqCount()
154         self.coalescer.icache = self.L1cache
155         self.coalescer.dcache = self.L1cache
156         self.coalescer.ruby_system = ruby_system
157         self.coalescer.support_inst_reqs = False
158         self.coalescer.is_cpu_sequencer = False
160         self.sequencer = RubySequencer()
161         self.sequencer.version = self.seqCount()
162         self.sequencer.icache = self.L1cache
163         self.sequencer.dcache = self.L1cache
164         self.sequencer.ruby_system = ruby_system
165         self.sequencer.is_cpu_sequencer = True
167         self.use_seq_not_coal = False
169         self.ruby_system = ruby_system
171             self.recycle_latency = options.recycle_latency
179     def create(self, options):
180         self.size = MemorySize(options.sqc_size)
181         self.assoc = options.sqc_assoc
182         self.replacement_policy = PseudoLRUReplacementPolicy(assoc = self.assoc)
186     def create(self, options, ruby_system, system):
187         self.version = self.versionCount()
188         self.L1cache = SQCCache()
189         self.L1cache.create(options)
190         self.L1cache.resourceStalls = False
191         self.sequencer = RubySequencer()
192         self.sequencer.version = self.seqCount()
193         self.sequencer.icache = self.L1cache
194         self.sequencer.dcache = self.L1cache
195         self.sequencer.ruby_system = ruby_system
196         self.sequencer.support_data_reqs = False
197         self.sequencer.is_cpu_sequencer = False
198         self.ruby_system = ruby_system
200             self.recycle_latency = options.recycle_latency
208     def create(self, options):
209         self.assoc = options.tcc_assoc
214           self.size = MemorySize(tcc_size)
215           self.dataArrayBanks = 64
216           self.tagArrayBanks = 64
218           self.size = MemorySize(options.tcc_size)
219           self.dataArrayBanks = 256 / options.num_tccs #number of data banks
220           self.tagArrayBanks = 256 / options.num_tccs #number of tag banks
221         self.size.value = self.size.value / options.num_tccs
222         if ((self.size.value / long(self.assoc)) < 128):
223             self.size.value = long(128 * self.assoc)
224         self.start_index_bit = math.log(options.cacheline_size, 2) + \
226         self.replacement_policy = PseudoLRUReplacementPolicy(assoc = self.assoc)
229     def create(self, options, ruby_system, system):
230         self.version = self.versionCount()
231         self.L2cache = TCC()
232         self.L2cache.create(options)
233         self.ruby_system = ruby_system
235             self.recycle_latency = options.recycle_latency
241     def create(self, options, ruby_system, system):
242         self.size = MemorySize(options.l3_size)
243         self.size.value /= options.num_dirs
244         self.assoc = options.l3_assoc
245         self.dataArrayBanks /= options.num_dirs
246         self.tagArrayBanks /= options.num_dirs
247         self.dataArrayBanks /= options.num_dirs
248         self.tagArrayBanks /= options.num_dirs
249         self.dataAccessLatency = options.l3_data_latency
250         self.tagAccessLatency = options.l3_tag_latency
251         self.resourceStalls = False
252         self.replacement_policy = PseudoLRUReplacementPolicy(assoc = self.assoc)
255     def create(self, options, ruby_system, system):
256         self.version = self.versionCount()
257         self.L3cache = L3Cache()
258         self.L3cache.create(options, ruby_system, system)
259         self.l3_response_latency = \
260             max(self.L3cache.dataAccessLatency, self.L3cache.tagAccessLatency)
261         self.ruby_system = ruby_system
263             self.recycle_latency = options.recycle_latency
265     def connectWireBuffers(self, req_to_dir, resp_to_dir, l3_unblock_to_dir,
267         self.reqToDir = req_to_dir
268         self.respToDir = resp_to_dir
269         self.l3UnblockToDir = l3_unblock_to_dir
270         self.reqToL3 = req_to_l3
271         self.probeToL3 = probe_to_l3
272         self.respToL3 = resp_to_l3
278     def create(self, options, ruby_system, system):
279         self.version = self.versionCount()
284         self.size = dir_size
293     def create(self, options, ruby_system, system):
294         self.version = self.versionCount()
295         self.response_latency = 25
296         self.response_latency_regionDir = 1
297         self.directory = DirMem()
298         self.directory.create(options, ruby_system, system)
299         self.L3CacheMemory = L3Cache()
300         self.L3CacheMemory.create(options, ruby_system, system)
301         self.l3_hit_latency = \
302             max(self.L3CacheMemory.dataAccessLatency,
303             self.L3CacheMemory.tagAccessLatency)
305         self.ruby_system = ruby_system
307             self.recycle_latency = options.recycle_latency
309     def connectWireBuffers(self, req_to_dir, resp_to_dir, l3_unblock_to_dir,
311         self.reqToDir = req_to_dir
312         self.respToDir = resp_to_dir
313         self.l3UnblockToDir = l3_unblock_to_dir
314         self.reqToL3 = req_to_l3
315         self.probeToL3 = probe_to_l3
316         self.respToL3 = resp_to_l3
321     def create(self, options, ruby_system, system):
322         self.block_size = "%dB" % (64 * options.blocks_per_region)
323         self.size = options.region_dir_entries * \
324             self.block_size * options.num_compute_units
325         self.assoc = 8
326         self.tagArrayBanks = 8
327         self.tagAccessLatency = options.dir_tag_latency
328         self.dataAccessLatency = 1
329         self.resourceStalls = options.no_resource_stalls
330         self.start_index_bit = 6 + int(math.log(options.blocks_per_region, 2))
331         self.replacement_policy = PseudoLRUReplacementPolicy(assoc = self.assoc)
335     def create(self, options, ruby_system, system):
336         self.version = self.versionCount()
337         self.cacheMemory = RegionDir()
338         self.cacheMemory.create(options, ruby_system, system)
339         self.blocksPerRegion = options.blocks_per_region
340         self.toDirLatency = \
341             max(self.cacheMemory.dataAccessLatency,
342             self.cacheMemory.tagAccessLatency)
343         self.ruby_system = ruby_system
344         self.always_migrate = options.always_migrate
345         self.sym_migrate = options.symmetric_migrate
346         self.asym_migrate = options.asymmetric_migrate
347         if self.always_migrate:
348             assert(not self.asym_migrate and not self.sym_migrate)
349         if self.sym_migrate:
350             assert(not self.always_migrate and not self.asym_migrate)
351         if self.asym_migrate:
352             assert(not self.always_migrate and not self.sym_migrate)
354             self.recycle_latency = options.recycle_latency
367     def create(self, options, ruby_system, system):
368         self.version = self.versionCount()
369         self.cacheMemory = RegionBuffer()
370         self.cacheMemory.resourceStalls = options.no_tcc_resource_stalls
371         self.cacheMemory.dataArrayBanks = 64
372         self.cacheMemory.tagArrayBanks = 64
373         self.blocksPerRegion = options.blocks_per_region
374         self.cacheMemory.block_size = "%dB" % (64 * self.blocksPerRegion)
375         self.cacheMemory.start_index_bit = \
376             6 + int(math.log(self.blocksPerRegion, 2))
377         self.cacheMemory.size = options.region_buffer_entries * \
378             self.cacheMemory.block_size * options.num_compute_units
379         self.toDirLatency = options.gpu_to_dir_latency
380         self.toRegionDirLatency = options.cpu_to_dir_latency
381         self.noTCCdir = True
383         self.TCC_select_num_bits = TCC_bits
384         self.ruby_system = ruby_system
387             self.recycle_latency = options.recycle_latency
388         self.cacheMemory.replacement_policy = \
389             PseudoLRUReplacementPolicy(assoc = self.cacheMemory.assoc)