| # Copyright (c) 2011-2015 Advanced Micro Devices, Inc. |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are met: |
| # |
| # 1. Redistributions of source code must retain the above copyright notice, |
| # this list of conditions and the following disclaimer. |
| # |
| # 2. Redistributions in binary form must reproduce the above copyright notice, |
| # this list of conditions and the following disclaimer in the documentation |
| # and/or other materials provided with the distribution. |
| # |
| # 3. Neither the name of the copyright holder nor the names of its |
| # contributors may be used to endorse or promote products derived from this |
| # software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
| # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| # POSSIBILITY OF SUCH DAMAGE. |
| |
| # Configure the TLB hierarchy |
| # Places which would probably need to be modified if you |
| # want a different hierarchy are specified by a <Modify here .. >' |
| # comment |
| import m5 |
| from m5.objects import * |
| |
| |
| def TLB_constructor(options, level, gpu_ctrl=None, full_system=False): |
| |
| if full_system: |
| constructor_call = ( |
| "VegaGPUTLB(\ |
| gpu_device = gpu_ctrl, \ |
| size = options.L%(level)dTLBentries, \ |
| assoc = options.L%(level)dTLBassoc, \ |
| hitLatency = options.L%(level)dAccessLatency,\ |
| missLatency1 = options.L%(level)dMissLatency,\ |
| missLatency2 = options.L%(level)dMissLatency,\ |
| maxOutstandingReqs = options.L%(level)dMaxOutstandingReqs,\ |
| clk_domain = SrcClockDomain(\ |
| clock = options.gpu_clock,\ |
| voltage_domain = VoltageDomain(\ |
| voltage = options.gpu_voltage)))" |
| % locals() |
| ) |
| else: |
| constructor_call = ( |
| "X86GPUTLB(size = options.L%(level)dTLBentries, \ |
| assoc = options.L%(level)dTLBassoc, \ |
| hitLatency = options.L%(level)dAccessLatency,\ |
| missLatency2 = options.L%(level)dMissLatency,\ |
| maxOutstandingReqs = options.L%(level)dMaxOutstandingReqs,\ |
| accessDistance = options.L%(level)dAccessDistanceStat,\ |
| clk_domain = SrcClockDomain(\ |
| clock = options.gpu_clock,\ |
| voltage_domain = VoltageDomain(\ |
| voltage = options.gpu_voltage)))" |
| % locals() |
| ) |
| return constructor_call |
| |
| |
| def Coalescer_constructor(options, level, full_system): |
| |
| if full_system: |
| constructor_call = ( |
| "VegaTLBCoalescer(probesPerCycle = \ |
| options.L%(level)dProbesPerCycle, \ |
| tlb_level = %(level)d ,\ |
| coalescingWindow = options.L%(level)dCoalescingWindow,\ |
| disableCoalescing = options.L%(level)dDisableCoalescing,\ |
| clk_domain = SrcClockDomain(\ |
| clock = options.gpu_clock,\ |
| voltage_domain = VoltageDomain(\ |
| voltage = options.gpu_voltage)))" |
| % locals() |
| ) |
| else: |
| constructor_call = ( |
| "TLBCoalescer(probesPerCycle = \ |
| options.L%(level)dProbesPerCycle, \ |
| coalescingWindow = options.L%(level)dCoalescingWindow,\ |
| disableCoalescing = options.L%(level)dDisableCoalescing,\ |
| clk_domain = SrcClockDomain(\ |
| clock = options.gpu_clock,\ |
| voltage_domain = VoltageDomain(\ |
| voltage = options.gpu_voltage)))" |
| % locals() |
| ) |
| return constructor_call |
| |
| |
| def create_TLB_Coalescer( |
| options, |
| my_level, |
| my_index, |
| tlb_name, |
| coalescer_name, |
| gpu_ctrl=None, |
| full_system=False, |
| ): |
| # arguments: options, TLB level, number of private structures for this |
| # Level, TLB name and Coalescer name |
| for i in range(my_index): |
| tlb_name.append( |
| eval(TLB_constructor(options, my_level, gpu_ctrl, full_system)) |
| ) |
| coalescer_name.append( |
| eval(Coalescer_constructor(options, my_level, full_system)) |
| ) |
| |
| |
| def config_tlb_hierarchy( |
| options, system, shader_idx, gpu_ctrl=None, full_system=False |
| ): |
| n_cu = options.num_compute_units |
| |
| if options.TLB_config == "perLane": |
| num_TLBs = 64 * n_cu |
| elif options.TLB_config == "mono": |
| num_TLBs = 1 |
| elif options.TLB_config == "perCU": |
| num_TLBs = n_cu |
| elif options.TLB_config == "2CU": |
| num_TLBs = n_cu >> 1 |
| else: |
| print("Bad option for TLB Configuration.") |
| sys.exit(1) |
| |
| # ------------------------------------------------------------------------- |
| # A visual representation of the TLB hierarchy |
| # for ease of configuration |
| # < Modify here the width and the number of levels if you want a different |
| # configuration > |
| # width is the number of TLBs of the given type (i.e., D-TLB, I-TLB etc) |
| # for this level |
| L1 = [ |
| { |
| "name": "sqc", |
| "width": options.num_sqc, |
| "TLBarray": [], |
| "CoalescerArray": [], |
| }, |
| { |
| "name": "scalar", |
| "width": options.num_scalar_cache, |
| "TLBarray": [], |
| "CoalescerArray": [], |
| }, |
| { |
| "name": "l1", |
| "width": num_TLBs, |
| "TLBarray": [], |
| "CoalescerArray": [], |
| }, |
| ] |
| |
| L2 = [{"name": "l2", "width": 1, "TLBarray": [], "CoalescerArray": []}] |
| L3 = [{"name": "l3", "width": 1, "TLBarray": [], "CoalescerArray": []}] |
| |
| TLB_hierarchy = [L1, L2, L3] |
| |
| # ------------------------------------------------------------------------- |
| # Create the hiearchy |
| # Call the appropriate constructors and add objects to the system |
| |
| for i in range(len(TLB_hierarchy)): |
| hierarchy_level = TLB_hierarchy[i] |
| level = i + 1 |
| for TLB_type in hierarchy_level: |
| TLB_index = TLB_type["width"] |
| TLB_array = TLB_type["TLBarray"] |
| Coalescer_array = TLB_type["CoalescerArray"] |
| # If the sim calls for a fixed L1 TLB size across CUs, |
| # override the TLB entries option |
| if options.tot_L1TLB_size: |
| options.L1TLBentries = options.tot_L1TLB_size / num_TLBs |
| if options.L1TLBassoc > options.L1TLBentries: |
| options.L1TLBassoc = options.L1TLBentries |
| # call the constructors for the TLB and the Coalescer |
| create_TLB_Coalescer( |
| options, |
| level, |
| TLB_index, |
| TLB_array, |
| Coalescer_array, |
| gpu_ctrl, |
| full_system, |
| ) |
| |
| system_TLB_name = TLB_type["name"] + "_tlb" |
| system_Coalescer_name = TLB_type["name"] + "_coalescer" |
| |
| # add the different TLB levels to the system |
| # Modify here if you want to make the TLB hierarchy a child of |
| # the shader. |
| exec("system.%s = TLB_array" % system_TLB_name) |
| exec("system.%s = Coalescer_array" % system_Coalescer_name) |
| |
| # =========================================================== |
| # Specify the TLB hierarchy (i.e., port connections) |
| # All TLBs but the last level TLB need to have a memSidePort |
| # =========================================================== |
| |
| # Each TLB is connected with its Coalescer through a single port. |
| # There is a one-to-one mapping of TLBs to Coalescers at a given level |
| # This won't be modified no matter what the hierarchy looks like. |
| for i in range(len(TLB_hierarchy)): |
| hierarchy_level = TLB_hierarchy[i] |
| level = i + 1 |
| for TLB_type in hierarchy_level: |
| name = TLB_type["name"] |
| for index in range(TLB_type["width"]): |
| exec( |
| "system.%s_coalescer[%d].mem_side_ports[0] = \ |
| system.%s_tlb[%d].cpu_side_ports[0]" |
| % (name, index, name, index) |
| ) |
| |
| # Connect the cpuSidePort of all the coalescers in level 1 |
| # < Modify here if you want a different configuration > |
| for TLB_type in L1: |
| name = TLB_type["name"] |
| num_TLBs = TLB_type["width"] |
| if name == "l1": # L1 D-TLBs |
| tlb_per_cu = num_TLBs // n_cu |
| for cu_idx in range(n_cu): |
| if tlb_per_cu: |
| for tlb in range(tlb_per_cu): |
| exec( |
| "system.cpu[%d].CUs[%d].translation_port[%d] = \ |
| system.l1_coalescer[%d].cpu_side_ports[%d]" |
| % ( |
| shader_idx, |
| cu_idx, |
| tlb, |
| cu_idx * tlb_per_cu + tlb, |
| 0, |
| ) |
| ) |
| else: |
| exec( |
| "system.cpu[%d].CUs[%d].translation_port[%d] = \ |
| system.l1_coalescer[%d].cpu_side_ports[%d]" |
| % ( |
| shader_idx, |
| cu_idx, |
| tlb_per_cu, |
| cu_idx / (n_cu / num_TLBs), |
| cu_idx % (n_cu / num_TLBs), |
| ) |
| ) |
| elif name == "sqc": # I-TLB |
| for index in range(n_cu): |
| sqc_tlb_index = index / options.cu_per_sqc |
| sqc_tlb_port_id = index % options.cu_per_sqc |
| exec( |
| "system.cpu[%d].CUs[%d].sqc_tlb_port = \ |
| system.sqc_coalescer[%d].cpu_side_ports[%d]" |
| % (shader_idx, index, sqc_tlb_index, sqc_tlb_port_id) |
| ) |
| elif name == "scalar": # Scalar D-TLB |
| for index in range(n_cu): |
| scalar_tlb_index = index / options.cu_per_scalar_cache |
| scalar_tlb_port_id = index % options.cu_per_scalar_cache |
| exec( |
| "system.cpu[%d].CUs[%d].scalar_tlb_port = \ |
| system.scalar_coalescer[%d].cpu_side_ports[%d]" |
| % (shader_idx, index, scalar_tlb_index, scalar_tlb_port_id) |
| ) |
| |
| # Connect the memSidePorts of all the TLBs with the |
| # cpuSidePorts of the Coalescers of the next level |
| # < Modify here if you want a different configuration > |
| # L1 <-> L2 |
| l2_coalescer_index = 0 |
| for TLB_type in L1: |
| name = TLB_type["name"] |
| for index in range(TLB_type["width"]): |
| exec( |
| "system.%s_tlb[%d].mem_side_ports[0] = \ |
| system.l2_coalescer[0].cpu_side_ports[%d]" |
| % (name, index, l2_coalescer_index) |
| ) |
| l2_coalescer_index += 1 |
| |
| # L2 <-> L3 |
| system.l2_tlb[0].mem_side_ports[0] = system.l3_coalescer[0].cpu_side_ports[ |
| 0 |
| ] |
| |
| # L3 TLB Vega page table walker to memory for full system only |
| if full_system: |
| for TLB_type in L3: |
| name = TLB_type["name"] |
| for index in range(TLB_type["width"]): |
| exec( |
| "system._dma_ports.append(system.%s_tlb[%d].walker)" |
| % (name, index) |
| ) |
| |
| return system |
