configs/ruby/GPU_VIPER.py

74     def create(self, size, assoc, options):
75         self.size = MemorySize(size)
76         self.assoc = assoc
77         self.replacement_policy = PseudoLRUReplacementPolicy()
84     def create(self, size, assoc, options):
85         self.size = MemorySize(size)
86         self.assoc = assoc
87         self.replacement_policy = PseudoLRUReplacementPolicy()
91     def create(self, options, ruby_system, system):
92         self.version = self.versionCount()
94         self.L1Icache = L1Cache()
95         self.L1Icache.create(options.l1i_size, options.l1i_assoc, options)
96         self.L1D0cache = L1Cache()
97         self.L1D0cache.create(options.l1d_size, options.l1d_assoc, options)
98         self.L1D1cache = L1Cache()
99         self.L1D1cache.create(options.l1d_size, options.l1d_assoc, options)
100         self.L2cache = L2Cache()
101         self.L2cache.create(options.l2_size, options.l2_assoc, options)
103         self.sequencer = RubySequencer()
104         self.sequencer.version = self.seqCount()
105         self.sequencer.icache = self.L1Icache
106         self.sequencer.dcache = self.L1D0cache
107         self.sequencer.ruby_system = ruby_system
108         self.sequencer.coreid = 0
109         self.sequencer.is_cpu_sequencer = True
111         self.sequencer1 = RubySequencer()
112         self.sequencer1.version = self.seqCount()
113         self.sequencer1.icache = self.L1Icache
114         self.sequencer1.dcache = self.L1D1cache
115         self.sequencer1.ruby_system = ruby_system
116         self.sequencer1.coreid = 1
117         self.sequencer1.is_cpu_sequencer = True
119         self.issue_latency = options.cpu_to_dir_latency
120         self.send_evictions = send_evicts(options)
122         self.ruby_system = ruby_system
125             self.recycle_latency = options.recycle_latency
134     def create(self, options):
135         self.size = MemorySize(options.tcp_size)
136         self.assoc = options.tcp_assoc
137         self.resourceStalls = options.no_tcc_resource_stalls
138         self.replacement_policy = PseudoLRUReplacementPolicy()
142     def create(self, options, ruby_system, system):
143         self.version = self.versionCount()
145         self.L1cache = TCPCache(tagAccessLatency = options.TCP_latency,
147         self.L1cache.resourceStalls = options.no_resource_stalls
148         self.L1cache.create(options)
149         self.issue_latency = 1
151         self.coalescer = VIPERCoalescer()
152         self.coalescer.version = self.seqCount()
153         self.coalescer.icache = self.L1cache
154         self.coalescer.dcache = self.L1cache
155         self.coalescer.ruby_system = ruby_system
156         self.coalescer.support_inst_reqs = False
157         self.coalescer.is_cpu_sequencer = False
159         self.sequencer = RubySequencer()
160         self.sequencer.version = self.seqCount()
161         self.sequencer.icache = self.L1cache
162         self.sequencer.dcache = self.L1cache
163         self.sequencer.ruby_system = ruby_system
164         self.sequencer.is_cpu_sequencer = True
166         self.use_seq_not_coal = False
168         self.ruby_system = ruby_system
171             self.recycle_latency = options.recycle_latency
173     def createCP(self, options, ruby_system, system):
174         self.version = self.versionCount()
176         self.L1cache = TCPCache(tagAccessLatency = options.TCP_latency,
178         self.L1cache.resourceStalls = options.no_resource_stalls
179         self.L1cache.create(options)
180         self.issue_latency = 1
182         self.coalescer = VIPERCoalescer()
183         self.coalescer.version = self.seqCount()
184         self.coalescer.icache = self.L1cache
185         self.coalescer.dcache = self.L1cache
186         self.coalescer.ruby_system = ruby_system
187         self.coalescer.support_inst_reqs = False
188         self.coalescer.is_cpu_sequencer = False
190         self.sequencer = RubySequencer()
191         self.sequencer.version = self.seqCount()
192         self.sequencer.icache = self.L1cache
193         self.sequencer.dcache = self.L1cache
194         self.sequencer.ruby_system = ruby_system
195         self.sequencer.is_cpu_sequencer = True
197         self.use_seq_not_coal = True
199         self.ruby_system = ruby_system
202             self.recycle_latency = options.recycle_latency
210     def create(self, options):
211         self.size = MemorySize(options.sqc_size)
212         self.assoc = options.sqc_assoc
213         self.replacement_policy = PseudoLRUReplacementPolicy()
217     def create(self, options, ruby_system, system):
218         self.version = self.versionCount()
220         self.L1cache = SQCCache()
221         self.L1cache.create(options)
222         self.L1cache.resourceStalls = options.no_resource_stalls
224         self.sequencer = RubySequencer()
226         self.sequencer.version = self.seqCount()
227         self.sequencer.icache = self.L1cache
228         self.sequencer.dcache = self.L1cache
229         self.sequencer.ruby_system = ruby_system
230         self.sequencer.support_data_reqs = False
231         self.sequencer.is_cpu_sequencer = False
233         self.ruby_system = ruby_system
236             self.recycle_latency = options.recycle_latency
244     def create(self, options):
245         self.assoc = options.tcc_assoc
250           self.size = MemorySize(tcc_size)
251           self.dataArrayBanks = 64
252           self.tagArrayBanks = 64
254           self.size = MemorySize(options.tcc_size)
255           self.dataArrayBanks = 256 / options.num_tccs #number of data banks
256           self.tagArrayBanks = 256 / options.num_tccs #number of tag banks
257         self.size.value = self.size.value / options.num_tccs
258         if ((self.size.value / long(self.assoc)) < 128):
259             self.size.value = long(128 * self.assoc)
260         self.start_index_bit = math.log(options.cacheline_size, 2) + \
262         self.replacement_policy = PseudoLRUReplacementPolicy()
266     def create(self, options, ruby_system, system):
267         self.version = self.versionCount()
268         self.L2cache = TCC()
269         self.L2cache.create(options)
270         self.L2cache.resourceStalls = options.no_tcc_resource_stalls
272         self.ruby_system = ruby_system
275             self.recycle_latency = options.recycle_latency
281     def create(self, options, ruby_system, system):
282         self.size = MemorySize(options.l3_size)
283         self.size.value /= options.num_dirs
284         self.assoc = options.l3_assoc
285         self.dataArrayBanks /= options.num_dirs
286         self.tagArrayBanks /= options.num_dirs
287         self.dataArrayBanks /= options.num_dirs
288         self.tagArrayBanks /= options.num_dirs
289         self.dataAccessLatency = options.l3_data_latency
290         self.tagAccessLatency = options.l3_tag_latency
291         self.resourceStalls = False
292         self.replacement_policy = PseudoLRUReplacementPolicy()
295     def create(self, options, ruby_system, system):
296         self.version = self.versionCount()
297         self.L3cache = L3Cache()
298         self.L3cache.create(options, ruby_system, system)
300         self.l3_response_latency = max(self.L3cache.dataAccessLatency, self.L3cache.tagAccessLatency)
301         self.ruby_system = ruby_system
304             self.recycle_latency = options.recycle_latency
306     def connectWireBuffers(self, req_to_dir, resp_to_dir, l3_unblock_to_dir,
308         self.reqToDir = req_to_dir
309         self.respToDir = resp_to_dir
310         self.l3UnblockToDir = l3_unblock_to_dir
311         self.reqToL3 = req_to_l3
312         self.probeToL3 = probe_to_l3
313         self.respToL3 = resp_to_l3
316     def create(self, options, ruby_system, system):
317         self.version = self.versionCount()
323         self.size = dir_size
326     def create(self, options, ruby_system, system):
327         self.version = self.versionCount()
329         self.response_latency = 30
331         self.directory = DirMem()
332         self.directory.create(options, ruby_system, system)
334         self.L3CacheMemory = L3Cache()
335         self.L3CacheMemory.create(options, ruby_system, system)
337         self.l3_hit_latency = max(self.L3CacheMemory.dataAccessLatency,
338                                   self.L3CacheMemory.tagAccessLatency)
340         self.number_of_TBEs = options.num_tbes
342         self.ruby_system = ruby_system
345             self.recycle_latency = options.recycle_latency
347     def connectWireBuffers(self, req_to_dir, resp_to_dir, l3_unblock_to_dir,
349         self.reqToDir = req_to_dir
350         self.respToDir = resp_to_dir
351         self.l3UnblockToDir = l3_unblock_to_dir
352         self.reqToL3 = req_to_l3
353         self.probeToL3 = probe_to_l3
354         self.respToL3 = resp_to_l3