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

Last change on this file since 853 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
Line 
1#!/usr/bin/env python
2"""This file contains a mapping generator for the tsar_generic_iob platform"""
3
4from math import log
5from mapping import Mapping
6
7################################################################################
8#   file   : arch.py  (for the tsar_generic_iob architecture)
9#   date   : may 2014
10#   author : Alain Greiner
11#
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#
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
26#  - fbf_width      : frame_buffer width = frame_buffer heigth
27#
28#  The "hidden" parameters (defined below) are:
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
35#  - p_width        : number of bits for processor local id field
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################################################################################
43
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
55
56# virtual address increment for distributed memory segments in the GietVM OS
57PERI_INCREMENT = 0x10000
58PTAB_INCREMENT = 0x200000
59SCHED_INCREMENT = 0x10000
60
61def pmsb(x, y):
62    """This function returns the physical most signicant bits for the
63    cluster(x,y)"""
64
65    return (x << X_WIDTH) | y
66
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"""
73
74    p_width = log(nb_procs, 2)
75
76    # parameters checking
77    assert nb_procs <= 4
78
79    assert ((x_size == 1) or (x_size == 2) or (x_size == 4) or (x_size == 8) or
80            (x_size == 16))
81
82    assert ((y_size == 1) or (y_size == 2) or (y_size == 4) or (y_size == 8) or
83            (y_size == 16))
84
85    assert NB_TTYS == 1
86
87    assert (((X_IO == 0) and (Y_IO == 0)) or
88            ((X_IO == x_size-1) and (Y_IO == y_size-1)))
89
90    platform_name = 'reconf-tsar_iob_%d_%d_%d' % (x_size, y_size, nb_procs)
91
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
98
99    xcu_base = 0x00B0000000
100    xcu_size = 0x1000                     # 4 Kbytes
101
102    dma_base = 0x00B1000000
103    dma_size = 0x1000 * nb_procs          # 4 Kbytes * nb_procs
104
105    mmc_base = 0x00B2000000
106    mmc_size = 0x1000                     # 4 Kbytes
107
108    rom_base = 0x00BFC00000
109    rom_size = 0x8000                     # 32 Kbytes
110
111    offset_io = pmsb(X_IO, Y_IO) << (PADDR_WIDTH - X_WIDTH - Y_WIDTH)
112
113    bdv_base = 0x00B3000000 + offset_io
114    bdv_size = 0x1000                     # 4 kbytes
115
116    tty_base = 0x00B4000000 + offset_io
117    tty_size = 0x1000                     # 4 Kbytes
118
119    nic_base = 0x00B5000000 + offset_io
120    nic_size = 0x80000                    # 512 kbytes
121
122    cma_base = 0x00B6000000 + offset_io
123    cma_size = 0x1000 * 2 * NB_NICS       # 4 kbytes * 2 * NB_NICS
124
125    fbf_base = 0x00B7000000 + offset_io
126    fbf_size = fbf_width * fbf_width      # fbf_width * fbf_width bytes
127
128    pic_base = 0x00B8000000 + offset_io
129    pic_size = 0x1000                     # 4 Kbytes
130
131    sim_base = 0x00B9000000 + offset_io
132    sim_size = 0x1000                     # 4 kbytes
133
134    iob_base = 0x00BE000000 + offset_io
135    iob_size = 0x1000                     # 4 kbytes
136
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)
154
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')
158
159    mapping.addPeriph('BDV', base=bdv_base, size=bdv_size,
160                      ptype='IOC', subtype='BDV')
161
162    mapping.addPeriph('TTY', base=tty_base, size=tty_size,
163                      ptype='TTY', channels=NB_TTYS)
164
165    mapping.addPeriph('NIC', base=nic_base, size=nic_size,
166                      ptype='NIC', channels=NB_NICS)
167
168    mapping.addPeriph('CMA', base=cma_base, size=cma_size,
169                      ptype='CMA', channels=2*NB_NICS)
170
171    mapping.addPeriph('FBF', base=fbf_base, size=fbf_size,
172                      ptype='FBF', arg=fbf_width)
173
174    mapping.addPeriph('SIM', base=sim_base, size=sim_size,
175                      ptype='SIM')
176
177    pic = mapping.addPeriph('PIC', base=pic_base, size=pic_size,
178                            ptype='PIC', channels=32)
179
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)
190
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)
195
196            mapping.addRam('RAM', base=ram_base + offset, size=ram_size)
197
198            mapping.addPeriph('MMC', base=mmc_base + offset, size=mmc_size,
199                              ptype='MMC')
200
201            mapping.addPeriph('ROM', base=rom_base + offset, size=rom_size,
202                              ptype='ROM')
203
204            dma = mapping.addPeriph('DMA', base=dma_base + offset,
205                                    size=dma_size, ptype='DMA',
206                                    channels=nb_procs)
207
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)
212
213            # MMC IRQ replicated in all clusters
214            mapping.addIrq(xcu, index=0, isrtype='ISR_MMC')
215
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)
220
221            # processors
222            for p in xrange(nb_procs):
223                mapping.addProc(x, y, p)
224
225    ############################################################################
226    # GIET_VM specifics
227
228    # define bootloader vsegs base addresses
229    bmapping_vbase = 0x00001000           # ident
230    bmapping_size = 0x0007F000            # 508 Kbytes
231
232    bcode_vbase = 0x00080000              # ident
233    bcode_size = 0x00040000               # 256 Kbytes
234
235    bdata_vbase = 0x000C0000              # ident
236    bdata_size = 0x00080000               # 512 Kbytes
237
238    bstack_vbase = 0x00140000             # ident
239    bstack_size = 0x00050000              # 320 Kbytes
240
241    # define kernel vsegs base addresses and sizes
242    kcode_vbase = 0x80000000
243    kcode_size = 0x00080000               # 512 Kbytes
244
245    kinit_vbase = 0x80800000
246    kinit_size = 0x00080000               # 512 Kbytes
247
248    kdata_vbase = 0x80100000
249    kdata_size = 0x00080000               # 512 Kbytes
250
251    kuncdata_vbase = 0x80180000
252    kuncdata_size = 0x00001000            # 4 Kbytes
253
254    kptab_vbase = 0xC0000000
255    kptab_size = 0x00200000               # 512 Kbytes
256
257    ksched_vbase = 0xF0000000             # distributed in all clusters
258    ksched_size = 0x2000 * nb_procs       # 8 kbytes per processor
259
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)
264
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)
268
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)
272
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)
276
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)
285
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)
290
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)
296
297
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)
303
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)
309
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)
314
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)
318
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)
321
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)
324
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)
327
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)
330
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)
333
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)
336
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)
339
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
344
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)
348
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)
352
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)
356
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)
360
361    return mapping
362
363def main(x, y, p, hard_path, xml_path):
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)
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
375################################# platform test ################################
376import sys
377if __name__ == '__main__':
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")
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.