Changeset 817


Ignore:
Timestamp:
Sep 29, 2014, 12:30:18 PM (8 years ago)
Author:
alain
Message:

Using both BPP (Big Physical Pages) and SPP (Small Physical Pages)
for Boot an kernel mapping on tsar_generic_iob platform.

Location:
trunk/platforms/tsar_generic_iob
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/platforms/tsar_generic_iob/arch.py

    r802 r817  
    1 #!/usr/bin/env python
    21
    32from math import log, ceil
     
    2019#  - y_size         : number of clusters in a column
    2120#  - nb_procs       : number of processors per cluster
     21#  - fbf_width      : frame_buffer width = frame_buffer heigth
    2222#
    2323#  The "hidden" parameters (defined below) are:
    2424#  - nb_ttys        : number of TTY channels
    2525#  - nb_nics        : number of NIC channels
    26 #  - fbf_width      : frame_buffer width = frame_buffer heigth
    2726#  - x_io           : cluster_io x coordinate
    2827#  - y_io           : cluster_io y coordinate
     
    3231#  - irq_per_proc   : number of input IRQs per processor
    3332#  - use_ramdisk    : use a ramdisk when True
    34 #  - peri_increment : address increment for replicated peripherals
    35 ####################################################################################
     33#  - vseg_increment : address increment for replicated peripherals
     34#
     35# Regarding physical memory allocation, there is one allocator per cluster:
     36# - We use only one big physical page (2 Mbytes) for the four boot vsegs,
     37#   allocated in cluster[0,0], identity mapping.
     38# - We use one big page per cluster for the kernel vsegs.
     39#   The kernel_code, kernel_init and kernel_ptab can be replicated in all clusters.
     40#   The kernel_data and kernel_uncdata shared vsegs are only mapped in cluster[0,0].
     41# - We use 8 small physical pages (4 Kbytes) per cluster for the schedulers.
     42# - We use one big page for each external peripheral in IO cluster,
     43# - We use one small page per cluster for each internal peripheral.
     44###################################################################################
    3645
    3746########################
    3847def arch( x_size    = 2,
    3948          y_size    = 2,
    40           nb_procs  = 2 ):
     49          nb_procs  = 2,
     50          fbf_width = 128 ):
    4151
    4252    ### define architecture constants
    4353
    44     nb_ttys           = 1
    45     nb_nics           = 2
    46     fbf_width         = 128
    47     x_io              = 0
    48     y_io              = 0
    49     x_width           = 4
    50     y_width           = 4
    51     p_width           = int(ceil(log(nb_procs, 2)))
    52     paddr_width       = 40
    53     irq_per_proc      = 4
    54     use_ramdisk       = False
    55     peri_increment    = 0x10000
    56     distributed_ptabs = True
     54    nb_ttys         = 1
     55    nb_nics         = 2
     56    x_io            = 0
     57    y_io            = 0
     58    x_width         = 4
     59    y_width         = 4
     60    p_width         = 4
     61    paddr_width     = 40
     62    irq_per_proc    = 4
     63    use_ramdisk     = False
     64    peri_increment  = 0x10000    # distributed peripherals vbase address increment
     65    sched_increment = 0x10000    # distributed schedulers vbase address increment
     66    ptab_increment  = 0x200000   # distributed page tables vbase address increment
    5767
    5868    ### parameters checking
     
    7181            ((x_io == x_size-1) and (y_io == y_size-1)) )
    7282
    73     platform_name  = 'tsar_iob_%d_%d_%d' % ( x_size, y_size, nb_procs )
    74 
    75     ### define physical segments
     83    platform_name  = 'tsar_iob_%d_%d_%d_%d' % ( x_size, y_size, nb_procs, fbf_width )
     84
     85    ### define replicated physical segments
     86    ### These segments are replicated in all clusters
    7687
    7788    ram_base = 0x0000000000
     
    8293
    8394    dma_base = 0x00B1000000
    84     dma_size = 0x1000 * nb_procs           # 4 Kbytes * nb_procs
     95    dma_size = 0x1000                      # 4 Kbytes
    8596
    8697    mmc_base = 0x00B2000000
    8798    mmc_size = 0x1000                      # 4 Kbytes
    8899
     100    ### define physical segments for external peripherals
     101    ## These segments are only defined in cluster_io
     102
    89103    offset_io = ((x_io << y_width) + y_io) << (paddr_width - x_width - y_width)
    90104
     
    108122
    109123    iob_base  = 0x00BE000000 + offset_io
    110     iob_size  = 0x1000                     # 4kbytes
     124    iob_size  = 0x1000                     # 4 bytes
    111125
    112126    rom_base  = 0x00BFC00000 + offset_io
     
    114128
    115129    ### define  bootloader vsegs base addresses and sizes
     130    ### We want to pack these 4 vsegs in the same big page
     131    ### => boot cost is one BPP in cluster[0][0]
    116132
    117133    boot_mapping_vbase   = 0x00000000      # ident
     
    128144
    129145    ### define kernel vsegs base addresses and sizes
     146    ### code, init, ptab & sched vsegs are replicated in all clusters.
     147    ### data & uncdata vsegs are only mapped in cluster[0][0].
     148    ### - We pack code, init, data vsegs in the same BIG page.
     149    ### - We use another BIG page for the ptab vseg.
     150    ### - We use 2*nb_procs SMALL pages for the sched vseg.
     151    ### - we use one SMALL page for uncdata
     152    ### => kernel cost is 2 BPPs and (2*n + 1) SPPs per cluster.
    130153
    131154    kernel_code_vbase    = 0x80000000
    132     kernel_code_size     = 0x00020000      # 128 Kbytes
    133 
    134     kernel_data_vbase    = 0x80020000
    135     kernel_data_size     = 0x00020000      # 128 Kbytes
    136 
    137     kernel_uncdata_vbase = 0x80040000
    138     kernel_uncdata_size  = 0x00010000      # 64 Kbytes
    139 
    140     kernel_init_vbase    = 0x80050000
    141     kernel_init_size     = 0x00010000      # 64 Kbytes
    142 
    143     kernel_sched_vbase   = 0xF0000000            # distributed in all clusters
    144     kernel_sched_size    = 0x2000 * nb_procs     # 8 kbytes per processor
     155    kernel_code_size     = 0x00080000      # 512 Kbytes per cluster
     156
     157    kernel_init_vbase    = 0x80080000
     158    kernel_init_size     = 0x00080000      # 512 Kbytes per cluster
     159
     160    kernel_data_vbase    = 0x80100000
     161    kernel_data_size     = 0x00100000      # 1 Mbytes in cluster[0][0]
     162
     163    kernel_ptab_vbase    = 0xE0000000
     164    kernel_ptab_size     = 0x00200000      # 2 Mbytes per cluster
     165
     166    kernel_uncdata_vbase = 0x90000000
     167    kernel_uncdata_size  = 0x00001000      # 4 Kbytes
     168
     169    kernel_sched_vbase   = 0xA0000000   
     170    kernel_sched_size    = 0x00002000*nb_procs  # 8 Kbytes per proc per cluster
    145171
    146172    ### create mapping
    147173
    148     mapping = Mapping( name           = platform_name,
    149                        x_size         = x_size,
    150                        y_size         = y_size,
    151                        procs_max      = nb_procs,
    152                        x_width        = x_width,
    153                        y_width        = y_width,
     174    mapping = Mapping( name           = platform_name, 
     175                       x_size         = x_size,       
     176                       y_size         = y_size,       
     177                       nprocs         = nb_procs,     
     178                       x_width        = x_width,       
     179                       y_width        = y_width,       
    154180                       p_width        = p_width,
    155                        paddr_width    = paddr_width,
    156                        coherence      = True,
    157                        irq_per_proc   = irq_per_proc,
    158                        use_ramdisk    = use_ramdisk,
    159                        x_io           = x_io,
     181                       paddr_width    = paddr_width,   
     182                       coherence      = True,         
     183                       irq_per_proc   = irq_per_proc, 
     184                       use_ramdisk    = use_ramdisk, 
     185                       x_io           = x_io,         
    160186                       y_io           = y_io,
    161187                       peri_increment = peri_increment,
     
    226252                mapping.addProc( x, y, p )
    227253
    228     ### global vsegs for boot_loader / identity mapping
     254    ### global vsegs for boot_loader
     255    ### we want to pack those 4 vsegs in the same big page
     256    ### => same flags CXW_ / identity mapping / non local / big page
    229257
    230258    mapping.addGlobal( 'seg_boot_mapping', boot_mapping_vbase, boot_mapping_size,
    231                        'C_W_', vtype = 'BLOB'  , x = 0, y = 0, pseg = 'RAM',
    232                        identity = True )
     259                       'CXW_', vtype = 'BLOB'  , x = 0, y = 0, pseg = 'RAM',
     260                       identity = True , local = False, big = True )
    233261
    234262    mapping.addGlobal( 'seg_boot_code', boot_code_vbase, boot_code_size,
    235263                       'CXW_', vtype = 'BUFFER', x = 0, y = 0, pseg = 'RAM',
    236                        identity = True )
     264                       identity = True , local = False, big = True )
    237265
    238266    mapping.addGlobal( 'seg_boot_data', boot_data_vbase, boot_data_size,
    239                        'C_W_', vtype = 'BUFFER', x = 0, y = 0, pseg = 'RAM',
    240                        identity = True )
     267                       'CXW_', vtype = 'BUFFER', x = 0, y = 0, pseg = 'RAM',
     268                       identity = True , local = False, big = True )
    241269
    242270    mapping.addGlobal( 'seg_boot_stack', boot_stack_vbase, boot_stack_size,
    243                        'C_W_', vtype = 'BUFFER', x = 0, y = 0, pseg = 'RAM',
    244                        identity = True )
    245 
    246     ### the code global vsegs for kernel can be replicated in all clusters
    247     ### if the page tables are distributed in all clusters.
    248 
    249     if distributed_ptabs:
    250         for x in xrange( x_size ):
    251             for y in xrange( y_size ):
    252                 cluster_xy = (x << y_width) + y;
    253 
    254                 mapping.addGlobal( 'seg_kernel_code', kernel_code_vbase, kernel_code_size,
    255                                    'CXW_', vtype = 'ELF', x = x , y = y , pseg = 'RAM',
    256                                    binpath = 'build/kernel/kernel.elf', local = True )
    257 
    258                 mapping.addGlobal( 'seg_kernel_init', kernel_init_vbase, kernel_init_size,
    259                                    'CXW_', vtype = 'ELF', x = x , y = y , pseg = 'RAM',
    260                                    binpath = 'build/kernel/kernel.elf', local = True )
    261     else:
    262         mapping.addGlobal( 'seg_kernel_code', kernel_code_vbase, kernel_code_size,
    263                            'CXW_', vtype = 'ELF', x = 0 , y = 0 , pseg = 'RAM',
    264                             binpath = 'build/kernel/kernel.elf', local = False )
    265 
    266         mapping.addGlobal( 'seg_kernel_init', kernel_init_vbase, kernel_init_size,
    267                            'CXW_', vtype = 'ELF', x = 0 , y = 0 , pseg = 'RAM',
    268                            binpath = 'build/kernel/kernel.elf', local = False )
    269 
    270     ### shared global vsegs for kernel
    271 
    272     mapping.addGlobal( 'seg_kernel_data', kernel_data_vbase, kernel_data_size,
    273                        'C_W_', vtype = 'ELF', x = 0, y = 0, pseg = 'RAM',
    274                        binpath = 'build/kernel/kernel.elf', local = False )
    275 
     271                       'CXW_', vtype = 'BUFFER', x = 0, y = 0, pseg = 'RAM',
     272                       identity = True , local = False, big = True )
     273
     274    ### global vsegs kernel_code, kernel_init : local / big page
     275    ### replicated in all clusters with the same name (same vbase)
     276    for x in xrange( x_size ):
     277        for y in xrange( y_size ):
     278            mapping.addGlobal( 'seg_kernel_code', kernel_code_vbase, kernel_code_size,
     279                               'CXW_', vtype = 'ELF', x = x , y = y , pseg = 'RAM',
     280                               binpath = 'build/kernel/kernel.elf',
     281                               local = True, big = True )
     282
     283            mapping.addGlobal( 'seg_kernel_init', kernel_init_vbase, kernel_init_size,
     284                               'CXW_', vtype = 'ELF', x = x , y = y , pseg = 'RAM',
     285                               binpath = 'build/kernel/kernel.elf',
     286                               local = True, big = True )
     287
     288    ### global vseg kernel_data: non local / big page
     289    ### Only mapped in cluster[0][0]
     290    mapping.addGlobal( 'seg_kernel_data', kernel_data_vbase, kernel_data_size,
     291                       'CXW_', vtype = 'ELF', x = 0, y = 0, pseg = 'RAM',
     292                       binpath = 'build/kernel/kernel.elf',
     293                       local = False, big = True )
     294
     295    ### global vseg kernel_uncdata: non local / small page
     296    ### Only mapped in cluster[0][0]
    276297    mapping.addGlobal( 'seg_kernel_uncdata', kernel_uncdata_vbase, kernel_uncdata_size,
    277                        '__W_', vtype = 'ELF', x = 0, y = 0, pseg = 'RAM',
    278                        binpath = 'build/kernel/kernel.elf', local = False )
    279 
    280     ### global vsegs for external peripherals / identity mapping
    281 
     298                       '__W_', vtype = 'ELF', x = 0, y = 0, pseg = 'RAM',
     299                       binpath = 'build/kernel/kernel.elf',
     300                       local = False, big = False )
     301
     302    ### Global vsegs kernel_ptab_x_y: non local / big pages
     303    ### replicated in all clusters with name indexed by (x,y)
     304    ### as vbase address is incremented by (cluster_xy * vseg_increment)
     305    for x in xrange( x_size ):
     306        for y in xrange( y_size ):
     307            offset = ((x << y_width) + y) * ptab_increment
     308            mapping.addGlobal( 'seg_kernel_ptab_%d_%d' %(x,y), kernel_ptab_vbase + offset , kernel_ptab_size,
     309                               'CXW_', vtype = 'PTAB', x = x, y = y, pseg = 'RAM',
     310                               local = False , big = True )
     311
     312    ### global vsegs kernel_sched : non local / small pages
     313    ### allocated in all clusters with name indexed by (x,y)
     314    ### as vbase address is incremented by (cluster_xy * vseg_increment)
     315    for x in xrange( x_size ):
     316        for y in xrange( y_size ):
     317            offset = ((x << y_width) + y) * sched_increment
     318            mapping.addGlobal( 'seg_kernel_sched_%d_%d' %(x,y), kernel_sched_vbase + offset , kernel_sched_size,
     319                               'C_W_', vtype = 'SCHED', x = x , y = y , pseg = 'RAM',
     320                               local = False, big = False )
     321
     322    ### global vsegs for external peripherals : non local / big page
    282323    mapping.addGlobal( 'seg_iob', iob_base, iob_size, '__W_',
    283324                       vtype = 'PERI', x = 0, y = 0, pseg = 'IOB',
    284                        identity = True )
     325                       local = False, big = True )
    285326
    286327    mapping.addGlobal( 'seg_bdv', bdv_base, bdv_size, '__W_',
    287328                       vtype = 'PERI', x = 0, y = 0, pseg = 'BDV',
    288                        identity = True )
     329                       local = False, big = True )
    289330
    290331    mapping.addGlobal( 'seg_tty', tty_base, tty_size, '__W_',
    291332                       vtype = 'PERI', x = 0, y = 0, pseg = 'TTY',
    292                        identity = True )
     333                       local = False, big = True )
    293334
    294335    mapping.addGlobal( 'seg_nic', nic_base, nic_size, '__W_',
    295336                       vtype = 'PERI', x = 0, y = 0, pseg = 'NIC',
    296                        identity = True )
     337                       local = False, big = True )
    297338
    298339    mapping.addGlobal( 'seg_cma', cma_base, cma_size, '__W_',
    299340                       vtype = 'PERI', x = 0, y = 0, pseg = 'CMA',
    300                        identity = True )
     341                       local = False, big = True )
    301342
    302343    mapping.addGlobal( 'seg_fbf', fbf_base, fbf_size, '__W_',
    303344                       vtype = 'PERI', x = 0, y = 0, pseg = 'FBF',
    304                        identity = True )
     345                       local = False, big = True )
    305346
    306347    mapping.addGlobal( 'seg_pic', pic_base, pic_size, '__W_',
    307348                       vtype = 'PERI', x = 0, y = 0, pseg = 'PIC',
    308                        identity = True )
     349                       local = False, big = True )
    309350
    310351    mapping.addGlobal( 'seg_rom', rom_base, rom_size, 'CXW_',
    311352                       vtype = 'PERI', x = 0, y = 0, pseg = 'ROM',
    312                        identity = True )
    313 
    314     ### global vsegs for internal peripherals, and for schedulers
    315     ### name is indexed by (x,y) / vbase address is incremented by (cluster_xy * peri_increment)
    316 
     353                       local = False, big = True )
     354
     355    ### global vsegs for internal peripherals : non local / small pages   
     356    ### allocated in all clusters with name indexed by (x,y)
     357    ### as vbase address is incremented by (cluster_xy * vseg_increment)
    317358    for x in xrange( x_size ):
    318359        for y in xrange( y_size ):
    319             cluster_xy = (x << y_width) + y;
    320             offset     = cluster_xy * peri_increment
     360            offset = ((x << y_width) + y) * peri_increment
    321361
    322362            mapping.addGlobal( 'seg_xcu_%d_%d' %(x,y), xcu_base + offset, xcu_size,
    323                                '__W_', vtype = 'PERI' , x = x , y = y , pseg = 'XCU' )
     363                               '__W_', vtype = 'PERI' , x = x , y = y , pseg = 'XCU',
     364                               local = False, big = False )
    324365
    325366            mapping.addGlobal( 'seg_dma_%d_%d' %(x,y), dma_base + offset, dma_size,
    326                                '__W_', vtype = 'PERI' , x = x , y = y , pseg = 'DMA' )
     367                               '__W_', vtype = 'PERI' , x = x , y = y , pseg = 'DMA',
     368                               local = False, big = False )
    327369
    328370            mapping.addGlobal( 'seg_mmc_%d_%d' %(x,y), mmc_base + offset, mmc_size,
    329                                '__W_', vtype = 'PERI' , x = x , y = y , pseg = 'MMC' )
    330 
    331             mapping.addGlobal( 'seg_sched_%d_%d' %(x,y), kernel_sched_vbase + offset, kernel_sched_size,
    332                                'C_W_', vtype = 'SCHED', x = x , y = y , pseg = 'RAM' )
     371                               '__W_', vtype = 'PERI' , x = x , y = y , pseg = 'MMC',
     372                               local = False, big = False )
    333373
    334374    ### return mapping ###
  • trunk/platforms/tsar_generic_iob/top.cpp

    r802 r817  
    14181418            uint64_t ms2 = (uint64_t) t2.tv_sec  * 1000ULL +
    14191419                           (uint64_t) t2.tv_usec / 1000;
    1420             std::cerr << "### cycle = " << n
     1420            std::cerr << "### cycle = " << std::dec << n
    14211421                      << " / frequency = "
    14221422                      << (double) 1000000 / (double) (ms2 - ms1) << "Khz"
     
    14271427
    14281428        // Monitor a specific address for one L1 cache
    1429         // clusters[1][1]->proc[0]->cache_monitor(0x50090ULL);
     1429        // clusters[0][0]->proc[0]->cache_monitor(0xC0180ULL);
    14301430
    14311431        // Monitor a specific address for one L2 cache
    1432         // clusters[0][0]->memc->cache_monitor( 0x1c4924LL, true );   // single word
     1432        // clusters[0][0]->memc->cache_monitor( 0xC0100ULL, true );   // single word
    14331433
    14341434        // Monitor a specific address for one XRAM
    1435         // clusters[0][0]->xram->start_monitor( 0xE1900ULL , 64);
     1435        // clusters[0][0]->xram->start_monitor( 0xC0100ULL , 4);
    14361436
    14371437        if ( debug_ok and (n > debug_from) )
Note: See TracChangeset for help on using the changeset viewer.