source: trunk/platforms/tsar_generic_leti/top.cpp @ 1053

Last change on this file since 1053 was 1029, checked in by cfuguet, 9 years ago
  • Support the cluster 0 to be the IO cluster.
  • Update the arch.py to allow the execution of new revisions of the Giet-VM.
File size: 56.1 KB
Line 
1/////////////////////////////////////////////////////////////////////////
2// File: top.cpp (for tsar_generic_leti platform)
3// Author: Alain Greiner
4// Copyright: UPMC/LIP6
5// Date : february 2013 / updated january 2015
6// This program is released under the GNU public license
7/////////////////////////////////////////////////////////////////////////
8// This file define a generic TSAR architecture, fully compatible
9// with the VLSI Hardware prototype developped by CEA-LETI and LIP6
10// in the framework of the SHARP project.
11//
12// The processor is a MIPS32 processor wrapped in a GDB server
13// (this is defined in the tsar_leti_cluster).
14//
15// The main hardware parameters are the mesh size (X_SIZE & Y_SIZE),
16// and the number of processors per cluster (NB_PROCS_MAX).
17// The NB_PROCS_MAX parameter cannot be larger than 4.
18// Others parameters are the frame buffer size, the disk controller type
19// (BDV or HBA), the number of TTY channels, the number of NIC channels,
20// and the number of CMA channels.
21//
22// All external peripherals are located in cluster[X_SIZE-1][Y_SIZE-1],
23// and are connected to an IO bus (implemented as a vci_local_crossbar):
24// - DISK : block device controller (BDV / HBA)
25// - MNIC : multi-channel ethernet controller
26// - CDMA : multi-channel chained buffer dma controller
27// - MTTY : multi-channel tty controller
28// - FBUF : frame buffer controller
29// - IOPI : HWI to SWI translator
30//
31// This IO bus is directly connected to the north ports of the CMD/RSP
32// routers in cluster[X_SIZE-1][y_SIZE-2] through VCI/DSPIN wrappers.
33// All other clusters in the upper row are empty: no processors,
34// no ram, no routers.
35// The X_SIZE parameter must be larger than 0, but no larger than 16.
36// The Y_SIZE parameter must be larger than 1, but no larger than 16.
37//
38// We don't use an external ROM, as the boot code is (pre)loaded
39// in RAM in cluster[0][0] at address 0x0.
40//
41// An optional RAMDISK of 32 Mbytes can be used in RAM of cluster[0][0].
42//
43// The physical address space is 40 bits.
44// The 8 address MSB bits define the cluster index.
45//
46// Besides the processors, each cluster contains:
47// - 5 L1/L2 DSPIN routers implementing 5 separated NOCs
48// - 1 vci_mem_cache
49// - 1 vci_xicu
50// - 1 vci_simple_ram (to emulate the L3 cache).
51//
52// Each processor receives 4 consecutive IRQ lines from the local XICU.
53// The number of PTI and WTI IRQs is bounded to 16.
54//
55// In all clusters, the MEMC IRQ line (signaling a late write error)
56// is connected to XICU HWI[8]
57//
58// For all external peripherals, the hardware interrupts (HWI) are
59// translated to write interrupts (WTI) by the iopic component:
60// - IOPIC HWI[1:0]     connected to IRQ_NIC_RX[1:0]
61// - IOPIC HWI[3:2]     connected to IRQ_NIC_TX[1:0]
62// - IOPIC HWI[7:4]     connected to IRQ_CMA_TX[3:0]]
63// - IOPIC HWI[8]       connected to IRQ_DISK
64// - IOPIC HWI[15:9]    unused       (grounded)
65// - IOPIC HWI[23:16]   connected to IRQ_TTY_RX[7:0]]
66// - IOPIC HWI[31:24]   connected to IRQ_TTY_TX[7:0]]
67//
68// The cluster internal architecture is defined in file tsar_leti_cluster,
69// that must be considered as an extension of this top.cpp file.
70////////////////////////////////////////////////////////////////////////////
71// The following parameters must be defined in the hard_config.h file :
72// - X_WIDTH          : number of bits for x coordinate (must be 4)
73// - Y_WIDTH          : number of bits for y coordinate (must be 4)
74// - P_WIDTH          : number of bits for local processor coordinate
75// - X_SIZE           : number of clusters in a row (1,2,4,8,16)
76// - Y_SIZE           : number of clusters in a column (1,2,4,8)
77// - NB_PROCS_MAX     : number of processors per cluster (1, 2 or 4)
78// - NB_CMA_CHANNELS  : number of CMA channels in I/0 cluster (4 max)
79// - NB_TTY_CHANNELS  : number of TTY channels in I/O cluster (8 max)
80// - NB_NIC_CHANNELS  : number of NIC channels in I/O cluster (2 max)
81// - FBUF_X_SIZE      : number of pixels per line for frame buffer
82// - FBUF_Y_SIZE      : number of lines for frame buffer
83// - XCU_NB_HWI       : number of XCU HWIs (must be 16)
84// - XCU_NB_PTI       : number of XCU PTIs (must be 16)
85// - XCU_NB_WTI       : number of XCU WTIs (must be 16)
86// - XCU_NB_OUT       : number of XCU output (must be 16)
87// - USE_IOC_XYZ      : IOC type (XYZ in HBA / BDV / SDC / RDK)
88//
89// Some other hardware parameters are not used when compiling the OS,
90// and are only defined in this top.cpp file:
91// - XRAM_LATENCY     : external ram latency
92// - L1_IWAYS         : L1 cache instruction number of ways
93// - L1_ISETS         : L1 cache instruction number of sets
94// - L1_DWAYS         : L1 cache data number of ways
95// - L1_DSETS         : L1 cache data number of sets
96// - DISK_IMAGE_NAME  : pathname for block device disk image
97/////////////////////////////////////////////////////////////////////////
98// General policy for 40 bits physical address decoding:
99// All physical segments base addresses are multiple of 1 Mbytes
100// (=> the 24 LSB bits = 0, and the 16 MSB bits define the target)
101// The (X_WIDTH + Y_WIDTH) MSB bits (left aligned) define
102// the cluster index, and the LADR bits define the local index:
103//      |X_ID|Y_ID|  LADR |     OFFSET          |
104//      |  4 |  4 |   8   |       24            |
105/////////////////////////////////////////////////////////////////////////
106// General policy for 14 bits SRCID decoding:
107// Each component is identified by (x_id, y_id, l_id) tuple.
108//      |X_ID|Y_ID| L_ID |
109//      |  4 |  4 |  6   |
110/////////////////////////////////////////////////////////////////////////
111
112#include <systemc>
113#include <sys/time.h>
114#include <iostream>
115#include <sstream>
116#include <cstdlib>
117#include <cstdarg>
118#include <stdint.h>
119
120#include "gdbserver.h"
121#include "mapping_table.h"
122
123#include "tsar_leti_cluster.h"
124#include "vci_local_crossbar.h"
125#include "vci_dspin_initiator_wrapper.h"
126#include "vci_dspin_target_wrapper.h"
127#include "vci_multi_tty.h"
128#include "vci_multi_nic.h"
129#include "vci_chbuf_dma.h"
130#include "vci_block_device_tsar.h"
131#include "vci_multi_ahci.h"
132#include "vci_framebuffer.h"
133#include "vci_iopic.h"
134
135#include "alloc_elems.h"
136
137///////////////////////////////////////////////////
138// Main hardware parameters values
139///////////////////////////////////////////////////
140
141#include "hard_config.h"
142
143///////////////////////////////////////////////////////////////////////////////////////
144//    Secondary Hardware Parameters
145///////////////////////////////////////////////////////////////////////////////////////
146
147#define XMAX                  X_SIZE         // actual number of columns in 2D mesh
148#define YMAX                  (Y_SIZE - 1)   // actual number of rows in 2D mesh
149
150#define XRAM_LATENCY          0
151
152#define MEMC_WAYS             16
153#define MEMC_SETS             256
154
155#define L1_IWAYS              4
156#define L1_ISETS              64
157
158#define L1_DWAYS              4
159#define L1_DSETS              64
160
161#define DISK_IMAGE_NAME       "virt_hdd.dmg"
162
163#define ROM_SOFT_NAME         "../../softs/tsar_boot/preloader.elf"
164
165#define NORTH                 0
166#define SOUTH                 1
167#define EAST                  2
168#define WEST                  3
169
170///////////////////////////////////////////////////
171//               Parallelisation
172///////////////////////////////////////////////////
173
174#define USE_OPENMP _OPENMP
175
176#if USE_OPENMP
177#include <omp.h>
178#endif
179
180///////////////////////////////////////////////////
181//  cluster index (from x,y coordinates)
182///////////////////////////////////////////////////
183
184#define cluster(x,y)   ((y) + ((x) << Y_WIDTH))
185
186///////////////////////////////////////////////////////////
187//          DSPIN parameters
188///////////////////////////////////////////////////////////
189
190#define dspin_cmd_width      39
191#define dspin_rsp_width      32
192
193///////////////////////////////////////////////////////////
194//          VCI parameters
195///////////////////////////////////////////////////////////
196
197#define vci_cell_width_int    4
198#define vci_cell_width_ext    8
199#define vci_address_width     40
200#define vci_plen_width        8
201#define vci_rerror_width      1
202#define vci_clen_width        1
203#define vci_rflag_width       1
204#define vci_srcid_width       14
205#define vci_pktid_width       4
206#define vci_trdid_width       4
207#define vci_wrplen_width      1
208
209
210
211///////////////////////////////////////////////////////////////////////////////////////
212//     DEBUG Parameters default values
213///////////////////////////////////////////////////////////////////////////////////////
214
215#define MAX_FROZEN_CYCLES     500000
216
217///////////////////////////////////////////////////////////////////////////////////////
218//     LOCAL TGTID & SRCID definition
219// For all components:  global TGTID = global SRCID = cluster_index
220///////////////////////////////////////////////////////////////////////////////////////
221
222#define MEMC_TGTID            0
223#define XICU_TGTID            1
224#define MTTY_TGTID            2
225#define DISK_TGTID            3
226#define FBUF_TGTID            4
227#define MNIC_TGTID            5
228#define CDMA_TGTID            6
229#define IOPI_TGTID            7
230
231#define DISK_SRCID            NB_PROCS_MAX
232#define CDMA_SRCID            NB_PROCS_MAX + 1
233#define IOPI_SRCID            NB_PROCS_MAX + 2
234
235bool stop_called = false;
236
237/////////////////////////////////
238int _main(int argc, char *argv[])
239{
240   using namespace sc_core;
241   using namespace soclib::caba;
242   using namespace soclib::common;
243
244   uint32_t ncycles           = 0xFFFFFFFF;         // max simulated cycles
245   size_t   threads           = 1;                  // simulator's threads number
246   bool     trace_ok          = false;              // trace activated
247   uint32_t trace_from        = 0;                  // trace start cycle
248   bool     trace_proc_ok     = false;              // detailed proc trace activated
249   size_t   trace_memc_ok     = false;              // detailed memc trace activated
250   size_t   trace_memc_id     = 0;                  // index of memc to be traced
251   size_t   trace_proc_id     = 0;                  // index of proc to be traced
252   char     soft_name[256]    = ROM_SOFT_NAME;      // pathname for ROM binary code
253   char     disk_name[256]    = DISK_IMAGE_NAME;    // pathname for DISK image
254   uint32_t frozen_cycles     = MAX_FROZEN_CYCLES;  // for debug
255   struct   timeval t1,t2;
256   uint64_t ms1,ms2;
257
258   ////////////// command line arguments //////////////////////
259   if (argc > 1)
260   {
261      for (int n = 1; n < argc; n = n + 2)
262      {
263         if ((strcmp(argv[n], "-NCYCLES") == 0) && (n + 1 < argc))
264         {
265            ncycles = (uint64_t) strtol(argv[n + 1], NULL, 0);
266         }
267         else if ((strcmp(argv[n],"-SOFT") == 0) && (n + 1 < argc))
268         {
269            strcpy(soft_name, argv[n + 1]);
270         }
271         else if ((strcmp(argv[n],"-DISK") == 0) && (n + 1 < argc))
272         {
273            strcpy(disk_name, argv[n + 1]);
274         }
275         else if ((strcmp(argv[n],"-DEBUG") == 0) && (n + 1 < argc))
276         {
277            trace_ok = true;
278            trace_from = (uint32_t) strtol(argv[n + 1], NULL, 0);
279         }
280         else if ((strcmp(argv[n], "-MEMCID") == 0) && (n + 1 < argc))
281         {
282            trace_memc_ok = true;
283            trace_memc_id = (size_t) strtol(argv[n + 1], NULL, 0);
284            size_t x = trace_memc_id >> Y_WIDTH;
285            size_t y = trace_memc_id & ((1<<Y_WIDTH)-1);
286
287            assert( (x < XMAX) and (y < (YMAX)) and
288                  "MEMCID parameter doesxn't fit valid XMAX/YMAX");
289         }
290         else if ((strcmp(argv[n], "-PROCID") == 0) && (n + 1 < argc))
291         {
292            trace_proc_ok = true;
293            trace_proc_id = (size_t) strtol(argv[n + 1], NULL, 0);
294            size_t cluster_xy = trace_proc_id >> P_WIDTH ;
295            size_t x          = cluster_xy >> Y_WIDTH;
296            size_t y          = cluster_xy & ((1<<Y_WIDTH)-1);
297            size_t l          = trace_proc_id & ((1<<P_WIDTH)-1) ;
298
299            assert( (x < XMAX) and (y < YMAX) and (l < NB_PROCS_MAX) and
300                  "PROCID parameter refers a not valid processor");
301         }
302         else if ((strcmp(argv[n], "-THREADS") == 0) && ((n + 1) < argc))
303         {
304            threads = (size_t) strtol(argv[n + 1], NULL, 0);
305            threads = (threads < 1) ? 1 : threads;
306         }
307         else if ((strcmp(argv[n], "-FROZEN") == 0) && (n + 1 < argc))
308         {
309            frozen_cycles = (uint32_t) strtol(argv[n + 1], NULL, 0);
310         }
311         else
312         {
313            std::cout << "   Arguments are (key,value) couples." << std::endl;
314            std::cout << "   The order is not important." << std::endl;
315            std::cout << "   Accepted arguments are :" << std::endl << std::endl;
316            std::cout << "     - NCYCLES number_of_simulated_cycles" << std::endl;
317            std::cout << "     - DEBUG debug_start_cycle" << std::endl;
318            std::cout << "     - THREADS simulator's threads number" << std::endl;
319            std::cout << "     - FROZEN max_number_of_lines" << std::endl;
320            std::cout << "     - MEMCID index_memc_to_be_traced" << std::endl;
321            std::cout << "     - PROCID index_proc_to_be_traced" << std::endl;
322            exit(0);
323         }
324      }
325   }
326
327    // checking hardware parameters
328    assert( ((X_SIZE <= 16) and (X_SIZE > 0)) and
329            "Illegal X_SIZE parameter" );
330
331    assert( ((Y_SIZE <= 16) and (Y_SIZE > 1)) and
332            "Illegal Y_SIZE parameter" );
333
334    assert( (P_WIDTH <= 2) and
335            "P_WIDTH parameter cannot be larger than 2" );
336
337    assert( (NB_PROCS_MAX <= 4) and
338            "Illegal NB_PROCS_MAX parameter" );
339
340    assert( (XCU_NB_HWI == 16) and
341            "XCU_NB_HWI must be 16" );
342
343    assert( (XCU_NB_PTI == 16) and
344            "XCU_NB_PTI must be 16" );
345
346    assert( (XCU_NB_WTI == 16) and
347            "XCU_NB_WTI must be 16" );
348
349    assert( (XCU_NB_OUT == 16) and
350            "XCU_NB_OUT must be 16" );
351   
352    assert( (NB_CMA_CHANNELS <= 4) and
353            "The NB_CMA_CHANNELS parameter cannot be larger than 4" );
354
355    assert( (NB_TTY_CHANNELS <= 8) and
356            "The NB_TTY_CHANNELS parameter cannot be larger than 8" );
357
358    assert( (NB_NIC_CHANNELS <= 2) and
359            "The NB_NIC_CHANNELS parameter cannot be larger than 2" );
360
361    assert( (vci_address_width == 40) and
362            "VCI address width with the GIET must be 40 bits" );
363
364    assert( (X_WIDTH == 4) and (Y_WIDTH == 4) and
365            "You must have X_WIDTH == Y_WIDTH == 4");
366
367    std::cout << std::endl;
368
369    std::cout << " - XMAX             = " << XMAX << std::endl
370              << " - YMAX             = " << YMAX << std::endl
371              << " - NB_PROCS_MAX     = " << NB_PROCS_MAX <<  std::endl
372              << " - NB_TTY_CHANNELS  = " << NB_TTY_CHANNELS <<  std::endl
373              << " - NB_NIC_CHANNELS  = " << NB_NIC_CHANNELS <<  std::endl
374              << " - NB_CMA_CHANNELS  = " << NB_CMA_CHANNELS <<  std::endl
375              << " - MEMC_WAYS        = " << MEMC_WAYS << std::endl
376              << " - MEMC_SETS        = " << MEMC_SETS << std::endl
377              << " - RAM_LATENCY      = " << XRAM_LATENCY << std::endl
378              << " - MAX_FROZEN       = " << frozen_cycles << std::endl
379              << " - MAX_CYCLES       = " << ncycles << std::endl
380              << " - RESET_ADDRESS    = " << RESET_ADDRESS << std::endl
381              << " - SOFT_FILENAME    = " << soft_name << std::endl
382              << " - DISK_IMAGENAME   = " << disk_name << std::endl
383              << " - OPENMP THREADS   = " << threads << std::endl
384              << " - DEBUG_PROCID     = " << trace_proc_id << std::endl
385              << " - DEBUG_MEMCID     = " << trace_memc_id << std::endl;
386
387    std::cout << std::endl;
388
389    // Internal and External VCI parameters definition
390    typedef soclib::caba::VciParams<vci_cell_width_int,
391                                    vci_plen_width,
392                                    vci_address_width,
393                                    vci_rerror_width,
394                                    vci_clen_width,
395                                    vci_rflag_width,
396                                    vci_srcid_width,
397                                    vci_pktid_width,
398                                    vci_trdid_width,
399                                    vci_wrplen_width> vci_param_int;
400
401    typedef soclib::caba::VciParams<vci_cell_width_ext,
402                                    vci_plen_width,
403                                    vci_address_width,
404                                    vci_rerror_width,
405                                    vci_clen_width,
406                                    vci_rflag_width,
407                                    vci_srcid_width,
408                                    vci_pktid_width,
409                                    vci_trdid_width,
410                                    vci_wrplen_width> vci_param_ext;
411
412#if USE_OPENMP
413   omp_set_dynamic(false);
414   omp_set_num_threads(threads);
415   std::cerr << "Built with openmp version " << _OPENMP << std::endl;
416#endif
417
418
419   ///////////////////////////////////////
420   //  Direct Network Mapping Table
421   ///////////////////////////////////////
422
423   MappingTable maptabd(vci_address_width,
424                        IntTab(X_WIDTH + Y_WIDTH, 16 - X_WIDTH - Y_WIDTH),
425                        IntTab(X_WIDTH + Y_WIDTH, vci_srcid_width - X_WIDTH - Y_WIDTH),
426                        0x00FF000000ULL);
427
428   // replicated segments
429   for (size_t x = 0; x < XMAX; x++)
430   {
431      for (size_t y = 0; y < (YMAX) ; y++)
432      {
433         sc_uint<vci_address_width> offset;
434         offset = ((sc_uint<vci_address_width>)cluster(x,y)) << 32;
435
436         std::ostringstream    si;
437         si << "seg_xicu_" << x << "_" << y;
438         maptabd.add(Segment(si.str(), SEG_XCU_BASE + offset, SEG_XCU_SIZE,
439                  IntTab(cluster(x,y),XICU_TGTID), false));
440
441         std::ostringstream    sd;
442         sd << "seg_mcfg_" << x << "_" << y;
443         maptabd.add(Segment(sd.str(), SEG_MMC_BASE + offset, SEG_MMC_SIZE,
444                  IntTab(cluster(x,y),MEMC_TGTID), false));
445
446         std::ostringstream    sh;
447         sh << "seg_memc_" << x << "_" << y;
448         maptabd.add(Segment(sh.str(), SEG_RAM_BASE + offset, SEG_RAM_SIZE,
449                  IntTab(cluster(x,y),MEMC_TGTID), true));
450      }
451   }
452
453   // segments for peripherals in cluster(0,0)
454   maptabd.add(Segment("seg_tty0", SEG_TTY_BASE, SEG_TTY_SIZE,
455               IntTab(cluster(0,0),MTTY_TGTID), false));
456
457   maptabd.add(Segment("seg_ioc0", SEG_IOC_BASE, SEG_IOC_SIZE,
458               IntTab(cluster(0,0),DISK_TGTID), false));
459
460   // segments for peripherals in cluster_io (XMAX-1,YMAX)
461   sc_uint<vci_address_width> offset;
462   offset = ((sc_uint<vci_address_width>)cluster(XMAX-1,YMAX)) << 32;
463
464   maptabd.add(Segment("seg_mtty", SEG_TTY_BASE + offset, SEG_TTY_SIZE,
465               IntTab(cluster(XMAX-1, YMAX),MTTY_TGTID), false));
466
467   maptabd.add(Segment("seg_fbuf", SEG_FBF_BASE + offset, SEG_FBF_SIZE,
468               IntTab(cluster(XMAX-1, YMAX),FBUF_TGTID), false));
469
470   maptabd.add(Segment("seg_disk", SEG_IOC_BASE + offset, SEG_IOC_SIZE,
471               IntTab(cluster(XMAX-1, YMAX),DISK_TGTID), false));
472
473   maptabd.add(Segment("seg_mnic", SEG_NIC_BASE + offset, SEG_NIC_SIZE,
474               IntTab(cluster(XMAX-1, YMAX),MNIC_TGTID), false));
475
476   maptabd.add(Segment("seg_cdma", SEG_CMA_BASE + offset, SEG_CMA_SIZE,
477               IntTab(cluster(XMAX-1, YMAX),CDMA_TGTID), false));
478
479   maptabd.add(Segment("seg_iopi", SEG_PIC_BASE + offset, SEG_PIC_SIZE,
480               IntTab(cluster(XMAX-1, YMAX),IOPI_TGTID), false));
481
482   std::cout << maptabd << std::endl;
483
484    /////////////////////////////////////////////////
485    // Ram network mapping table
486    /////////////////////////////////////////////////
487
488    MappingTable maptabx(vci_address_width,
489                         IntTab(X_WIDTH+Y_WIDTH),
490                         IntTab(X_WIDTH+Y_WIDTH),
491                         0x00FF000000ULL);
492
493    for (size_t x = 0; x < XMAX; x++)
494    {
495        for (size_t y = 0; y < (YMAX) ; y++)
496        {
497            sc_uint<vci_address_width> offset;
498            offset = (sc_uint<vci_address_width>)cluster(x,y)
499                      << (vci_address_width-X_WIDTH-Y_WIDTH);
500
501            std::ostringstream sh;
502            sh << "x_seg_memc_" << x << "_" << y;
503
504            maptabx.add(Segment(sh.str(), SEG_RAM_BASE + offset,
505                     SEG_RAM_SIZE, IntTab(cluster(x,y)), false));
506        }
507    }
508    std::cout << maptabx << std::endl;
509
510    ////////////////////
511    // Signals
512    ///////////////////
513
514    sc_clock                          signal_clk("clk");
515    sc_signal<bool>                   signal_resetn("resetn");
516
517    // IRQs from external peripherals
518    sc_signal<bool>                   signal_irq_disk;
519    sc_signal<bool>                   signal_irq_mnic_rx[NB_NIC_CHANNELS];
520    sc_signal<bool>                   signal_irq_mnic_tx[NB_NIC_CHANNELS];
521    sc_signal<bool>                   signal_irq_mtty_rx[NB_TTY_CHANNELS];
522    sc_signal<bool>                   signal_irq_cdma[NB_CMA_CHANNELS];
523    sc_signal<bool>                   signal_irq_false;
524
525   // Horizontal inter-clusters DSPIN signals
526   DspinSignals<dspin_cmd_width>** signal_dspin_h_cmd_inc =
527      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_inc", XMAX-1, YMAX);
528   DspinSignals<dspin_cmd_width>** signal_dspin_h_cmd_dec =
529      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_dec", XMAX-1, YMAX);
530
531   DspinSignals<dspin_rsp_width>** signal_dspin_h_rsp_inc =
532      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_rsp_inc", XMAX-1, YMAX);
533   DspinSignals<dspin_rsp_width>** signal_dspin_h_rsp_dec =
534      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_rsp_dec", XMAX-1, YMAX);
535
536   DspinSignals<dspin_cmd_width>** signal_dspin_h_m2p_inc =
537      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_m2p_inc", XMAX-1, YMAX);
538   DspinSignals<dspin_cmd_width>** signal_dspin_h_m2p_dec =
539      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_m2p_dec", XMAX-1, YMAX);
540
541   DspinSignals<dspin_rsp_width>** signal_dspin_h_p2m_inc =
542      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_p2m_inc", XMAX-1, YMAX);
543   DspinSignals<dspin_rsp_width>** signal_dspin_h_p2m_dec =
544      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_p2m_dec", XMAX-1, YMAX);
545
546   DspinSignals<dspin_cmd_width>** signal_dspin_h_cla_inc =
547      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cla_inc", XMAX-1, YMAX);
548   DspinSignals<dspin_cmd_width>** signal_dspin_h_cla_dec =
549      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cla_dec", XMAX-1, YMAX);
550
551   // Vertical inter-clusters DSPIN signals
552   DspinSignals<dspin_cmd_width>** signal_dspin_v_cmd_inc =
553      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_inc", XMAX, YMAX-1);
554   DspinSignals<dspin_cmd_width>** signal_dspin_v_cmd_dec =
555      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_dec", XMAX, YMAX-1);
556
557   DspinSignals<dspin_rsp_width>** signal_dspin_v_rsp_inc =
558      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_rsp_inc", XMAX, YMAX-1);
559   DspinSignals<dspin_rsp_width>** signal_dspin_v_rsp_dec =
560      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_rsp_dec", XMAX, YMAX-1);
561
562   DspinSignals<dspin_cmd_width>** signal_dspin_v_m2p_inc =
563      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_m2p_inc", XMAX, YMAX-1);
564   DspinSignals<dspin_cmd_width>** signal_dspin_v_m2p_dec =
565      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_m2p_dec", XMAX, YMAX-1);
566
567   DspinSignals<dspin_rsp_width>** signal_dspin_v_p2m_inc =
568      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_p2m_inc", XMAX, YMAX-1);
569   DspinSignals<dspin_rsp_width>** signal_dspin_v_p2m_dec =
570      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_p2m_dec", XMAX, YMAX-1);
571
572   DspinSignals<dspin_cmd_width>** signal_dspin_v_cla_inc =
573      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cla_inc", XMAX, YMAX-1);
574   DspinSignals<dspin_cmd_width>** signal_dspin_v_cla_dec =
575      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cla_dec", XMAX, YMAX-1);
576
577   // Mesh boundaries DSPIN signals (Most of those signals are not used...)
578   DspinSignals<dspin_cmd_width>*** signal_dspin_bound_cmd_in =
579      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_bound_cmd_in" , XMAX, YMAX, 4);
580   DspinSignals<dspin_cmd_width>*** signal_dspin_bound_cmd_out =
581      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_bound_cmd_out", XMAX, YMAX, 4);
582
583   DspinSignals<dspin_rsp_width>*** signal_dspin_bound_rsp_in =
584      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_bound_rsp_in" , XMAX, YMAX, 4);
585   DspinSignals<dspin_rsp_width>*** signal_dspin_bound_rsp_out =
586      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_bound_rsp_out", XMAX, YMAX, 4);
587
588   DspinSignals<dspin_cmd_width>*** signal_dspin_bound_m2p_in =
589      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_bound_m2p_in" , XMAX, YMAX, 4);
590   DspinSignals<dspin_cmd_width>*** signal_dspin_bound_m2p_out =
591      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_bound_m2p_out", XMAX, YMAX, 4);
592
593   DspinSignals<dspin_rsp_width>*** signal_dspin_bound_p2m_in =
594      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_bound_p2m_in" , XMAX, YMAX, 4);
595   DspinSignals<dspin_rsp_width>*** signal_dspin_bound_p2m_out =
596      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_bound_p2m_out", XMAX, YMAX, 4);
597
598   DspinSignals<dspin_cmd_width>*** signal_dspin_bound_cla_in =
599      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_bound_cla_in" , XMAX, YMAX, 4);
600   DspinSignals<dspin_cmd_width>*** signal_dspin_bound_cla_out =
601      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_bound_cla_out", XMAX, YMAX, 4);
602
603   // VCI signals for iobus and peripherals
604   VciSignals<vci_param_int>    signal_vci_ini_disk("signal_vci_ini_disk");
605   VciSignals<vci_param_int>    signal_vci_ini_cdma("signal_vci_ini_cdma");
606   VciSignals<vci_param_int>    signal_vci_ini_iopi("signal_vci_ini_iopi");
607
608   VciSignals<vci_param_int>*   signal_vci_ini_proc =
609       alloc_elems<VciSignals<vci_param_int> >("signal_vci_ini_proc", NB_PROCS_MAX );
610
611   VciSignals<vci_param_int>    signal_vci_tgt_memc("signal_vci_tgt_memc");
612   VciSignals<vci_param_int>    signal_vci_tgt_xicu("signal_vci_tgt_xicu");
613   VciSignals<vci_param_int>    signal_vci_tgt_disk("signal_vci_tgt_disk");
614   VciSignals<vci_param_int>    signal_vci_tgt_mtty("signal_vci_tgt_mtty");
615   VciSignals<vci_param_int>    signal_vci_tgt_fbuf("signal_vci_tgt_fbuf");
616   VciSignals<vci_param_int>    signal_vci_tgt_mnic("signal_vci_tgt_mnic");
617   VciSignals<vci_param_int>    signal_vci_tgt_cdma("signal_vci_tgt_cdma");
618   VciSignals<vci_param_int>    signal_vci_tgt_iopi("signal_vci_tgt_iopi");
619
620   VciSignals<vci_param_int>    signal_vci_cmd_to_noc("signal_vci_cmd_to_noc");
621   VciSignals<vci_param_int>    signal_vci_cmd_from_noc("signal_vci_cmd_from_noc");
622
623   ////////////////////////////
624   //      Loader
625   ////////////////////////////
626
627#if USE_IOC_RDK
628   std::ostringstream ramdisk_name;
629   ramdisk_name << disk_name << "@" << std::hex << SEG_RDK_BASE << ":";
630   soclib::common::Loader loader( soft_name, ramdisk_name.str().c_str() );
631#else
632   soclib::common::Loader loader( soft_name );
633#endif
634
635   loader.memory_default(0x55);
636
637   typedef soclib::common::GdbServer<soclib::common::Mips32ElIss> proc_iss;
638   proc_iss::set_loader( loader );
639
640   //////////////////////////////////////////////////////////////
641   // mesh construction: XMAX * YMAX clusters
642   //////////////////////////////////////////////////////////////
643
644   TsarLetiCluster<dspin_cmd_width,
645                   dspin_rsp_width,
646                   vci_param_int,
647                   vci_param_ext>*          clusters[XMAX][YMAX];
648
649#if USE_OPENMP
650#pragma omp parallel
651    {
652#pragma omp for
653#endif
654        for (size_t i = 0; i  < (XMAX * YMAX); i++)
655        {
656            size_t x = i / (YMAX);
657            size_t y = i % (YMAX);
658
659#if USE_OPENMP
660#pragma omp critical
661            {
662#endif
663            std::cout << std::endl;
664            std::cout << "Cluster_" << std::dec << x << "_" << y
665                      << " with cluster_xy = " << std::hex << cluster(x,y) << std::endl;
666            std::cout << std::endl;
667
668            std::ostringstream cluster_name;
669            cluster_name <<  "cluster_" << std::dec << x << "_" << y;
670
671            clusters[x][y] = new TsarLetiCluster<dspin_cmd_width,
672                                                 dspin_rsp_width,
673                                                 vci_param_int,
674                                                 vci_param_ext>
675            (
676                cluster_name.str().c_str(),
677                NB_PROCS_MAX,
678                x,
679                y,
680                cluster(x,y),
681                maptabd,
682                maptabx,
683                RESET_ADDRESS,
684                X_WIDTH,
685                Y_WIDTH,
686                vci_srcid_width - X_WIDTH - Y_WIDTH,   // l_id width,
687                P_WIDTH,
688                MEMC_TGTID,
689                XICU_TGTID,
690                MTTY_TGTID,
691                DISK_TGTID,
692                (USE_IOC_RDK == 1),
693                disk_name,
694                MEMC_WAYS,
695                MEMC_SETS,
696                L1_IWAYS,
697                L1_ISETS,
698                L1_DWAYS,
699                L1_DSETS,
700                XRAM_LATENCY,
701                loader,
702                frozen_cycles,
703                trace_from,
704                trace_proc_ok,
705                trace_proc_id,
706                trace_memc_ok,
707                trace_memc_id
708            );
709
710#if USE_OPENMP
711            } // end critical
712#endif
713        } // end for
714#if USE_OPENMP
715    }
716#endif
717
718#if USE_PIC
719
720    //////////////////////////////////////////////////////////////////
721    // IO bus and external peripherals in cluster[X_SIZE-1][Y_SIZE-1]
722    // - 6 local targets    : FBF, TTY, CMA, NIC, PIC, IOC
723    // - 3 local initiators : IOC, CMA, PIC
724    // There is no PROC, no MEMC and no XICU in this cluster,
725    // but the crossbar has (NB_PROCS_MAX + 3) intiators and
726    // 8 targets, in order to use the same SRCID and TGTID space
727    // (same mapping table for the internal components,
728    //  and for the external peripherals)
729    //////////////////////////////////////////////////////////////////
730
731    std::cout << std::endl;
732    std::cout << " Building IO cluster (external peripherals)" << std::endl;
733    std::cout << std::endl;
734
735    size_t cluster_io = cluster(XMAX-1, YMAX);
736
737    //////////// vci_local_crossbar
738    VciLocalCrossbar<vci_param_int>*
739    iobus = new VciLocalCrossbar<vci_param_int>(
740                "iobus",
741                maptabd,                      // mapping table
742                cluster_io,                   // cluster_xy
743                NB_PROCS_MAX + 3,             // number of local initiators
744                8,                            // number of local targets
745                DISK_TGTID );                 // default target index
746
747    //////////// vci_framebuffer
748    VciFrameBuffer<vci_param_int>*
749    fbuf = new VciFrameBuffer<vci_param_int>(
750                "fbuf",
751                IntTab(cluster_io, FBUF_TGTID),
752                maptabd,
753                FBUF_X_SIZE, FBUF_Y_SIZE );
754
755#if ( USE_IOC_HBA )
756
757    ////////////  vci_multi_ahci
758    std::vector<std::string> filenames;
759    filenames.push_back(disk_name);           // one single disk
760    VciMultiAhci<vci_param_int>* 
761    disk = new VciMultiAhci<vci_param_int>( 
762                "disk",
763                maptabd,
764                IntTab(cluster_io, DISK_SRCID),
765                IntTab(cluster_io, DISK_TGTID),
766                filenames,
767                512,                          // block size
768                64,                           // burst size (bytes)
769                0 );                          // disk latency
770
771#elif ( USE_IOC_BDV or USE_IOC_SDC )
772
773    ////////////  vci_block_device
774    VciBlockDeviceTsar<vci_param_int>*
775    disk = new VciBlockDeviceTsar<vci_param_int>(
776                "disk",
777                maptabd,
778                IntTab(cluster_io, DISK_SRCID),
779                IntTab(cluster_io, DISK_TGTID),
780                disk_name,
781                512,                          // block size
782                64,                           // burst size (bytes)
783                0 );                          // disk latency
784#endif
785
786    //////////// vci_multi_nic
787    VciMultiNic<vci_param_int>*
788    mnic = new VciMultiNic<vci_param_int>(
789             "mnic",
790                IntTab(cluster_io, MNIC_TGTID),
791                maptabd,
792                NB_NIC_CHANNELS,
793                0,                // default MAC_4 address
794                0,                // default MAC_2 address
795                1,                // NIC_MODE_SYNTHESIS
796                12 );             // INTER_FRAME_GAP
797
798    ///////////// vci_chbuf_dma
799    VciChbufDma<vci_param_int>*
800    cdma = new VciChbufDma<vci_param_int>(
801                "cdma",
802                maptabd,
803                IntTab(cluster_io, CDMA_SRCID),
804                IntTab(cluster_io, CDMA_TGTID),
805                64,                               // burst size
806                NB_CMA_CHANNELS,
807                4 );                              // number of pipelined bursts
808
809    ////////////// vci_multi_tty
810    std::vector<std::string> vect_names;
811    for (size_t id = 0; id < NB_TTY_CHANNELS; id++)
812    {
813        std::ostringstream term_name;
814        term_name <<  "ext_" << id;
815        vect_names.push_back(term_name.str().c_str());
816    }
817
818    VciMultiTty<vci_param_int>*
819    mtty = new VciMultiTty<vci_param_int>(
820                "mtty",
821                IntTab(cluster_io, MTTY_TGTID),
822                maptabd,
823                vect_names );
824
825    ///////////// vci_iopic
826    VciIopic<vci_param_int>*
827    iopic = new VciIopic<vci_param_int>(
828                "iopic",
829                maptabd,
830                IntTab(cluster_io, IOPI_SRCID),
831                IntTab(cluster_io, IOPI_TGTID),
832                32 );
833
834    ////////////// vci_dspin wrappers
835    VciDspinTargetWrapper<vci_param_int, dspin_cmd_width, dspin_rsp_width>*
836    wt_iobus = new VciDspinTargetWrapper<vci_param_int, dspin_cmd_width, dspin_rsp_width>(
837                "wt_iobus",
838                vci_srcid_width );
839
840    VciDspinInitiatorWrapper<vci_param_int, dspin_cmd_width, dspin_rsp_width>*
841    wi_iobus = new VciDspinInitiatorWrapper<vci_param_int, dspin_cmd_width, dspin_rsp_width>(
842                "wi_iobus",
843                vci_srcid_width );
844
845    ///////////////////////////////////////////////////////////////
846    //     IObus  Net-list
847    ///////////////////////////////////////////////////////////////
848
849    // iobus
850    iobus->p_clk                       (signal_clk);
851    iobus->p_resetn                    (signal_resetn);
852
853    iobus->p_target_to_up              (signal_vci_cmd_from_noc);
854    iobus->p_initiator_to_up           (signal_vci_cmd_to_noc);
855
856    iobus->p_to_target[MEMC_TGTID]     (signal_vci_tgt_memc);
857    iobus->p_to_target[XICU_TGTID]     (signal_vci_tgt_xicu);
858    iobus->p_to_target[MTTY_TGTID]     (signal_vci_tgt_mtty);
859    iobus->p_to_target[FBUF_TGTID]     (signal_vci_tgt_fbuf);
860    iobus->p_to_target[MNIC_TGTID]     (signal_vci_tgt_mnic);
861    iobus->p_to_target[DISK_TGTID]     (signal_vci_tgt_disk);
862    iobus->p_to_target[CDMA_TGTID]     (signal_vci_tgt_cdma);
863    iobus->p_to_target[IOPI_TGTID]     (signal_vci_tgt_iopi);
864
865    for( size_t p=0 ; p<NB_PROCS_MAX ; p++ )
866    {
867        iobus->p_to_initiator[p]       (signal_vci_ini_proc[p]);
868    }
869    iobus->p_to_initiator[DISK_SRCID]  (signal_vci_ini_disk);
870    iobus->p_to_initiator[CDMA_SRCID]  (signal_vci_ini_cdma);
871    iobus->p_to_initiator[IOPI_SRCID]  (signal_vci_ini_iopi);
872
873    std::cout << "  - IOBUS connected" << std::endl;
874
875    // disk
876#if ( USE_IOC_HBA or USE_IOC_BDV or USE_IOC_SDC )
877    disk->p_clk                        (signal_clk);
878    disk->p_resetn                     (signal_resetn);
879    disk->p_vci_target                 (signal_vci_tgt_disk);
880    disk->p_vci_initiator              (signal_vci_ini_disk);
881#if USE_IOC_HBA
882    disk->p_channel_irq[0]             (signal_irq_disk);
883#else
884    disk->p_irq                        (signal_irq_disk);
885#endif
886
887    std::cout << "  - DISK connected" << std::endl;
888#endif
889
890    // frame_buffer
891    fbuf->p_clk                        (signal_clk);
892    fbuf->p_resetn                     (signal_resetn);
893    fbuf->p_vci                        (signal_vci_tgt_fbuf);
894
895    std::cout << "  - FBUF connected" << std::endl;
896
897    // multi_nic
898    mnic->p_clk                        (signal_clk);
899    mnic->p_resetn                     (signal_resetn);
900    mnic->p_vci                        (signal_vci_tgt_mnic);
901    for ( size_t i=0 ; i<NB_NIC_CHANNELS ; i++ )
902    {
903         mnic->p_rx_irq[i]             (signal_irq_mnic_rx[i]);
904         mnic->p_tx_irq[i]             (signal_irq_mnic_tx[i]);
905    }
906
907    std::cout << "  - MNIC connected" << std::endl;
908
909    // chbuf_dma
910    cdma->p_clk                        (signal_clk);
911    cdma->p_resetn                     (signal_resetn);
912    cdma->p_vci_target                 (signal_vci_tgt_cdma);
913    cdma->p_vci_initiator              (signal_vci_ini_cdma);
914    for ( size_t i=0 ; i<NB_CMA_CHANNELS ; i++)
915    {
916        cdma->p_irq[i]                 (signal_irq_cdma[i]);
917    }
918
919    std::cout << "  - CDMA connected" << std::endl;
920
921    // multi_tty
922    mtty->p_clk                        (signal_clk);
923    mtty->p_resetn                     (signal_resetn);
924    mtty->p_vci                        (signal_vci_tgt_mtty);
925    for ( size_t i=0 ; i<NB_TTY_CHANNELS ; i++ )
926    {
927        mtty->p_irq[i]                  (signal_irq_mtty_rx[i]);
928    }
929
930    std::cout << "  - MTTY connected" << std::endl;
931
932    // iopic
933    // NB_NIC_CHANNELS <= 2
934    // NB_CMA_CHANNELS <= 4
935    // NB_TTY_CHANNELS <= 16
936    iopic->p_clk                       (signal_clk);
937    iopic->p_resetn                    (signal_resetn);
938    iopic->p_vci_target                (signal_vci_tgt_iopi);
939    iopic->p_vci_initiator             (signal_vci_ini_iopi);
940    for ( size_t i=0 ; i<32 ; i++)
941    {
942       if     (i < NB_NIC_CHANNELS)    iopic->p_hwi[i] (signal_irq_mnic_rx[i]);
943       else if(i < 2 )                 iopic->p_hwi[i] (signal_irq_false);
944       else if(i < 2+NB_NIC_CHANNELS)  iopic->p_hwi[i] (signal_irq_mnic_tx[i-2]);
945       else if(i < 4 )                 iopic->p_hwi[i] (signal_irq_false);
946       else if(i < 4+NB_CMA_CHANNELS)  iopic->p_hwi[i] (signal_irq_cdma[i-4]);
947       else if(i < 8)                  iopic->p_hwi[i] (signal_irq_false);
948       else if(i == 8)                 iopic->p_hwi[i] (signal_irq_disk);
949       else if(i < 16)                 iopic->p_hwi[i] (signal_irq_false);
950       else if(i < 16+NB_TTY_CHANNELS) iopic->p_hwi[i] (signal_irq_mtty_rx[i-16]);
951       else                            iopic->p_hwi[i] (signal_irq_false);
952    }
953
954    std::cout << "  - IOPIC connected" << std::endl;
955
956    // vci/dspin wrappers
957    wi_iobus->p_clk                    (signal_clk);
958    wi_iobus->p_resetn                 (signal_resetn);
959    wi_iobus->p_vci                    (signal_vci_cmd_to_noc);
960    wi_iobus->p_dspin_cmd              (signal_dspin_bound_cmd_in[XMAX-1][YMAX-1][NORTH]);
961    wi_iobus->p_dspin_rsp              (signal_dspin_bound_rsp_out[XMAX-1][YMAX-1][NORTH]);
962
963    // vci/dspin wrappers
964    wt_iobus->p_clk                    (signal_clk);
965    wt_iobus->p_resetn                 (signal_resetn);
966    wt_iobus->p_vci                    (signal_vci_cmd_from_noc);
967    wt_iobus->p_dspin_cmd              (signal_dspin_bound_cmd_out[XMAX-1][YMAX-1][NORTH]);
968    wt_iobus->p_dspin_rsp              (signal_dspin_bound_rsp_in[XMAX-1][YMAX-1][NORTH]);
969
970#endif  // USE_PIC
971
972    // Clock & RESET for clusters
973    for (size_t x = 0; x < (XMAX); x++)
974    {
975        for (size_t y = 0; y < (YMAX); y++)
976        {
977            clusters[x][y]->p_clk                    (signal_clk);
978            clusters[x][y]->p_resetn                 (signal_resetn);
979        }
980    }
981
982    // Inter Clusters horizontal connections
983    if (XMAX > 1)
984    {
985        for (size_t x = 0; x < (XMAX-1); x++)
986        {
987            for (size_t y = 0; y < (YMAX); y++)
988            {
989                clusters[x][y]->p_cmd_out[EAST]      (signal_dspin_h_cmd_inc[x][y]);
990                clusters[x+1][y]->p_cmd_in[WEST]     (signal_dspin_h_cmd_inc[x][y]);
991                clusters[x][y]->p_cmd_in[EAST]       (signal_dspin_h_cmd_dec[x][y]);
992                clusters[x+1][y]->p_cmd_out[WEST]    (signal_dspin_h_cmd_dec[x][y]);
993
994                clusters[x][y]->p_rsp_out[EAST]      (signal_dspin_h_rsp_inc[x][y]);
995                clusters[x+1][y]->p_rsp_in[WEST]     (signal_dspin_h_rsp_inc[x][y]);
996                clusters[x][y]->p_rsp_in[EAST]       (signal_dspin_h_rsp_dec[x][y]);
997                clusters[x+1][y]->p_rsp_out[WEST]    (signal_dspin_h_rsp_dec[x][y]);
998
999                clusters[x][y]->p_m2p_out[EAST]      (signal_dspin_h_m2p_inc[x][y]);
1000                clusters[x+1][y]->p_m2p_in[WEST]     (signal_dspin_h_m2p_inc[x][y]);
1001                clusters[x][y]->p_m2p_in[EAST]       (signal_dspin_h_m2p_dec[x][y]);
1002                clusters[x+1][y]->p_m2p_out[WEST]    (signal_dspin_h_m2p_dec[x][y]);
1003
1004                clusters[x][y]->p_p2m_out[EAST]      (signal_dspin_h_p2m_inc[x][y]);
1005                clusters[x+1][y]->p_p2m_in[WEST]     (signal_dspin_h_p2m_inc[x][y]);
1006                clusters[x][y]->p_p2m_in[EAST]       (signal_dspin_h_p2m_dec[x][y]);
1007                clusters[x+1][y]->p_p2m_out[WEST]    (signal_dspin_h_p2m_dec[x][y]);
1008
1009                clusters[x][y]->p_cla_out[EAST]      (signal_dspin_h_cla_inc[x][y]);
1010                clusters[x+1][y]->p_cla_in[WEST]     (signal_dspin_h_cla_inc[x][y]);
1011                clusters[x][y]->p_cla_in[EAST]       (signal_dspin_h_cla_dec[x][y]);
1012                clusters[x+1][y]->p_cla_out[WEST]    (signal_dspin_h_cla_dec[x][y]);
1013            }
1014        }
1015    }
1016    std::cout << std::endl << "Horizontal connections done" << std::endl;
1017
1018    // Inter Clusters vertical connections
1019    if (YMAX > 1)
1020    {
1021        for (size_t y = 0; y < (YMAX-1); y++)
1022        {
1023            for (size_t x = 0; x < XMAX; x++)
1024            {
1025                clusters[x][y]->p_cmd_out[NORTH]     (signal_dspin_v_cmd_inc[x][y]);
1026                clusters[x][y+1]->p_cmd_in[SOUTH]    (signal_dspin_v_cmd_inc[x][y]);
1027                clusters[x][y]->p_cmd_in[NORTH]      (signal_dspin_v_cmd_dec[x][y]);
1028                clusters[x][y+1]->p_cmd_out[SOUTH]   (signal_dspin_v_cmd_dec[x][y]);
1029
1030                clusters[x][y]->p_rsp_out[NORTH]     (signal_dspin_v_rsp_inc[x][y]);
1031                clusters[x][y+1]->p_rsp_in[SOUTH]    (signal_dspin_v_rsp_inc[x][y]);
1032                clusters[x][y]->p_rsp_in[NORTH]      (signal_dspin_v_rsp_dec[x][y]);
1033                clusters[x][y+1]->p_rsp_out[SOUTH]   (signal_dspin_v_rsp_dec[x][y]);
1034
1035                clusters[x][y]->p_m2p_out[NORTH]     (signal_dspin_v_m2p_inc[x][y]);
1036                clusters[x][y+1]->p_m2p_in[SOUTH]    (signal_dspin_v_m2p_inc[x][y]);
1037                clusters[x][y]->p_m2p_in[NORTH]      (signal_dspin_v_m2p_dec[x][y]);
1038                clusters[x][y+1]->p_m2p_out[SOUTH]   (signal_dspin_v_m2p_dec[x][y]);
1039
1040                clusters[x][y]->p_p2m_out[NORTH]     (signal_dspin_v_p2m_inc[x][y]);
1041                clusters[x][y+1]->p_p2m_in[SOUTH]    (signal_dspin_v_p2m_inc[x][y]);
1042                clusters[x][y]->p_p2m_in[NORTH]      (signal_dspin_v_p2m_dec[x][y]);
1043                clusters[x][y+1]->p_p2m_out[SOUTH]   (signal_dspin_v_p2m_dec[x][y]);
1044
1045                clusters[x][y]->p_cla_out[NORTH]     (signal_dspin_v_cla_inc[x][y]);
1046                clusters[x][y+1]->p_cla_in[SOUTH]    (signal_dspin_v_cla_inc[x][y]);
1047                clusters[x][y]->p_cla_in[NORTH]      (signal_dspin_v_cla_dec[x][y]);
1048                clusters[x][y+1]->p_cla_out[SOUTH]   (signal_dspin_v_cla_dec[x][y]);
1049            }
1050        }
1051    }
1052    std::cout << std::endl << "Vertical connections done" << std::endl;
1053
1054    // East & West boundary cluster connections
1055    for (size_t y = 0; y < (YMAX); y++)
1056    {
1057        clusters[0][y]->p_cmd_in[WEST]           (signal_dspin_bound_cmd_in[0][y][WEST]);
1058        clusters[0][y]->p_cmd_out[WEST]          (signal_dspin_bound_cmd_out[0][y][WEST]);
1059        clusters[XMAX-1][y]->p_cmd_in[EAST]    (signal_dspin_bound_cmd_in[XMAX-1][y][EAST]);
1060        clusters[XMAX-1][y]->p_cmd_out[EAST]   (signal_dspin_bound_cmd_out[XMAX-1][y][EAST]);
1061
1062        clusters[0][y]->p_rsp_in[WEST]           (signal_dspin_bound_rsp_in[0][y][WEST]);
1063        clusters[0][y]->p_rsp_out[WEST]          (signal_dspin_bound_rsp_out[0][y][WEST]);
1064        clusters[XMAX-1][y]->p_rsp_in[EAST]    (signal_dspin_bound_rsp_in[XMAX-1][y][EAST]);
1065        clusters[XMAX-1][y]->p_rsp_out[EAST]   (signal_dspin_bound_rsp_out[XMAX-1][y][EAST]);
1066
1067        clusters[0][y]->p_m2p_in[WEST]           (signal_dspin_bound_m2p_in[0][y][WEST]);
1068        clusters[0][y]->p_m2p_out[WEST]          (signal_dspin_bound_m2p_out[0][y][WEST]);
1069        clusters[XMAX-1][y]->p_m2p_in[EAST]    (signal_dspin_bound_m2p_in[XMAX-1][y][EAST]);
1070        clusters[XMAX-1][y]->p_m2p_out[EAST]   (signal_dspin_bound_m2p_out[XMAX-1][y][EAST]);
1071
1072        clusters[0][y]->p_p2m_in[WEST]           (signal_dspin_bound_p2m_in[0][y][WEST]);
1073        clusters[0][y]->p_p2m_out[WEST]          (signal_dspin_bound_p2m_out[0][y][WEST]);
1074        clusters[XMAX-1][y]->p_p2m_in[EAST]    (signal_dspin_bound_p2m_in[XMAX-1][y][EAST]);
1075        clusters[XMAX-1][y]->p_p2m_out[EAST]   (signal_dspin_bound_p2m_out[XMAX-1][y][EAST]);
1076
1077        clusters[0][y]->p_cla_in[WEST]           (signal_dspin_bound_cla_in[0][y][WEST]);
1078        clusters[0][y]->p_cla_out[WEST]          (signal_dspin_bound_cla_out[0][y][WEST]);
1079        clusters[XMAX-1][y]->p_cla_in[EAST]    (signal_dspin_bound_cla_in[XMAX-1][y][EAST]);
1080        clusters[XMAX-1][y]->p_cla_out[EAST]   (signal_dspin_bound_cla_out[XMAX-1][y][EAST]);
1081    }
1082
1083    std::cout << std::endl << "West & East boundaries connections done" << std::endl;
1084
1085    // North & South boundary clusters connections
1086    for (size_t x = 0; x < XMAX; x++)
1087    {
1088        clusters[x][0]->p_cmd_in[SOUTH]          (signal_dspin_bound_cmd_in[x][0][SOUTH]);
1089        clusters[x][0]->p_cmd_out[SOUTH]         (signal_dspin_bound_cmd_out[x][0][SOUTH]);
1090        clusters[x][YMAX-1]->p_cmd_in[NORTH]   (signal_dspin_bound_cmd_in[x][YMAX-1][NORTH]);
1091        clusters[x][YMAX-1]->p_cmd_out[NORTH]  (signal_dspin_bound_cmd_out[x][YMAX-1][NORTH]);
1092
1093        clusters[x][0]->p_rsp_in[SOUTH]          (signal_dspin_bound_rsp_in[x][0][SOUTH]);
1094        clusters[x][0]->p_rsp_out[SOUTH]         (signal_dspin_bound_rsp_out[x][0][SOUTH]);
1095        clusters[x][YMAX-1]->p_rsp_in[NORTH]   (signal_dspin_bound_rsp_in[x][YMAX-1][NORTH]);
1096        clusters[x][YMAX-1]->p_rsp_out[NORTH]  (signal_dspin_bound_rsp_out[x][YMAX-1][NORTH]);
1097
1098        clusters[x][0]->p_m2p_in[SOUTH]          (signal_dspin_bound_m2p_in[x][0][SOUTH]);
1099        clusters[x][0]->p_m2p_out[SOUTH]         (signal_dspin_bound_m2p_out[x][0][SOUTH]);
1100        clusters[x][YMAX-1]->p_m2p_in[NORTH]   (signal_dspin_bound_m2p_in[x][YMAX-1][NORTH]);
1101        clusters[x][YMAX-1]->p_m2p_out[NORTH]  (signal_dspin_bound_m2p_out[x][YMAX-1][NORTH]);
1102
1103        clusters[x][0]->p_p2m_in[SOUTH]          (signal_dspin_bound_p2m_in[x][0][SOUTH]);
1104        clusters[x][0]->p_p2m_out[SOUTH]         (signal_dspin_bound_p2m_out[x][0][SOUTH]);
1105        clusters[x][YMAX-1]->p_p2m_in[NORTH]   (signal_dspin_bound_p2m_in[x][YMAX-1][NORTH]);
1106        clusters[x][YMAX-1]->p_p2m_out[NORTH]  (signal_dspin_bound_p2m_out[x][YMAX-1][NORTH]);
1107
1108        clusters[x][0]->p_cla_in[SOUTH]          (signal_dspin_bound_cla_in[x][0][SOUTH]);
1109        clusters[x][0]->p_cla_out[SOUTH]         (signal_dspin_bound_cla_out[x][0][SOUTH]);
1110        clusters[x][YMAX-1]->p_cla_in[NORTH]   (signal_dspin_bound_cla_in[x][YMAX-1][NORTH]);
1111        clusters[x][YMAX-1]->p_cla_out[NORTH]  (signal_dspin_bound_cla_out[x][YMAX-1][NORTH]);
1112    }
1113
1114    std::cout << std::endl << "North & South boundaries connections done" << std::endl;
1115
1116    std::cout << std::endl;
1117
1118    ////////////////////////////////////////////////////////
1119    //   Simulation
1120    ///////////////////////////////////////////////////////
1121
1122    sc_start(sc_core::sc_time(0, SC_NS));
1123    signal_resetn    = false;
1124    signal_irq_false = false;
1125
1126    // set network boundaries signals default values
1127    // for all boundary clusters but the IO cluster
1128    for (size_t x = 0; x < XMAX ; x++)
1129    {
1130        for (size_t y = 0; y < YMAX ; y++)
1131        {
1132            for (size_t face = 0; face < 4; face++)
1133            {
1134                if ( (x != XMAX-1) or (y != YMAX-1) or (face != NORTH) )
1135                {
1136                    signal_dspin_bound_cmd_in [x][y][face].write = false;
1137                    signal_dspin_bound_cmd_in [x][y][face].read  = true;
1138                    signal_dspin_bound_cmd_out[x][y][face].write = false;
1139                    signal_dspin_bound_cmd_out[x][y][face].read  = true;
1140
1141                    signal_dspin_bound_rsp_in [x][y][face].write = false;
1142                    signal_dspin_bound_rsp_in [x][y][face].read  = true;
1143                    signal_dspin_bound_rsp_out[x][y][face].write = false;
1144                    signal_dspin_bound_rsp_out[x][y][face].read  = true;
1145                }
1146
1147                signal_dspin_bound_m2p_in [x][y][face].write = false;
1148                signal_dspin_bound_m2p_in [x][y][face].read  = true;
1149                signal_dspin_bound_m2p_out[x][y][face].write = false;
1150                signal_dspin_bound_m2p_out[x][y][face].read  = true;
1151
1152                signal_dspin_bound_p2m_in [x][y][face].write = false;
1153                signal_dspin_bound_p2m_in [x][y][face].read  = true;
1154                signal_dspin_bound_p2m_out[x][y][face].write = false;
1155                signal_dspin_bound_p2m_out[x][y][face].read  = true;
1156
1157                signal_dspin_bound_cla_in [x][y][face].write = false;
1158                signal_dspin_bound_cla_in [x][y][face].read  = true;
1159                signal_dspin_bound_cla_out[x][y][face].write = false;
1160                signal_dspin_bound_cla_out[x][y][face].read  = true;
1161            }
1162        }
1163    }
1164
1165#if USE_PIC == 0
1166    signal_dspin_bound_cmd_in[XMAX-1][YMAX-1][NORTH].write = false;
1167    signal_dspin_bound_rsp_out[XMAX-1][YMAX-1][NORTH].read = true;
1168    signal_dspin_bound_cmd_out[XMAX-1][YMAX-1][NORTH].read = true;
1169    signal_dspin_bound_rsp_in[XMAX-1][YMAX-1][NORTH].write = false;
1170#endif
1171
1172    // set default values for VCI signals connected to unused ports on iobus
1173    signal_vci_tgt_memc.rspval = false;
1174    signal_vci_tgt_xicu.rspval = false;
1175    for ( size_t p = 0 ; p < NB_PROCS_MAX ; p++ ) signal_vci_ini_proc[p].cmdval = false;
1176
1177    sc_start(sc_core::sc_time(1, SC_NS));
1178    signal_resetn = true;
1179
1180    if (gettimeofday(&t1, NULL) != 0)
1181    {
1182        perror("gettimeofday");
1183        return EXIT_FAILURE;
1184    }
1185
1186    // simulation loop
1187    for (uint64_t n = 1; n < ncycles && !stop_called; n++)
1188    {
1189        // Monitor a specific address for L1 cache
1190        // clusters[0][0]->proc[0]->cache_monitor(0x110002C078ULL);
1191
1192        // Monitor a specific address for L2 cache
1193        // clusters[0][0]->memc->cache_monitor( 0x0000201E00ULL );
1194
1195        // Monitor a specific address for one XRAM
1196        // clusters[0][0]->xram->start_monitor( 0x0000201E00ULL , 64);
1197
1198        // stats display
1199        if( (n % 5000000) == 0)
1200        {
1201
1202            if (gettimeofday(&t2, NULL) != 0)
1203            {
1204                perror("gettimeofday");
1205                return EXIT_FAILURE;
1206            }
1207
1208            ms1 = (uint64_t) t1.tv_sec * 1000ULL + (uint64_t) t1.tv_usec / 1000;
1209            ms2 = (uint64_t) t2.tv_sec * 1000ULL + (uint64_t) t2.tv_usec / 1000;
1210            std::cerr << "platform clock frequency "
1211                      << (double) 5000000 / (double) (ms2 - ms1) << "Khz" << std::endl;
1212
1213            if (gettimeofday(&t1, NULL) != 0)
1214            {
1215                perror("gettimeofday");
1216                return EXIT_FAILURE;
1217            }
1218        }
1219
1220        // trace display
1221        if ( trace_ok and (n > trace_from) )
1222        {
1223            std::cout << "****************** cycle " << std::dec << n ;
1224            std::cout << " ********************************************" << std::endl;
1225
1226            size_t l = 0;
1227            size_t x = 0;
1228            size_t y = 0;
1229
1230            if ( trace_proc_ok )
1231            {
1232                l = trace_proc_id & ((1<<P_WIDTH)-1) ;
1233                x = (trace_proc_id >> P_WIDTH) >> Y_WIDTH ;
1234                y = (trace_proc_id >> P_WIDTH) & ((1<<Y_WIDTH) - 1);
1235
1236                std::ostringstream proc_signame;
1237                proc_signame << "[SIG]PROC_" << x << "_" << y << "_" << l ;
1238                clusters[x][y]->proc[l]->print_trace(1);
1239                clusters[x][y]->signal_vci_ini_proc[l].print_trace(proc_signame.str());
1240
1241                std::ostringstream xicu_signame;
1242                xicu_signame << "[SIG]XICU_" << x << "_" << y ;
1243                clusters[x][y]->xicu->print_trace(0);
1244                clusters[x][y]->signal_vci_tgt_xicu.print_trace(xicu_signame.str());
1245               
1246                if ( clusters[x][y]->signal_proc_irq[0] ) 
1247                   std::cout << "### IRQ_PROC_" << x << "_" << y << "_0" << std::endl;
1248                if ( clusters[x][y]->signal_proc_irq[4] ) 
1249                   std::cout << "### IRQ_PROC_" << x << "_" << y << "_1" << std::endl;
1250                if ( clusters[x][y]->signal_proc_irq[8] ) 
1251                   std::cout << "### IRQ_PROC_" << x << "_" << y << "_2" << std::endl;
1252                if ( clusters[x][y]->signal_proc_irq[12] ) 
1253                   std::cout << "### IRQ_PROC_" << x << "_" << y << "_3" << std::endl;
1254            }
1255
1256            if ( trace_memc_ok )
1257            {
1258                x = trace_memc_id >> Y_WIDTH;
1259                y = trace_memc_id & ((1<<Y_WIDTH) - 1);
1260
1261                std::ostringstream smemc;
1262                smemc << "[SIG]MEMC_" << x << "_" << y;
1263                std::ostringstream sxram;
1264                sxram << "[SIG]XRAM_" << x << "_" << y;
1265
1266                clusters[x][y]->memc->print_trace();
1267                clusters[x][y]->signal_vci_tgt_memc.print_trace(smemc.str());
1268                clusters[x][y]->signal_vci_xram.print_trace(sxram.str());
1269            }
1270
1271            // trace coherence signals
1272            // clusters[0][0]->signal_dspin_m2p_proc[0].print_trace("[CC_M2P_0_0]");
1273            // clusters[0][1]->signal_dspin_m2p_proc[0].print_trace("[CC_M2P_0_1]");
1274            // clusters[1][0]->signal_dspin_m2p_proc[0].print_trace("[CC_M2P_1_0]");
1275            // clusters[1][1]->signal_dspin_m2p_proc[0].print_trace("[CC_M2P_1_1]");
1276
1277            // clusters[0][0]->signal_dspin_p2m_proc[0].print_trace("[CC_P2M_0_0]");
1278            // clusters[0][1]->signal_dspin_p2m_proc[0].print_trace("[CC_P2M_0_1]");
1279            // clusters[1][0]->signal_dspin_p2m_proc[0].print_trace("[CC_P2M_1_0]");
1280            // clusters[1][1]->signal_dspin_p2m_proc[0].print_trace("[CC_P2M_1_1]");
1281
1282            // trace xbar(s) m2p
1283            // clusters[0][0]->xbar_m2p->print_trace();
1284            // clusters[1][0]->xbar_m2p->print_trace();
1285            // clusters[0][1]->xbar_m2p->print_trace();
1286            // clusters[1][1]->xbar_m2p->print_trace();
1287
1288            // trace router(s) m2p
1289            // clusters[0][0]->router_m2p->print_trace();
1290            // clusters[1][0]->router_m2p->print_trace();
1291            // clusters[0][1]->router_m2p->print_trace();
1292            // clusters[1][1]->router_m2p->print_trace();
1293
1294#if ( USE_IOC_HBA or USE_IOC_BDV or USE_IOC_SDC )
1295#if USE_PIC
1296            // trace external ioc
1297            disk->print_trace();
1298            signal_vci_tgt_disk.print_trace("[SIG]DISK_TGT");
1299            signal_vci_ini_disk.print_trace("[SIG]DISK_INI");
1300
1301            // trace external iopic
1302            iopic->print_trace();
1303            signal_vci_tgt_iopi.print_trace("[SIG]IOPI_TGT");
1304            signal_vci_ini_iopi.print_trace("[SIG]IOPI_INI");
1305
1306            // trace external interrupts
1307            if (signal_irq_disk)   std::cout << "### IRQ_DISK" << std::endl;
1308#else
1309            clusters[0][0]->disk->print_trace();
1310            clusters[0][0]->signal_vci_tgt_disk.print_trace("[SIG]DISK_0_0");
1311            clusters[0][0]->signal_vci_ini_disk.print_trace("[SIG]DISK_0_0");
1312#endif
1313#endif
1314
1315        }  // end trace
1316
1317        sc_start(sc_core::sc_time(1, SC_NS));
1318    }
1319    // Free memory
1320    for (size_t i = 0 ; i  < (XMAX * YMAX) ; i++)
1321    {
1322        size_t x = i / (YMAX);
1323        size_t y = i % (YMAX);
1324        delete clusters[x][y];
1325    }
1326
1327    return EXIT_SUCCESS;
1328}
1329
1330void handler(int dummy = 0)
1331{
1332   stop_called = true;
1333   sc_stop();
1334}
1335
1336void voidhandler(int dummy = 0) {}
1337
1338int sc_main (int argc, char *argv[])
1339{
1340   signal(SIGINT, handler);
1341   signal(SIGPIPE, voidhandler);
1342
1343   try {
1344      return _main(argc, argv);
1345   } catch (std::exception &e) {
1346      std::cout << e.what() << std::endl;
1347   } catch (...) {
1348      std::cout << "Unknown exception occured" << std::endl;
1349      throw;
1350   }
1351   return 1;
1352}
1353
1354
1355// Local Variables:
1356// tab-width: 3
1357// c-basic-offset: 3
1358// c-file-offsets:((innamespace . 0)(inline-open . 0))
1359// indent-tabs-mode: nil
1360// End:
1361
1362// vim: filetype=cpp:expandtab:shiftwidth=3:tabstop=3:softtabstop=3
Note: See TracBrowser for help on using the repository browser.