source: branches/reconfiguration/platforms/tsar_generic_iob/scripts/arch.py @ 841

Last change on this file since 841 was 831, checked in by cfuguet, 10 years ago

reconf/tsar_generic_iob: updating the arch.py file

  • Adding support for new GietVm? version
  • GietVm? mapping structure moved to 0x1000 instead of 0x0 because new GCC versions assumes that no data can be referenced in this address. The consequence is that GCC is optimizing out code with references to 0 (which in the C standard is the NULL pointer).
  • Property svn:executable set to *
File size: 14.8 KB
RevLine 
[747]1#!/usr/bin/env python
[831]2"""This file contains a mapping generator for the tsar_generic_iob platform"""
3
[806]4from math import log
[831]5from mapping import Mapping
[747]6
[831]7################################################################################
[747]8#   file   : arch.py  (for the tsar_generic_iob architecture)
9#   date   : may 2014
10#   author : Alain Greiner
11#
[831]12#   modified by:
13#       Cesar Fuguet
14#           - Adding distributed ROMs used by the distributed reconfiguration
15#             procedure
16#
17################################################################################
18#  This platform includes 6 external peripherals, accessible through two
19#  IO_Bridge components located in cluster [0,0] and cluster [x_size-1,
20#  y_size-1]. Available peripherals are: TTY, BDV, FBF, ROM, NIC, CMA.
21#
[747]22#  The "constructor" parameters are:
23#  - x_size         : number of clusters in a row
24#  - y_size         : number of clusters in a column
25#  - nb_procs       : number of processors per cluster
[831]26#  - fbf_width      : frame_buffer width = frame_buffer heigth
[747]27#
[766]28#  The "hidden" parameters (defined below) are:
[831]29#  - NB_TTYS        : number of TTY channels
30#  - NB_NICS        : number of NIC channels
31#  - X_IO           : cluster_io x coordinate
32#  - Y_IO           : cluster_io y coordinate
33#  - X_WIDTH        : number of bits for x coordinate
34#  - Y_WIDTH        : number of bits for y coordinate
[806]35#  - p_width        : number of bits for processor local id field
[831]36#  - PADDR_WIDTH    : number of bits for physical address
37#  - IRQ_PER_PROC   : number of input IRQs per processor
38#  - USE_RAMDISK    : use a ramdisk when True
39#  - PERI_INCREMENT : virtual address increment for replicated peripherals
40#  - PTAB_INCREMENT : virtual address increment for replicated page tables
41#  - SCHED_INCREMENT: virtual address increment for replicated schedulers
42################################################################################
[747]43
[831]44# define architecture constants
45PADDR_WIDTH = 40
46NB_TTYS = 1
47NB_NICS = 2
48FBF_WIDTH = 128
49X_WIDTH = 4
50Y_WIDTH = 4
51X_IO = 0
52Y_IO = 0
53IRQ_PER_PROC = 4
54USE_RAMDISK = False
[747]55
[831]56# virtual address increment for distributed memory segments in the GietVM OS
57PERI_INCREMENT = 0x10000
58PTAB_INCREMENT = 0x200000
59SCHED_INCREMENT = 0x10000
[747]60
[831]61def pmsb(x, y):
62    """This function returns the physical most signicant bits for the
63    cluster(x,y)"""
[748]64
[831]65    return (x << X_WIDTH) | y
[747]66
[831]67def arch(x_size=2,
68         y_size=2,
69         nb_procs=4,
70         fbf_width=FBF_WIDTH):
71    """This function describes the tsar_generic_iob platform and defines its
72    parameters"""
[747]73
[831]74    p_width = log(nb_procs, 2)
[747]75
[831]76    # parameters checking
77    assert nb_procs <= 4
[747]78
[831]79    assert ((x_size == 1) or (x_size == 2) or (x_size == 4) or (x_size == 8) or
80            (x_size == 16))
[747]81
[831]82    assert ((y_size == 1) or (y_size == 2) or (y_size == 4) or (y_size == 8) or
83            (y_size == 16))
[747]84
[831]85    assert NB_TTYS == 1
[748]86
[831]87    assert (((X_IO == 0) and (Y_IO == 0)) or
88            ((X_IO == x_size-1) and (Y_IO == y_size-1)))
[747]89
[831]90    platform_name = 'reconf-tsar_iob_%d_%d_%d' % (x_size, y_size, nb_procs)
[747]91
[831]92    # define physical segments
93    ram_base = 0x0000000000
94    if 1:
95        ram_size = 0x4000000              # 64 Mbytes
96    else:
97        ram_size = 0x0040000              # 256 Kbytes
[747]98
[831]99    xcu_base = 0x00B0000000
100    xcu_size = 0x1000                     # 4 Kbytes
[747]101
[831]102    dma_base = 0x00B1000000
103    dma_size = 0x1000 * nb_procs          # 4 Kbytes * nb_procs
[747]104
[831]105    mmc_base = 0x00B2000000
106    mmc_size = 0x1000                     # 4 Kbytes
[748]107
[831]108    rom_base = 0x00BFC00000
109    rom_size = 0x8000                     # 32 Kbytes
[747]110
[831]111    offset_io = pmsb(X_IO, Y_IO) << (PADDR_WIDTH - X_WIDTH - Y_WIDTH)
[747]112
[831]113    bdv_base = 0x00B3000000 + offset_io
114    bdv_size = 0x1000                     # 4 kbytes
[747]115
[831]116    tty_base = 0x00B4000000 + offset_io
117    tty_size = 0x1000                     # 4 Kbytes
[747]118
[831]119    nic_base = 0x00B5000000 + offset_io
120    nic_size = 0x80000                    # 512 kbytes
[747]121
[831]122    cma_base = 0x00B6000000 + offset_io
123    cma_size = 0x1000 * 2 * NB_NICS       # 4 kbytes * 2 * NB_NICS
[747]124
[831]125    fbf_base = 0x00B7000000 + offset_io
126    fbf_size = fbf_width * fbf_width      # fbf_width * fbf_width bytes
[747]127
[831]128    pic_base = 0x00B8000000 + offset_io
129    pic_size = 0x1000                     # 4 Kbytes
[769]130
[831]131    sim_base = 0x00B9000000 + offset_io
132    sim_size = 0x1000                     # 4 kbytes
[747]133
[831]134    iob_base = 0x00BE000000 + offset_io
135    iob_size = 0x1000                     # 4 kbytes
[747]136
[831]137    # create mapping
138    mapping = Mapping(name=platform_name,
139                      x_size=x_size,
140                      y_size=y_size,
141                      nprocs=nb_procs,
142                      x_width=X_WIDTH,
143                      y_width=Y_WIDTH,
144                      p_width=p_width,
145                      paddr_width=PADDR_WIDTH,
146                      coherence=True,
147                      irq_per_proc=IRQ_PER_PROC,
148                      use_ramdisk=USE_RAMDISK,
149                      x_io=X_IO,
150                      y_io=Y_IO,
151                      peri_increment=PERI_INCREMENT,
152                      ram_base=ram_base,
153                      ram_size=ram_size)
[747]154
[831]155    # external peripherals (accessible in cluster[0,0] only for this mapping)
156    mapping.addPeriph('IOB', base=iob_base, size=iob_size,
157                      ptype='IOB')
[748]158
[831]159    mapping.addPeriph('BDV', base=bdv_base, size=bdv_size,
160                      ptype='IOC', subtype='BDV')
[747]161
[831]162    mapping.addPeriph('TTY', base=tty_base, size=tty_size,
163                      ptype='TTY', channels=NB_TTYS)
[747]164
[831]165    mapping.addPeriph('NIC', base=nic_base, size=nic_size,
166                      ptype='NIC', channels=NB_NICS)
[747]167
[831]168    mapping.addPeriph('CMA', base=cma_base, size=cma_size,
169                      ptype='CMA', channels=2*NB_NICS)
[747]170
[831]171    mapping.addPeriph('FBF', base=fbf_base, size=fbf_size,
172                      ptype='FBF', arg=fbf_width)
[747]173
[831]174    mapping.addPeriph('SIM', base=sim_base, size=sim_size,
175                      ptype='SIM')
[747]176
[831]177    pic = mapping.addPeriph('PIC', base=pic_base, size=pic_size,
178                            ptype='PIC', channels=32)
[747]179
[831]180    mapping.addIrq(pic, index=0, isrtype='ISR_NIC_RX', channel=0)
181    mapping.addIrq(pic, index=1, isrtype='ISR_NIC_RX', channel=1)
182    mapping.addIrq(pic, index=2, isrtype='ISR_NIC_TX', channel=0)
183    mapping.addIrq(pic, index=3, isrtype='ISR_NIC_TX', channel=1)
184    mapping.addIrq(pic, index=4, isrtype='ISR_CMA', channel=0)
185    mapping.addIrq(pic, index=5, isrtype='ISR_CMA', channel=1)
186    mapping.addIrq(pic, index=6, isrtype='ISR_CMA', channel=2)
187    mapping.addIrq(pic, index=7, isrtype='ISR_CMA', channel=3)
188    mapping.addIrq(pic, index=8, isrtype='ISR_BDV', channel=0)
189    mapping.addIrq(pic, index=9, isrtype='ISR_TTY_RX', channel=0)
[747]190
[831]191    # hardware components replicated in all clusters
192    for x in xrange(x_size):
193        for y in xrange(y_size):
194            offset = pmsb(x, y) << (PADDR_WIDTH - X_WIDTH - Y_WIDTH)
[747]195
[831]196            mapping.addRam('RAM', base=ram_base + offset, size=ram_size)
[747]197
[831]198            mapping.addPeriph('MMC', base=mmc_base + offset, size=mmc_size,
199                              ptype='MMC')
[747]200
[831]201            mapping.addPeriph('ROM', base=rom_base + offset, size=rom_size,
202                              ptype='ROM')
[747]203
[831]204            dma = mapping.addPeriph('DMA', base=dma_base + offset,
205                                    size=dma_size, ptype='DMA',
206                                    channels=nb_procs)
[747]207
[831]208            xcu = mapping.addPeriph('XCU', base=xcu_base + offset,
209                                    size=xcu_size, ptype='XCU',
210                                    channels=nb_procs * IRQ_PER_PROC,
211                                    arg=16)
[747]212
[831]213            # MMC IRQ replicated in all clusters
214            mapping.addIrq(xcu, index=0, isrtype='ISR_MMC')
[747]215
[831]216            # DMA IRQ replicated in all clusters
217            for i in xrange(dma.channels):
218                mapping.addIrq(xcu, index=1+i, isrtype='ISR_DMA',
219                               channel=i)
[747]220
[831]221            # processors
222            for p in xrange(nb_procs):
223                mapping.addProc(x, y, p)
[747]224
[831]225    ############################################################################
226    # GIET_VM specifics
[747]227
[831]228    # define bootloader vsegs base addresses
229    bmapping_vbase = 0x00001000           # ident
230    bmapping_size = 0x0007F000            # 508 Kbytes
[769]231
[831]232    bcode_vbase = 0x00080000              # ident
233    bcode_size = 0x00040000               # 256 Kbytes
[747]234
[831]235    bdata_vbase = 0x000C0000              # ident
236    bdata_size = 0x00080000               # 512 Kbytes
[747]237
[831]238    bstack_vbase = 0x00140000             # ident
239    bstack_size = 0x00050000              # 320 Kbytes
[747]240
[831]241    # define kernel vsegs base addresses and sizes
242    kcode_vbase = 0x80000000
243    kcode_size = 0x00080000               # 512 Kbytes
[747]244
[831]245    kinit_vbase = 0x80800000
246    kinit_size = 0x00080000               # 512 Kbytes
[747]247
[831]248    kdata_vbase = 0x80100000
249    kdata_size = 0x00080000               # 512 Kbytes
[747]250
[831]251    kuncdata_vbase = 0x80180000
252    kuncdata_size = 0x00001000            # 4 Kbytes
[747]253
[831]254    kptab_vbase = 0xC0000000
255    kptab_size = 0x00200000               # 512 Kbytes
[747]256
[831]257    ksched_vbase = 0xF0000000             # distributed in all clusters
258    ksched_size = 0x2000 * nb_procs       # 8 kbytes per processor
[747]259
[831]260    # global vsegs for boot_loader / identity mapping
261    mapping.addGlobal('seg_boot_mapping', bmapping_vbase, bmapping_size,
262                      'CXW_', vtype='BLOB', x=0, y=0, pseg='RAM',
263                      identity=True, local=False, big=True)
[747]264
[831]265    mapping.addGlobal('seg_boot_code', bcode_vbase, bcode_size,
266                      'CXW_', vtype='BUFFER', x=0, y=0, pseg='RAM',
267                      identity=True, local=False, big=True)
[747]268
[831]269    mapping.addGlobal('seg_boot_data', bdata_vbase, bdata_size,
270                      'CXW_', vtype='BUFFER', x=0, y=0, pseg='RAM',
271                      identity=True, local=False, big=True)
[748]272
[831]273    mapping.addGlobal('seg_boot_stack', bstack_vbase, bstack_size,
274                      'CXW_', vtype='BUFFER', x=0, y=0, pseg='RAM',
275                      identity=True, local=False, big=True)
[747]276
[831]277    # the code global vsegs for kernel can be replicated in all clusters
278    # if the page tables are distributed in all clusters.
279    for x in xrange(x_size):
280        for y in xrange(y_size):
281            mapping.addGlobal('seg_kernel_code', kcode_vbase, kcode_size,
282                              'CXW_', vtype='ELF', x=x, y=y, pseg='RAM',
283                              binpath='build/kernel/kernel.elf',
284                              local=True, big=True)
[770]285
[831]286            mapping.addGlobal('seg_kernel_init', kinit_vbase, kinit_size,
287                              'CXW_', vtype='ELF', x=x, y=y, pseg='RAM',
288                              binpath='build/kernel/kernel.elf',
289                              local=True, big=True)
[747]290
[831]291            offset = pmsb(x, y) * PTAB_INCREMENT
292            mapping.addGlobal('seg_kernel_ptab_%d_%d' % (x, y),
293                              kptab_vbase + offset, kptab_size, 'C_W_',
294                              vtype='PTAB', x=x, y=y, pseg='RAM',
295                              local=False, big=True)
[747]296
297
[831]298            offset = pmsb(x, y) * SCHED_INCREMENT
299            mapping.addGlobal('seg_kernel_sched_%d_%d' % (x, y),
300                              ksched_vbase + offset, ksched_size, 'C_W_',
301                              vtype='SCHED', x=x, y=y, pseg='RAM',
302                              local=False, big=False)
[747]303
[831]304    # shared global vsegs for kernel
305    mapping.addGlobal('seg_kernel_data', kdata_vbase, kdata_size,
306                      'CXW_', vtype='ELF', x=0, y=0, pseg='RAM',
307                      binpath='build/kernel/kernel.elf', local=False,
308                      big=True)
[747]309
[831]310    mapping.addGlobal('seg_kernel_uncdata', kuncdata_vbase, kuncdata_size,
311                      'CXW_', vtype='ELF', x=0, y=0, pseg='RAM',
312                      binpath='build/kernel/kernel.elf', local=False,
313                      big=True)
[747]314
[831]315    # global vsegs for external peripherals / identity mapping
316    mapping.addGlobal('seg_iob', iob_base, iob_size, '__W_', vtype='PERI',
317                      x=X_IO, y=Y_IO, pseg='IOB', local=False, big=False)
[747]318
[831]319    mapping.addGlobal('seg_bdv', bdv_base, bdv_size, '__W_', vtype='PERI',
320                      x=X_IO, y=Y_IO, pseg='BDV', local=False, big=False)
[747]321
[831]322    mapping.addGlobal('seg_tty', tty_base, tty_size, '__W_', vtype='PERI',
323                      x=X_IO, y=Y_IO, pseg='TTY', local=False, big=False)
[747]324
[831]325    mapping.addGlobal('seg_nic', nic_base, nic_size, '__W_', vtype='PERI',
326                      x=X_IO, y=Y_IO, pseg='NIC', local=False, big=False)
[747]327
[831]328    mapping.addGlobal('seg_cma', cma_base, cma_size, '__W_', vtype='PERI',
329                      x=X_IO, y=Y_IO, pseg='CMA', local=False, big=False)
[747]330
[831]331    mapping.addGlobal('seg_fbf', fbf_base, fbf_size, '__W_', vtype='PERI',
332                      x=X_IO, y=Y_IO, pseg='FBF', local=False, big=True)
[747]333
[831]334    mapping.addGlobal('seg_pic', pic_base, pic_size, '__W_', vtype='PERI',
335                      x=X_IO, y=Y_IO, pseg='PIC', local=False, big=False)
[747]336
[831]337    mapping.addGlobal('seg_sim', sim_base, sim_size, '__W_', vtype='PERI',
338                      x=X_IO, y=Y_IO, pseg='SIM', local=False, big=False)
[766]339
[831]340    # global vsegs for internal peripherals
341    for x in xrange(x_size):
342        for y in xrange(y_size):
343            offset = pmsb(x, y) * PERI_INCREMENT
[747]344
[831]345            mapping.addGlobal('seg_rom_%d_%d' % (x, y), rom_base + offset,
346                              rom_size, 'CX__', vtype='PERI', x=x, y=y,
347                              pseg='ROM', local=False, big=False)
[747]348
[831]349            mapping.addGlobal('seg_xcu_%d_%d' % (x, y), xcu_base + offset,
350                              xcu_size, '__W_', vtype='PERI', x=x, y=y,
351                              pseg='XCU', local=False, big=False)
[747]352
[831]353            mapping.addGlobal('seg_dma_%d_%d' % (x, y), dma_base + offset,
354                              dma_size, '__W_', vtype='PERI', x=x, y=y,
355                              pseg='DMA', local=False, big=False)
[747]356
[831]357            mapping.addGlobal('seg_mmc_%d_%d' % (x, y), mmc_base + offset,
358                              mmc_size, '__W_', vtype='PERI', x=x, y=y,
359                              pseg='MMC', local=False, big=False)
[747]360
361    return mapping
362
[774]363def main(x, y, p, hard_path, xml_path):
[831]364    """main function: it generates the map.xml and the hard_config.h file based
365    on the Mapping object returned by arch()"""
366    mapping = arch(x_size=x,
367                   y_size=y,
368                   nb_procs=p)
[774]369
370    with open(xml_path, "w") as map_xml:
371        map_xml.write(mapping.xml())
372    with open(hard_path, "w") as hard_config:
373        hard_config.write(mapping.hard_config())
374
[831]375################################# platform test ################################
[806]376import sys
[747]377if __name__ == '__main__':
[831]378    main(x=int(sys.argv[1]),
379         y=int(sys.argv[2]),
380         p=int(sys.argv[3]),
381         hard_path="hard_config.test.h",
382         xml_path="map.test.xml")
[747]383
384# Local Variables:
385# tab-width: 4;
386# c-basic-offset: 4;
387# c-file-offsets:((innamespace . 0)(inline-open . 0));
388# indent-tabs-mode: nil;
389# End:
390#
391# vim: filetype=python:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
392
Note: See TracBrowser for help on using the repository browser.