source: trunk/platforms/tsar_generic_xbar/top.cpp @ 734

Last change on this file since 734 was 706, checked in by meunier, 10 years ago
  • Replaced vci_dspin_local_crossbar with a vci_local_crossbar in tsar_generic_xbar
  • Added the scripts/ directory in tsar_generic_xbar
File size: 42.4 KB
RevLine 
[344]1/////////////////////////////////////////////////////////////////////////
2// File: top.cpp
3// Author: Alain Greiner
4// Copyright: UPMC/LIP6
[396]5// Date : may 2013
[344]6// This program is released under the GNU public license
7/////////////////////////////////////////////////////////////////////////
[396]8// This file define a generic TSAR architecture.
9// The physical address space is 40 bits.
10//
[344]11// The number of clusters cannot be larger than 256.
12// The number of processors per cluster cannot be larger than 8.
13//
14// - It uses four dspin_local_crossbar per cluster as local interconnect
15// - It uses two virtual_dspin routers per cluster as global interconnect
16// - It uses the vci_cc_vcache_wrapper
17// - It uses the vci_mem_cache
[396]18// - It contains one vci_xicu per cluster.
19// - It contains one vci_multi_dma per cluster.
20// - It contains one vci_simple_ram per cluster to model the L3 cache.
[344]21//
[396]22// The communication between the MemCache and the Xram is 64 bits.
23//
24// All clusters are identical, but the cluster 0 (called io_cluster),
[493]25// contains 6 extra components:
[344]26// - the boot rom (BROM)
27// - the disk controller (BDEV)
28// - the multi-channel network controller (MNIC)
[493]29// - the multi-channel chained buffer dma controller (CDMA)
[344]30// - the multi-channel tty controller (MTTY)
31// - the frame buffer controller (FBUF)
32//
[396]33// It is build with one single component implementing a cluster,
34// defined in files tsar_xbar_cluster.* (with * = cpp, h, sd)
[344]35//
36// The IRQs are connected to XICUs as follow:
37// - The IRQ_IN[0] to IRQ_IN[7] ports are not used in all clusters.
38// - The DMA IRQs are connected to IRQ_IN[8] to IRQ_IN[15] in all clusters.
39// - The TTY IRQs are connected to IRQ_IN[16] to IRQ_IN[30] in I/O cluster.
40// - The BDEV IRQ is connected to IRQ_IN[31] in I/O cluster.
41//
[396]42// Some hardware parameters are used when compiling the OS, and are used
43// by this top.cpp file. They must be defined in the hard_config.h file :
[344]44// - CLUSTER_X        : number of clusters in a row (power of 2)
45// - CLUSTER_Y        : number of clusters in a column (power of 2)
46// - CLUSTER_SIZE     : size of the segment allocated to a cluster
47// - NB_PROCS_MAX     : number of processors per cluster (power of 2)
[438]48// - NB_DMA_CHANNELS  : number of DMA channels per cluster (< 9)
49// - NB_TTY_CHANNELS  : number of TTY channels in I/O cluster (< 16)
50// - NB_NIC_CHANNELS  : number of NIC channels in I/O cluster (< 9)
[344]51//
[396]52// Some other hardware parameters are not used when compiling the OS,
53// and can be directly defined in this top.cpp file:
[344]54// - XRAM_LATENCY     : external ram latency
55// - MEMC_WAYS        : L2 cache number of ways
56// - MEMC_SETS        : L2 cache number of sets
57// - L1_IWAYS     
58// - L1_ISETS   
59// - L1_DWAYS   
60// - L1_DSETS 
61// - FBUF_X_SIZE      : width of frame buffer (pixels)
62// - FBUF_Y_SIZE      : heigth of frame buffer (lines)
63// - BDEV_SECTOR_SIZE : block size for block drvice
64// - BDEV_IMAGE_NAME  : file pathname for block device
65// - NIC_RX_NAME      : file pathname for NIC received packets
66// - NIC_TX_NAME      : file pathname for NIC transmited packets
67// - NIC_TIMEOUT      : max number of cycles before closing a container
[396]68/////////////////////////////////////////////////////////////////////////
69// General policy for 40 bits physical address decoding:
70// All physical segments base addresses are multiple of 1 Mbytes
71// (=> the 24 LSB bits = 0, and the 16 MSB bits define the target)
[344]72// The (x_width + y_width) MSB bits (left aligned) define
[396]73// the cluster index, and the LADR bits define the local index:
[344]74//      | X_ID  | Y_ID  |---| LADR |     OFFSET          |
[396]75//      |x_width|y_width|---|  8   |       24            |
[344]76/////////////////////////////////////////////////////////////////////////
[396]77// General policy for 14 bits SRCID decoding:
78// Each component is identified by (x_id, y_id, l_id) tuple.
79//      | X_ID  | Y_ID  |---| L_ID |
80//      |x_width|y_width|---|  6   |
81/////////////////////////////////////////////////////////////////////////
[344]82
83#include <systemc>
84#include <sys/time.h>
85#include <iostream>
86#include <sstream>
87#include <cstdlib>
88#include <cstdarg>
89#include <stdint.h>
90
91#include "gdbserver.h"
92#include "mapping_table.h"
[663]93#include "alloc_elems.h"
[378]94#include "tsar_xbar_cluster.h"
[344]95
[663]96#define USE_ALMOS 1
97//#define USE_GIET
[344]98
[464]99#ifdef USE_ALMOS
100#ifdef USE_GIET
101#error "Can't use Two different OS"
102#endif
103#endif
104
105#ifndef USE_ALMOS
106#ifndef USE_GIET
107#error "You need to specify one OS"
108#endif
109#endif
110
[663]111#ifdef USE_ALMOS
112   #define PREFIX_OS "almos/"
113   #include "almos/hard_config.h"
114#endif
115#ifdef USE_GIET
116   #define PREFIX_OS "giet_vm/"
117#endif
118
[344]119///////////////////////////////////////////////////
120//               Parallelisation
121///////////////////////////////////////////////////
[663]122
[504]123#define USE_OPENMP 0
[344]124
125#if USE_OPENMP
126#include <omp.h>
127#endif
128
129//  cluster index (computed from x,y coordinates)
[619]130#ifdef USE_ALMOS
[663]131   #define cluster(x,y)   (y + x * Y_SIZE)
[619]132#else
[663]133   #define cluster(x,y)   (y + (x << Y_WIDTH))
[619]134#endif
[344]135
[619]136
[547]137#define min(x, y) (x < y ? x : y)
138
[344]139///////////////////////////////////////////////////////////
140//          DSPIN parameters           
141///////////////////////////////////////////////////////////
142
[404]143#define dspin_cmd_width      39
144#define dspin_rsp_width      32
[344]145
[396]146///////////////////////////////////////////////////////////
147//          VCI parameters           
148///////////////////////////////////////////////////////////
149
[438]150#define vci_cell_width_int    4
151#define vci_cell_width_ext    8
[396]152
[504]153#ifdef USE_ALMOS
154#define vci_address_width     32
155#endif
156#ifdef USE_GIET
157#define vci_address_width     40
158#endif
[438]159#define vci_plen_width        8
160#define vci_rerror_width      1
161#define vci_clen_width        1
162#define vci_rflag_width       1
163#define vci_srcid_width       14
164#define vci_pktid_width       4
165#define vci_trdid_width       4
166#define vci_wrplen_width      1
[493]167
[344]168////////////////////////////////////////////////////////////
[396]169//    Secondary Hardware Parameters         
[344]170//////////////////////i/////////////////////////////////////
171
[438]172
[344]173#define XRAM_LATENCY          0
174
175#define MEMC_WAYS             16
176#define MEMC_SETS             256
177
178#define L1_IWAYS              4
179#define L1_ISETS              64
180
181#define L1_DWAYS              4
182#define L1_DSETS              64
183
[464]184#ifdef USE_ALMOS
[663]185#define FBUF_X_SIZE           1024
186#define FBUF_Y_SIZE           1024
[464]187#endif
188#ifdef USE_GIET
[344]189#define FBUF_X_SIZE           128
190#define FBUF_Y_SIZE           128
[464]191#endif
[344]192
[464]193#ifdef USE_GIET
[344]194#define BDEV_SECTOR_SIZE      512
[468]195#define BDEV_IMAGE_NAME       PREFIX_OS"display/images.raw"
[464]196#endif
197#ifdef USE_ALMOS
198#define BDEV_SECTOR_SIZE      4096
199#define BDEV_IMAGE_NAME       PREFIX_OS"hdd-img.bin"
200#endif
[344]201
[464]202#define NIC_RX_NAME           PREFIX_OS"nic/rx_packets.txt"
203#define NIC_TX_NAME           PREFIX_OS"nic/tx_packets.txt"
[344]204#define NIC_TIMEOUT           10000
205
[438]206#define NORTH                 0
207#define SOUTH                 1
208#define EAST                  2
209#define WEST                  3
210
[344]211////////////////////////////////////////////////////////////
212//    Software to be loaded in ROM & RAM         
213//////////////////////i/////////////////////////////////////
214
[464]215#ifdef USE_ALMOS
[663]216#define soft_name       PREFIX_OS"bootloader-tsar-mipsel.bin",\
[468]217                        PREFIX_OS"kernel-soclib.bin@0xbfc10000:D",\
218                        PREFIX_OS"arch-info.bib@0xBFC08000:D"
[464]219#endif
220#ifdef USE_GIET
[468]221#define soft_pathname   PREFIX_OS"soft.elf"
[464]222#endif
[344]223
224////////////////////////////////////////////////////////////
225//     DEBUG Parameters default values         
226//////////////////////i/////////////////////////////////////
227
[663]228#define MAX_FROZEN_CYCLES     100000000
[344]229
[572]230
231////////////////////////////////////////////////////////////////////
232//     TGTID definition in direct space
233// For all components:  global TGTID = global SRCID = cluster_index
234////////////////////////////////////////////////////////////////////
235
236#define MEMC_TGTID      0
237#define XICU_TGTID      1
238#define MDMA_TGTID      2
239#define MTTY_TGTID      3
[663]240#define BDEV_TGTID      4
241#define MNIC_TGTID      5
242#define BROM_TGTID      6
243#define CDMA_TGTID      7
244#define SIMH_TGTID      8
245#define FBUF_TGTID      9
[572]246
247
[344]248/////////////////////////////////////////////////////////
249//    Physical segments definition
250/////////////////////////////////////////////////////////
251// There is 3 segments replicated in all clusters
252// and 5 specific segments in the "IO" cluster
253// (containing address 0xBF000000)
254/////////////////////////////////////////////////////////
255
[547]256#ifdef USE_GIET
257   // specific segments in "IO" cluster : absolute physical address
258   #define BROM_BASE    0x00BFC00000
259   #define BROM_SIZE    0x0000100000   // 1 Mbytes
[344]260
[547]261   #define FBUF_BASE    0x00B2000000
262   #define FBUF_SIZE    (FBUF_X_SIZE * FBUF_Y_SIZE * 2)
[344]263
[547]264   #define BDEV_BASE    0x00B3000000
265   #define BDEV_SIZE    0x0000001000   // 4 Kbytes
[344]266
[547]267   #define MTTY_BASE    0x00B4000000
268   #define MTTY_SIZE    0x0000001000   // 4 Kbytes
[344]269
[547]270   #define MNIC_BASE    0x00B5000000
271   #define MNIC_SIZE    0x0000080000   // 512 Kbytes (for 8 channels)
[344]272
[547]273   #define CDMA_BASE    0x00B6000000
274   #define CDMA_SIZE    0x0000004000 * NB_CMA_CHANNELS
[344]275
[547]276   // replicated segments : address is incremented by a cluster offset
277   //     offset  = cluster(x,y) << (address_width-x_width-y_width);
[475]278
[547]279   #define MEMC_BASE    0x0000000000
280   #define MEMC_SIZE    0x0010000000   // 256 Mbytes per cluster
[344]281
[547]282   #define XICU_BASE    0x00B0000000
283   #define XICU_SIZE    0x0000001000   // 4 Kbytes
[344]284
[547]285   #define MDMA_BASE    0x00B1000000
286   #define MDMA_SIZE    0x0000001000 * NB_DMA_CHANNELS  // 4 Kbytes per channel
287
288   #define SIMH_BASE    0x00B7000000
289   #define SIMH_SIZE    0x0000001000
[504]290#endif
[344]291
[504]292#ifdef USE_ALMOS
[572]293   // 2^19 is the offset for the local id (8 bits for global ID :
294   // 1 bit for Memcache or Peripheral, 4 for local peripheral id)
295   // (Almos supports 32 bits physical addresses)
[547]296
[706]297   #define CLUSTER_INC (0x80000000ULL / (X_SIZE * Y_SIZE) * 2)
[547]298
[706]299   #define CLUSTER_IO_INC (cluster_io_id * CLUSTER_INC)
300   #define MEMC_MAX_SIZE (0x40000000 / (X_SIZE * Y_SIZE)) // 0x40000000 : valeur totale souhaitée (ici : 1Go)
301
[547]302   #define BROM_BASE    0x00BFC00000
[706]303   #define BROM_SIZE    0x0000100000 // 1 Mbytes
[547]304
[572]305   #define MEMC_BASE    0x0000000000
[663]306   #define MEMC_SIZE    min(0x04000000, MEMC_MAX_SIZE)
[572]307
[706]308   #define XICU_BASE    (CLUSTER_INC >> 1) + (XICU_TGTID << 19)
309   #define XICU_SIZE    0x0000001000 // 4 Kbytes
[572]310   
[706]311   #define MDMA_BASE    (CLUSTER_INC >> 1) + (MDMA_TGTID << 19)
312   #define MDMA_SIZE    (0x0000001000 * NB_DMA_CHANNELS) // 4 Kbytes per channel 
[547]313
[706]314   #define BDEV_BASE    (CLUSTER_INC >> 1) + (BDEV_TGTID << 19) + (CLUSTER_IO_INC)
315   #define BDEV_SIZE    0x0000001000 // 4 Kbytes
[663]316
[706]317   #define MTTY_BASE    (CLUSTER_INC >> 1) + (MTTY_TGTID << 19) + (CLUSTER_IO_INC)
318   #define MTTY_SIZE    0x0000001000 // 4 Kbytes
[663]319
[706]320   #define FBUF_BASE    (CLUSTER_INC >> 1) + (FBUF_TGTID << 19) + (CLUSTER_IO_INC)
[547]321   #define FBUF_SIZE    (FBUF_X_SIZE * FBUF_Y_SIZE * 2) // Should be 0x80000
[663]322
[706]323   #define MNIC_BASE    (CLUSTER_INC >> 1) + (MNIC_TGTID << 19) + (CLUSTER_IO_INC)
[572]324   #define MNIC_SIZE    0x0000080000
[663]325
[706]326   #define CDMA_BASE    (CLUSTER_INC >> 1) + (CDMA_TGTID << 19) + (CLUSTER_IO_INC)
[572]327   #define CDMA_SIZE    (0x0000004000 * NB_CMA_CHANNELS)
[663]328
[706]329   #define SIMH_BASE    (CLUSTER_INC >> 1) + (SIMH_TGTID << 19) + (CLUSTER_IO_INC)
[572]330   #define SIMH_SIZE    0x0000001000
[504]331#endif
[344]332
[504]333bool stop_called = false;
334
[344]335/////////////////////////////////
336int _main(int argc, char *argv[])
337{
338   using namespace sc_core;
339   using namespace soclib::caba;
340   using namespace soclib::common;
341
[464]342#ifdef USE_GIET
[663]343   char     soft_name[256]    = soft_pathname;      // pathname to binary code
[464]344#endif
[663]345   const int64_t max_cycles   = 5000000;             // Maximum number of cycles simulated in one sc_start call
346   int64_t ncycles            = 0x7FFFFFFFFFFFFFFF;  // simulated cycles
347   char     disk_name[256]    = BDEV_IMAGE_NAME;    // pathname to the disk image
348   char     nic_rx_name[256]  = NIC_RX_NAME;        // pathname to the rx packets file
349   char     nic_tx_name[256]  = NIC_TX_NAME;        // pathname to the tx packets file
350   ssize_t  threads_nr        = 1;                  // simulator's threads number
351   bool     debug_ok          = false;              // trace activated
352   size_t   debug_period      = 1;                  // trace period
353   size_t   debug_memc_id     = 0;                  // index of memc to be traced
354   size_t   debug_proc_id     = 0;                  // index of proc to be traced
355   int64_t  debug_from        = 0;                  // trace start cycle
356   int64_t  frozen_cycles     = MAX_FROZEN_CYCLES;  // monitoring frozen processor
[504]357   size_t   cluster_io_id;                         // index of cluster containing IOs
[663]358   int64_t  reset_counters    = -1;
359   int64_t  dump_counters     = -1;
360   bool     do_reset_counters = false;
361   bool     do_dump_counters  = false;
362   struct   timeval t1, t2;
363   uint64_t ms1, ms2;
[344]364
365   ////////////// command line arguments //////////////////////
366   if (argc > 1)
367   {
368      for (int n = 1; n < argc; n = n + 2)
369      {
[504]370         if ((strcmp(argv[n], "-NCYCLES") == 0) && (n + 1 < argc))
[344]371         {
[663]372            ncycles = (int64_t) strtol(argv[n + 1], NULL, 0);
[344]373         }
[504]374         else if ((strcmp(argv[n], "-SOFT") == 0) && (n + 1 < argc))
[344]375         {
[464]376#ifdef USE_ALMOS
377            assert( 0 && "Can't define almos soft name" );
378#endif
379#ifdef USE_GIET
[504]380            strcpy(soft_name, argv[n + 1]);
[464]381#endif
[344]382         }
[504]383         else if ((strcmp(argv[n],"-DISK") == 0) && (n + 1 < argc))
[344]384         {
[504]385            strcpy(disk_name, argv[n + 1]);
[344]386         }
[504]387         else if ((strcmp(argv[n],"-DEBUG") == 0) && (n + 1 < argc))
[344]388         {
389            debug_ok = true;
[663]390            debug_from = (int64_t) strtol(argv[n + 1], NULL, 0);
[344]391         }
[504]392         else if ((strcmp(argv[n], "-MEMCID") == 0) && (n + 1 < argc))
[344]393         {
[619]394            debug_memc_id = (size_t) strtol(argv[n + 1], NULL, 0);
395#ifdef USE_ALMOS
[663]396            assert((debug_memc_id < (X_SIZE * Y_SIZE)) &&
397                   "debug_memc_id larger than X_SIZE * Y_SIZE" );
[619]398#else
399            size_t x = debug_memc_id >> Y_WIDTH;
400            size_t y = debug_memc_id & ((1<<Y_WIDTH)-1);
401
[663]402            assert( (x <= X_SIZE) and (y <= Y_SIZE) &&
[619]403                  "MEMCID parameter refers a not valid memory cache");
404#endif
[344]405         }
[504]406         else if ((strcmp(argv[n], "-PROCID") == 0) && (n + 1 < argc))
[344]407         {
[619]408            debug_proc_id = (size_t) strtol(argv[n + 1], NULL, 0);
409#ifdef USE_ALMOS
[663]410            assert((debug_proc_id < (X_SIZE * Y_SIZE * NB_PROCS_MAX)) && 
411                   "debug_proc_id larger than X_SIZE * Y_SIZE * NB_PROCS");
[619]412#else
413            size_t cluster_xy = debug_proc_id / NB_PROCS_MAX ;
414            size_t x          = cluster_xy >> Y_WIDTH;
415            size_t y          = cluster_xy & ((1<<Y_WIDTH)-1);
416
[663]417            assert( (x <= X_SIZE) and (y <= Y_SIZE) &&
[619]418                  "PROCID parameter refers a not valid processor");
419#endif
[344]420         }
[504]421         else if ((strcmp(argv[n], "-THREADS") == 0) && ((n + 1) < argc))
[344]422         {
[619]423            threads_nr = (ssize_t) strtol(argv[n + 1], NULL, 0);
[344]424            threads_nr = (threads_nr < 1) ? 1 : threads_nr;
425         }
[504]426         else if ((strcmp(argv[n], "-FROZEN") == 0) && (n + 1 < argc))
[344]427         {
[663]428            frozen_cycles = (int64_t) strtol(argv[n + 1], NULL, 0);
[344]429         }
[504]430         else if ((strcmp(argv[n], "-PERIOD") == 0) && (n + 1 < argc))
[344]431         {
[619]432            debug_period = (size_t) strtol(argv[n + 1], NULL, 0);
[344]433         }
[663]434         else if ((strcmp(argv[n], "--reset-counters") == 0) && (n + 1 < argc))
435         {
436            reset_counters = (int64_t) strtol(argv[n + 1], NULL, 0);
437            do_reset_counters = true;
438         }
439         else if ((strcmp(argv[n], "--dump-counters") == 0) && (n + 1 < argc))
440         {
441            dump_counters = (int64_t) strtol(argv[n + 1], NULL, 0);
442            do_dump_counters = true;
443         }
[344]444         else
445         {
446            std::cout << "   Arguments are (key,value) couples." << std::endl;
447            std::cout << "   The order is not important." << std::endl;
448            std::cout << "   Accepted arguments are :" << std::endl << std::endl;
449            std::cout << "     -SOFT pathname_for_embedded_soft" << std::endl;
450            std::cout << "     -DISK pathname_for_disk_image" << std::endl;
451            std::cout << "     -NCYCLES number_of_simulated_cycles" << std::endl;
452            std::cout << "     -DEBUG debug_start_cycle" << std::endl;
453            std::cout << "     -THREADS simulator's threads number" << std::endl;
454            std::cout << "     -FROZEN max_number_of_lines" << std::endl;
455            std::cout << "     -PERIOD number_of_cycles between trace" << std::endl;
456            std::cout << "     -MEMCID index_memc_to_be_traced" << std::endl;
457            std::cout << "     -PROCID index_proc_to_be_traced" << std::endl;
458            exit(0);
459         }
460      }
461   }
462
[396]463    // checking hardware parameters
[663]464    assert( ( (X_SIZE == 1) or (X_SIZE == 2) or (X_SIZE == 4) or
465              (X_SIZE == 8) or (X_SIZE == 16) ) and
466              "The X_SIZE parameter must be 1, 2, 4, 8 or 16" );
[344]467
[663]468    assert( ( (Y_SIZE == 1) or (Y_SIZE == 2) or (Y_SIZE == 4) or
469              (Y_SIZE == 8) or (Y_SIZE == 16) ) and
470              "The Y_SIZE parameter must be 1, 2, 4, 8 or 16" );
[344]471
[396]472    assert( ( (NB_PROCS_MAX == 1) or (NB_PROCS_MAX == 2) or
473              (NB_PROCS_MAX == 4) or (NB_PROCS_MAX == 8) ) and
474             "The NB_PROCS_MAX parameter must be 1, 2, 4 or 8" );
[344]475
[396]476    assert( (NB_DMA_CHANNELS < 9) and
477            "The NB_DMA_CHANNELS parameter must be smaller than 9" );
[344]478
[396]479    assert( (NB_TTY_CHANNELS < 15) and
480            "The NB_TTY_CHANNELS parameter must be smaller than 15" );
[344]481
[396]482    assert( (NB_NIC_CHANNELS < 9) and
483            "The NB_NIC_CHANNELS parameter must be smaller than 9" );
[344]484
[464]485#ifdef USE_GIET
[438]486    assert( (vci_address_width == 40) and
[504]487            "VCI address width with the GIET must be 40 bits" );
[464]488#endif
[344]489
[504]490#ifdef USE_ALMOS
491    assert( (vci_address_width == 32) and
492            "VCI address width with ALMOS must be 32 bits" );
493#endif
494
495
[396]496    std::cout << std::endl;
[663]497    std::cout << " - X_SIZE             = " << X_SIZE << std::endl;
498    std::cout << " - Y_SIZE             = " << Y_SIZE << std::endl;
[438]499    std::cout << " - NB_PROCS_MAX     = " << NB_PROCS_MAX <<  std::endl;
[396]500    std::cout << " - NB_DMA_CHANNELS  = " << NB_DMA_CHANNELS <<  std::endl;
[438]501    std::cout << " - NB_TTY_CHANNELS  = " << NB_TTY_CHANNELS <<  std::endl;
502    std::cout << " - NB_NIC_CHANNELS  = " << NB_NIC_CHANNELS <<  std::endl;
503    std::cout << " - MEMC_WAYS        = " << MEMC_WAYS << std::endl;
504    std::cout << " - MEMC_SETS        = " << MEMC_SETS << std::endl;
505    std::cout << " - RAM_LATENCY      = " << XRAM_LATENCY << std::endl;
506    std::cout << " - MAX_FROZEN       = " << frozen_cycles << std::endl;
[396]507
508    std::cout << std::endl;
509    // Internal and External VCI parameters definition
[438]510    typedef soclib::caba::VciParams<vci_cell_width_int,
511                                    vci_plen_width,
512                                    vci_address_width,
513                                    vci_rerror_width,
514                                    vci_clen_width,
515                                    vci_rflag_width,
516                                    vci_srcid_width,
517                                    vci_pktid_width,
518                                    vci_trdid_width,
519                                    vci_wrplen_width> vci_param_int;
[396]520
[438]521    typedef soclib::caba::VciParams<vci_cell_width_ext,
522                                    vci_plen_width,
523                                    vci_address_width,
524                                    vci_rerror_width,
525                                    vci_clen_width,
526                                    vci_rflag_width,
527                                    vci_srcid_width,
528                                    vci_pktid_width,
529                                    vci_trdid_width,
530                                    vci_wrplen_width> vci_param_ext;
[396]531
[344]532#if USE_OPENMP
533   omp_set_dynamic(false);
534   omp_set_num_threads(threads_nr);
535   std::cerr << "Built with openmp version " << _OPENMP << std::endl;
536#endif
537
[663]538   // Define parameters depending on mesh size
539   size_t   x_width;
540   size_t   y_width;
541
[619]542#ifdef USE_ALMOS
[663]543   if      (X_SIZE == 1) x_width = 0;
544   else if (X_SIZE == 2) x_width = 1;
545   else if (X_SIZE <= 4) x_width = 2;
546   else if (X_SIZE <= 8) x_width = 3;
[504]547   else                x_width = 4;
[344]548
[663]549   if      (Y_SIZE == 1) y_width = 0;
550   else if (Y_SIZE == 2) y_width = 1;
551   else if (Y_SIZE <= 4) y_width = 2;
552   else if (Y_SIZE <= 8) y_width = 3;
[504]553   else                y_width = 4;
[344]554
[619]555#else
556   size_t x_width = X_WIDTH;
557   size_t y_width = Y_WIDTH;
558
559   assert( (X_WIDTH <= 4) and (Y_WIDTH <= 4) and
560           "Up to 256 clusters");
561
[663]562   assert( (X_SIZE <= (1 << X_WIDTH)) and (Y_SIZE <= (1 << Y_WIDTH)) and
[619]563           "The X_WIDTH and Y_WIDTH parameter are insufficient");
564
[504]565#endif
566
[619]567   // index of cluster containing IOs
568   cluster_io_id = 0x00bfc00000ULL >> (vci_address_width - x_width - y_width);
569
[663]570
[344]571   /////////////////////
572   //  Mapping Tables
573   /////////////////////
574
[396]575   // internal network
[438]576   MappingTable maptabd(vci_address_width, 
[572]577                        IntTab(x_width + y_width, 16 - x_width - y_width), 
[438]578                        IntTab(x_width + y_width, vci_srcid_width - x_width - y_width), 
[547]579                        0x00FF800000);
[344]580
[663]581   for (size_t x = 0; x < X_SIZE; x++)
[344]582   {
[663]583      for (size_t y = 0; y < Y_SIZE; y++)
[344]584      {
[438]585         sc_uint<vci_address_width> offset;
586         offset = (sc_uint<vci_address_width>)cluster(x,y) 
587                   << (vci_address_width-x_width-y_width);
[344]588
589         std::ostringstream    si;
[396]590         si << "seg_xicu_" << x << "_" << y;
[547]591         maptabd.add(Segment(si.str(), XICU_BASE + offset, XICU_SIZE, 
592                  IntTab(cluster(x,y),XICU_TGTID), false));
[344]593
594         std::ostringstream    sd;
[396]595         sd << "seg_mdma_" << x << "_" << y;
[547]596         maptabd.add(Segment(sd.str(), MDMA_BASE + offset, MDMA_SIZE, 
597                  IntTab(cluster(x,y),MDMA_TGTID), false));
[344]598
[547]599         std::ostringstream    sh;
600         sh << "seg_memc_" << x << "_" << y;
601         maptabd.add(Segment(sh.str(), MEMC_BASE + offset, MEMC_SIZE, 
602                  IntTab(cluster(x,y),MEMC_TGTID), true));
603
[344]604         if ( cluster(x,y) == cluster_io_id )
605         {
[396]606            maptabd.add(Segment("seg_mtty", MTTY_BASE, MTTY_SIZE, 
607                        IntTab(cluster(x,y),MTTY_TGTID), false));
608            maptabd.add(Segment("seg_fbuf", FBUF_BASE, FBUF_SIZE, 
609                        IntTab(cluster(x,y),FBUF_TGTID), false));
610            maptabd.add(Segment("seg_bdev", BDEV_BASE, BDEV_SIZE, 
611                        IntTab(cluster(x,y),BDEV_TGTID), false));
[547]612            maptabd.add(Segment("seg_brom", BROM_BASE, BROM_SIZE, 
613                        IntTab(cluster(x,y),BROM_TGTID), true));
[396]614            maptabd.add(Segment("seg_mnic", MNIC_BASE, MNIC_SIZE, 
615                        IntTab(cluster(x,y),MNIC_TGTID), false));
[493]616            maptabd.add(Segment("seg_cdma", CDMA_BASE, CDMA_SIZE, 
617                        IntTab(cluster(x,y),CDMA_TGTID), false));
[547]618            maptabd.add(Segment("seg_simh", SIMH_BASE, SIMH_SIZE, 
619                        IntTab(cluster(x,y),SIMH_TGTID), false));
[344]620         }
621      }
622   }
623   std::cout << maptabd << std::endl;
624
625   // external network
[438]626   MappingTable maptabx(vci_address_width, 
[396]627                        IntTab(x_width+y_width), 
628                        IntTab(x_width+y_width), 
629                        0xFFFF000000ULL);
[344]630
[663]631   for (size_t x = 0; x < X_SIZE; x++)
[344]632   {
[663]633      for (size_t y = 0; y < Y_SIZE ; y++)
[344]634      { 
[396]635
[438]636         sc_uint<vci_address_width> offset;
637         offset = (sc_uint<vci_address_width>)cluster(x,y) 
638                   << (vci_address_width-x_width-y_width);
[396]639
[344]640         std::ostringstream sh;
641         sh << "x_seg_memc_" << x << "_" << y;
[396]642
[547]643         maptabx.add(Segment(sh.str(), MEMC_BASE + offset, 
[344]644                     MEMC_SIZE, IntTab(cluster(x,y)), false));
645      }
646   }
647   std::cout << maptabx << std::endl;
648
649   ////////////////////
650   // Signals
651   ///////////////////
652
[389]653   sc_clock           signal_clk("clk");
[344]654   sc_signal<bool>    signal_resetn("resetn");
655
656   // Horizontal inter-clusters DSPIN signals
[396]657   DspinSignals<dspin_cmd_width>*** signal_dspin_h_cmd_inc =
[663]658      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_inc", X_SIZE-1, Y_SIZE, 3);
[396]659   DspinSignals<dspin_cmd_width>*** signal_dspin_h_cmd_dec =
[663]660      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_dec", X_SIZE-1, Y_SIZE, 3);
[396]661   DspinSignals<dspin_rsp_width>*** signal_dspin_h_rsp_inc =
[663]662      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_rsp_inc", X_SIZE-1, Y_SIZE, 2);
[396]663   DspinSignals<dspin_rsp_width>*** signal_dspin_h_rsp_dec =
[663]664      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_rsp_dec", X_SIZE-1, Y_SIZE, 2);
[344]665
666   // Vertical inter-clusters DSPIN signals
[396]667   DspinSignals<dspin_cmd_width>*** signal_dspin_v_cmd_inc =
[663]668      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_inc", X_SIZE, Y_SIZE-1, 3);
[396]669   DspinSignals<dspin_cmd_width>*** signal_dspin_v_cmd_dec =
[663]670      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_dec", X_SIZE, Y_SIZE-1, 3);
[396]671   DspinSignals<dspin_rsp_width>*** signal_dspin_v_rsp_inc =
[663]672      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_rsp_inc", X_SIZE, Y_SIZE-1, 2);
[396]673   DspinSignals<dspin_rsp_width>*** signal_dspin_v_rsp_dec =
[663]674      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_rsp_dec", X_SIZE, Y_SIZE-1, 2);
[344]675
676   // Mesh boundaries DSPIN signals
[396]677   DspinSignals<dspin_cmd_width>**** signal_dspin_false_cmd_in =
[663]678      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_cmd_in" , X_SIZE, Y_SIZE, 4, 3);
[396]679   DspinSignals<dspin_cmd_width>**** signal_dspin_false_cmd_out =
[663]680      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_cmd_out", X_SIZE, Y_SIZE, 4, 3);
[396]681   DspinSignals<dspin_rsp_width>**** signal_dspin_false_rsp_in =
[663]682      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_false_rsp_in" , X_SIZE, Y_SIZE, 4, 2);
[396]683   DspinSignals<dspin_rsp_width>**** signal_dspin_false_rsp_out =
[663]684      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_false_rsp_out", X_SIZE, Y_SIZE, 4, 2);
[344]685
686
687   ////////////////////////////
688   //      Loader   
689   ////////////////////////////
690
691   soclib::common::Loader loader(soft_name);
692
693   typedef soclib::common::GdbServer<soclib::common::Mips32ElIss> proc_iss;
694   proc_iss::set_loader(loader);
695
696   ////////////////////////////
697   // Clusters construction
698   ////////////////////////////
699
[396]700   TsarXbarCluster<dspin_cmd_width,
701                   dspin_rsp_width,
702                   vci_param_int,
[663]703                   vci_param_ext>*          clusters[X_SIZE][Y_SIZE];
[344]704
705#if USE_OPENMP
706#pragma omp parallel
707    {
708#pragma omp for
709#endif
[663]710        for (size_t i = 0; i  < (X_SIZE * Y_SIZE); i++)
[344]711        {
[663]712            size_t x = i / Y_SIZE;
713            size_t y = i % Y_SIZE;
[344]714
715#if USE_OPENMP
716#pragma omp critical
717            {
718#endif
[438]719            std::cout << std::endl;
720            std::cout << "Cluster_" << x << "_" << y << std::endl;
721            std::cout << std::endl;
[389]722
[344]723            std::ostringstream sc;
724            sc << "cluster_" << x << "_" << y;
[396]725            clusters[x][y] = new TsarXbarCluster<dspin_cmd_width,
726                                                 dspin_rsp_width,
727                                                 vci_param_int,
728                                                 vci_param_ext>
[344]729            (
730                sc.str().c_str(),
[396]731                NB_PROCS_MAX,
732                NB_TTY_CHANNELS, 
733                NB_DMA_CHANNELS, 
734                x,
735                y,
736                cluster(x,y),
737                maptabd,
738                maptabx,
739                x_width,
740                y_width,
[438]741                vci_srcid_width - x_width - y_width,   // l_id width,
[396]742                MEMC_TGTID,
743                XICU_TGTID,
744                MDMA_TGTID,
745                FBUF_TGTID,
746                MTTY_TGTID,
747                BROM_TGTID,
748                MNIC_TGTID,
[493]749                CDMA_TGTID,
[396]750                BDEV_TGTID,
[547]751                SIMH_TGTID,
[396]752                MEMC_WAYS,
753                MEMC_SETS,
754                L1_IWAYS,
755                L1_ISETS,
756                L1_DWAYS,
757                L1_DSETS,
[706]758                IRQ_PER_PROCESSOR,
[396]759                XRAM_LATENCY,
760                (cluster(x,y) == cluster_io_id),
761                FBUF_X_SIZE,
762                FBUF_Y_SIZE,
763                disk_name,
764                BDEV_SECTOR_SIZE,
765                NB_NIC_CHANNELS,
766                nic_rx_name,
767                nic_tx_name,
768                NIC_TIMEOUT,
[485]769                NB_CMA_CHANNELS,
[396]770                loader,
[344]771                frozen_cycles,
[663]772                debug_from,
[344]773                debug_ok and (cluster(x,y) == debug_memc_id),
774                debug_ok and (cluster(x,y) == debug_proc_id) 
775            );
776
777#if USE_OPENMP
778            } // end critical
779#endif
780        } // end for
781#if USE_OPENMP
782    }
783#endif
784
785   ///////////////////////////////////////////////////////////////
786   //     Net-list
787   ///////////////////////////////////////////////////////////////
788
789   // Clock & RESET
[663]790   for (size_t x = 0; x < (X_SIZE); x++){
791      for (size_t y = 0; y < Y_SIZE; y++){
[389]792         clusters[x][y]->p_clk                         (signal_clk);
793         clusters[x][y]->p_resetn                      (signal_resetn);
[344]794      }
795   }
796
797   // Inter Clusters horizontal connections
[663]798   if (X_SIZE > 1){
799      for (size_t x = 0; x < (X_SIZE-1); x++){
800         for (size_t y = 0; y < Y_SIZE; y++){
[468]801            for (size_t k = 0; k < 3; k++){
[465]802               clusters[x][y]->p_cmd_out[EAST][k]      (signal_dspin_h_cmd_inc[x][y][k]);
803               clusters[x+1][y]->p_cmd_in[WEST][k]     (signal_dspin_h_cmd_inc[x][y][k]);
804               clusters[x][y]->p_cmd_in[EAST][k]       (signal_dspin_h_cmd_dec[x][y][k]);
805               clusters[x+1][y]->p_cmd_out[WEST][k]    (signal_dspin_h_cmd_dec[x][y][k]);
[468]806            }
807
808            for (size_t k = 0; k < 2; k++){
[465]809               clusters[x][y]->p_rsp_out[EAST][k]      (signal_dspin_h_rsp_inc[x][y][k]);
810               clusters[x+1][y]->p_rsp_in[WEST][k]     (signal_dspin_h_rsp_inc[x][y][k]);
811               clusters[x][y]->p_rsp_in[EAST][k]       (signal_dspin_h_rsp_dec[x][y][k]);
812               clusters[x+1][y]->p_rsp_out[WEST][k]    (signal_dspin_h_rsp_dec[x][y][k]);
[344]813            }
814         }
815      }
816   }
817   std::cout << std::endl << "Horizontal connections established" << std::endl;   
818
819   // Inter Clusters vertical connections
[663]820   if (Y_SIZE > 1) {
821      for (size_t y = 0; y < (Y_SIZE-1); y++){
822         for (size_t x = 0; x < X_SIZE; x++){
[468]823            for (size_t k = 0; k < 3; k++){
[465]824               clusters[x][y]->p_cmd_out[NORTH][k]     (signal_dspin_v_cmd_inc[x][y][k]);
825               clusters[x][y+1]->p_cmd_in[SOUTH][k]    (signal_dspin_v_cmd_inc[x][y][k]);
826               clusters[x][y]->p_cmd_in[NORTH][k]      (signal_dspin_v_cmd_dec[x][y][k]);
827               clusters[x][y+1]->p_cmd_out[SOUTH][k]   (signal_dspin_v_cmd_dec[x][y][k]);
[468]828            }
829
830            for (size_t k = 0; k < 2; k++){
[465]831               clusters[x][y]->p_rsp_out[NORTH][k]     (signal_dspin_v_rsp_inc[x][y][k]);
832               clusters[x][y+1]->p_rsp_in[SOUTH][k]    (signal_dspin_v_rsp_inc[x][y][k]);
833               clusters[x][y]->p_rsp_in[NORTH][k]      (signal_dspin_v_rsp_dec[x][y][k]);
834               clusters[x][y+1]->p_rsp_out[SOUTH][k]   (signal_dspin_v_rsp_dec[x][y][k]);
[344]835            }
836         }
837      }
838   }
839   std::cout << "Vertical connections established" << std::endl;
840
841   // East & West boundary cluster connections
[663]842   for (size_t y = 0; y < Y_SIZE; y++)
[344]843   {
[468]844      for (size_t k = 0; k < 3; k++)
845      {
846         clusters[0][y]->p_cmd_in[WEST][k]        (signal_dspin_false_cmd_in[0][y][WEST][k]);
847         clusters[0][y]->p_cmd_out[WEST][k]       (signal_dspin_false_cmd_out[0][y][WEST][k]);
[663]848         clusters[X_SIZE-1][y]->p_cmd_in[EAST][k]   (signal_dspin_false_cmd_in[X_SIZE-1][y][EAST][k]);
849         clusters[X_SIZE-1][y]->p_cmd_out[EAST][k]  (signal_dspin_false_cmd_out[X_SIZE-1][y][EAST][k]);
[468]850      }
851
[344]852      for (size_t k = 0; k < 2; k++)
853      {
[468]854         clusters[0][y]->p_rsp_in[WEST][k]        (signal_dspin_false_rsp_in[0][y][WEST][k]);
855         clusters[0][y]->p_rsp_out[WEST][k]       (signal_dspin_false_rsp_out[0][y][WEST][k]);
[663]856         clusters[X_SIZE-1][y]->p_rsp_in[EAST][k]   (signal_dspin_false_rsp_in[X_SIZE-1][y][EAST][k]);
857         clusters[X_SIZE-1][y]->p_rsp_out[EAST][k]  (signal_dspin_false_rsp_out[X_SIZE-1][y][EAST][k]);
[344]858      }
859   }
860
861   // North & South boundary clusters connections
[663]862   for (size_t x = 0; x < X_SIZE; x++)
[344]863   {
[468]864      for (size_t k = 0; k < 3; k++)
865      {
866         clusters[x][0]->p_cmd_in[SOUTH][k]       (signal_dspin_false_cmd_in[x][0][SOUTH][k]);
867         clusters[x][0]->p_cmd_out[SOUTH][k]      (signal_dspin_false_cmd_out[x][0][SOUTH][k]);
[663]868         clusters[x][Y_SIZE-1]->p_cmd_in[NORTH][k]  (signal_dspin_false_cmd_in[x][Y_SIZE-1][NORTH][k]);
869         clusters[x][Y_SIZE-1]->p_cmd_out[NORTH][k] (signal_dspin_false_cmd_out[x][Y_SIZE-1][NORTH][k]);
[468]870      }
871
[344]872      for (size_t k = 0; k < 2; k++)
873      {
[468]874         clusters[x][0]->p_rsp_in[SOUTH][k]       (signal_dspin_false_rsp_in[x][0][SOUTH][k]);
875         clusters[x][0]->p_rsp_out[SOUTH][k]      (signal_dspin_false_rsp_out[x][0][SOUTH][k]);
[663]876         clusters[x][Y_SIZE-1]->p_rsp_in[NORTH][k]  (signal_dspin_false_rsp_in[x][Y_SIZE-1][NORTH][k]);
877         clusters[x][Y_SIZE-1]->p_rsp_out[NORTH][k] (signal_dspin_false_rsp_out[x][Y_SIZE-1][NORTH][k]);
[344]878      }
879   }
[396]880   std::cout << "North, South, West, East connections established" << std::endl;
881   std::cout << std::endl;
[344]882
883
884   ////////////////////////////////////////////////////////
885   //   Simulation
886   ///////////////////////////////////////////////////////
887
888   sc_start(sc_core::sc_time(0, SC_NS));
889   signal_resetn = false;
890
891   // network boundaries signals
[663]892   for (size_t x = 0; x < X_SIZE ; x++){
893      for (size_t y = 0; y < Y_SIZE ; y++){
[468]894         for (size_t a = 0; a < 4; a++){
895            for (size_t k = 0; k < 3; k++){
896               signal_dspin_false_cmd_in [x][y][a][k].write = false;
897               signal_dspin_false_cmd_in [x][y][a][k].read  = true;
898               signal_dspin_false_cmd_out[x][y][a][k].write = false;
899               signal_dspin_false_cmd_out[x][y][a][k].read  = true;
900            }
[344]901
[468]902            for (size_t k = 0; k < 2; k++){
903               signal_dspin_false_rsp_in [x][y][a][k].write = false;
904               signal_dspin_false_rsp_in [x][y][a][k].read  = true;
905               signal_dspin_false_rsp_out[x][y][a][k].write = false;
906               signal_dspin_false_rsp_out[x][y][a][k].read  = true;
[344]907            }
908         }
909      }
910   }
911
912   sc_start(sc_core::sc_time(1, SC_NS));
913   signal_resetn = true;
914
[663]915   if (debug_ok) {
916      #if USE_OPENMP
917         assert(false && "OPEN MP should not be used with debug because of its traces");
918      #endif
[464]919
[663]920      if (gettimeofday(&t1, NULL) != 0) {
921         perror("gettimeofday");
922         return EXIT_FAILURE;
923      }
[396]924
[663]925      for (int64_t n = 1; n < ncycles && !stop_called; n++)
[464]926      {
[663]927         // Monitor a specific address for L1 & L2 caches
928         //clusters[0][0]->proc[0]->cache_monitor(0x800002c000ULL);
929         //clusters[1][0]->memc->copies_monitor(0x800002C000ULL);
[464]930
[663]931         if ((n % max_cycles) == 0)
[464]932         {
[663]933
934            if (gettimeofday(&t2, NULL) != 0) 
935            {
936               perror("gettimeofday");
937               return EXIT_FAILURE;
938            }
939
940            ms1 = (uint64_t) t1.tv_sec * 1000ULL + (uint64_t) t1.tv_usec / 1000;
941            ms2 = (uint64_t) t2.tv_sec * 1000ULL + (uint64_t) t2.tv_usec / 1000;
942            std::cerr << "platform clock frequency " << (double) 5000000 / (double) (ms2 - ms1) << "Khz" << std::endl;
943
944            if (gettimeofday(&t1, NULL) != 0) 
945            {
946               perror("gettimeofday");
947               return EXIT_FAILURE;
948            }
[464]949         }
950
951
[663]952         if (n == reset_counters) {
953            for (size_t x = 0; x < (X_SIZE); x++) {
954               for (size_t y = 0; y < Y_SIZE; y++) {
955                  clusters[x][y]->memc->reset_counters();
956               }
957            }
[464]958         }
959
[663]960         if (n == dump_counters) {
961            for (size_t x = 0; x < (X_SIZE); x++) {
962               for (size_t y = 0; y < Y_SIZE; y++) {
963                  clusters[x][y]->memc->print_stats(true, false);
964               }
965            }
966         }
[344]967
[663]968         if (debug_ok and (n > debug_from) and (n % debug_period == 0))
969         {
970            std::cout << "****************** cycle " << std::dec << n ;
971            std::cout << " ************************************************" << std::endl;
[379]972
[663]973            // trace proc[debug_proc_id]
974            size_t l = debug_proc_id % NB_PROCS_MAX ;
975            size_t y = (debug_proc_id / NB_PROCS_MAX) % Y_SIZE ;
976            size_t x = debug_proc_id / (Y_SIZE * NB_PROCS_MAX) ;
[379]977
[663]978            std::ostringstream proc_signame;
979            proc_signame << "[SIG]PROC_" << x << "_" << y << "_" << l ;
980            std::ostringstream p2m_signame;
981            p2m_signame << "[SIG]PROC_" << x << "_" << y << "_" << l << " P2M" ;
982            std::ostringstream m2p_signame;
983            m2p_signame << "[SIG]PROC_" << x << "_" << y << "_" << l << " M2P" ;
[404]984
[663]985            //clusters[x][y]->signal_vci_ini_proc[l].print_trace(proc_signame.str());
986            //clusters[x][y]->signal_dspin_p2m_proc[l].print_trace(p2m_signame.str());
987            //clusters[x][y]->signal_dspin_m2p_proc[l].print_trace(m2p_signame.str());
[404]988
[663]989            //clusters[x][y]->signal_dspin_cmd_l2g_d.print_trace("[SIG]L2G CMD");
990            //clusters[x][y]->signal_dspin_cmd_g2l_d.print_trace("[SIG]G2L CMD");
991            //clusters[x][y]->signal_dspin_rsp_l2g_d.print_trace("[SIG]L2G RSP");
992            //clusters[x][y]->signal_dspin_rsp_g2l_d.print_trace("[SIG]G2L RSP");
[344]993
[663]994            // trace memc[debug_memc_id]
995            x = debug_memc_id / Y_SIZE;
996            y = debug_memc_id % Y_SIZE;
[344]997
[663]998            std::ostringstream smemc;
999            smemc << "[SIG]MEMC_" << x << "_" << y;
1000            std::ostringstream sxram;
1001            sxram << "[SIG]XRAM_" << x << "_" << y;
1002            std::ostringstream sm2p;
1003            sm2p << "[SIG]MEMC_" << x << "_" << y << " M2P" ;
1004            std::ostringstream sp2m;
1005            sp2m << "[SIG]MEMC_" << x << "_" << y << " P2M" ;
[396]1006
[663]1007            //clusters[x][y]->memc->print_trace();
1008            //clusters[x][y]->signal_vci_tgt_memc.print_trace(smemc.str());
1009            //clusters[x][y]->signal_vci_xram.print_trace(sxram.str());
1010            //clusters[x][y]->signal_dspin_p2m_memc.print_trace(sp2m.str());
1011            //clusters[x][y]->signal_dspin_m2p_memc.print_trace(sm2p.str());
[625]1012
[663]1013            // trace replicated peripherals
1014            //clusters[1][1]->mdma->print_trace();
1015            //clusters[1][1]->signal_vci_tgt_mdma.print_trace("[SIG]MDMA_TGT_1_1");
1016            //clusters[1][1]->signal_vci_ini_mdma.print_trace("[SIG]MDMA_INI_1_1");
[396]1017
[663]1018
1019            // trace external peripherals
1020            //size_t io_x   = cluster_io_id / Y_SIZE;
1021            //size_t io_y   = cluster_io_id % Y_SIZE;
1022
1023            //clusters[io_x][io_y]->brom->print_trace();
1024            //clusters[io_x][io_y]->signal_vci_tgt_brom.print_trace("[SIG]BROM");
1025
1026            //clusters[io_x][io_y]->bdev->print_trace();
1027            //clusters[io_x][io_y]->signal_vci_tgt_bdev.print_trace("[SIG]BDEV_TGT");
1028            //clusters[io_x][io_y]->signal_vci_ini_bdev.print_trace("[SIG]BDEV_INI");
1029         }
1030
1031         sc_start(sc_core::sc_time(1, SC_NS));
[344]1032      }
[663]1033   }
1034   else {
1035      int64_t n = 0;
1036      while (!stop_called) {
1037         if (gettimeofday(&t1, NULL) != 0) {
1038            perror("gettimeofday");
1039            return EXIT_FAILURE;
1040         }
1041         int64_t nb_cycles = max_cycles;
1042         if (do_reset_counters) {
1043            nb_cycles = min(nb_cycles, reset_counters - n);
1044         }
1045         if (do_dump_counters) {
1046            nb_cycles = min(nb_cycles, dump_counters - n);
1047         }
[344]1048
[663]1049         sc_start(sc_core::sc_time(nb_cycles, SC_NS));
1050         n += nb_cycles;
1051
1052         if (do_reset_counters && n == reset_counters) {
1053            // Reseting counters
1054            for (size_t x = 0; x < (X_SIZE); x++) {
1055               for (size_t y = 0; y < Y_SIZE; y++) {
1056                  clusters[x][y]->memc->reset_counters();
1057               }
1058            }
1059            do_reset_counters = false;
1060         }
1061
1062         if (do_dump_counters && n == dump_counters) {
1063            // Dumping counters
1064            for (size_t x = 0; x < (X_SIZE); x++) {
1065               for (size_t y = 0; y < Y_SIZE; y++) {
1066                  clusters[x][y]->memc->print_stats(true, false);
1067               }
1068            }
1069            do_dump_counters = false;
1070         }
1071
1072
1073         if (gettimeofday(&t2, NULL) != 0) {
1074            perror("gettimeofday");
1075            return EXIT_FAILURE;
1076         }
1077         ms1 = (uint64_t) t1.tv_sec * 1000ULL + (uint64_t) t1.tv_usec / 1000;
1078         ms2 = (uint64_t) t2.tv_sec * 1000ULL + (uint64_t) t2.tv_usec / 1000;
[706]1079         std::cerr << std::dec << "cycle " << n << " platform clock frequency " << (double) nb_cycles / (double) (ms2 - ms1) << "Khz" << std::endl;
[663]1080      }
[344]1081   }
[504]1082
1083   
[512]1084   // Free memory
[663]1085   for (size_t i = 0; i  < (X_SIZE * Y_SIZE); i++)
[504]1086   {
[663]1087      size_t x = i / Y_SIZE;
1088      size_t y = i % Y_SIZE;
[504]1089      delete clusters[x][y];
1090   }
1091
[663]1092   dealloc_elems<DspinSignals<dspin_cmd_width> >(signal_dspin_h_cmd_inc, X_SIZE - 1, Y_SIZE, 3);
1093   dealloc_elems<DspinSignals<dspin_cmd_width> >(signal_dspin_h_cmd_dec, X_SIZE - 1, Y_SIZE, 3);
1094   dealloc_elems<DspinSignals<dspin_rsp_width> >(signal_dspin_h_rsp_inc, X_SIZE - 1, Y_SIZE, 2);
1095   dealloc_elems<DspinSignals<dspin_rsp_width> >(signal_dspin_h_rsp_dec, X_SIZE - 1, Y_SIZE, 2);
1096   dealloc_elems<DspinSignals<dspin_cmd_width> >(signal_dspin_v_cmd_inc, X_SIZE, Y_SIZE - 1, 3);
1097   dealloc_elems<DspinSignals<dspin_cmd_width> >(signal_dspin_v_cmd_dec, X_SIZE, Y_SIZE - 1, 3);
1098   dealloc_elems<DspinSignals<dspin_rsp_width> >(signal_dspin_v_rsp_inc, X_SIZE, Y_SIZE - 1, 2);
1099   dealloc_elems<DspinSignals<dspin_rsp_width> >(signal_dspin_v_rsp_dec, X_SIZE, Y_SIZE - 1, 2);
1100   dealloc_elems<DspinSignals<dspin_cmd_width> >(signal_dspin_false_cmd_in, X_SIZE, Y_SIZE, 4, 3);
1101   dealloc_elems<DspinSignals<dspin_cmd_width> >(signal_dspin_false_cmd_out, X_SIZE, Y_SIZE, 4, 3);
1102   dealloc_elems<DspinSignals<dspin_rsp_width> >(signal_dspin_false_rsp_in, X_SIZE, Y_SIZE, 4, 2);
1103   dealloc_elems<DspinSignals<dspin_rsp_width> >(signal_dspin_false_rsp_out, X_SIZE, Y_SIZE, 4, 2);
[512]1104
[344]1105   return EXIT_SUCCESS;
1106}
1107
[504]1108
1109void handler(int dummy = 0) {
1110   stop_called = true;
1111   sc_stop();
1112}
1113
[547]1114void voidhandler(int dummy = 0) {}
[504]1115
[344]1116int sc_main (int argc, char *argv[])
1117{
[504]1118   signal(SIGINT, handler);
[547]1119   signal(SIGPIPE, voidhandler);
[504]1120
[344]1121   try {
1122      return _main(argc, argv);
1123   } catch (std::exception &e) {
1124      std::cout << e.what() << std::endl;
1125   } catch (...) {
1126      std::cout << "Unknown exception occured" << std::endl;
1127      throw;
1128   }
1129   return 1;
1130}
1131
1132
1133// Local Variables:
1134// tab-width: 3
1135// c-basic-offset: 3
1136// c-file-offsets:((innamespace . 0)(inline-open . 0))
1137// indent-tabs-mode: nil
1138// End:
1139
1140// vim: filetype=cpp:expandtab:shiftwidth=3:tabstop=3:softtabstop=3
Note: See TracBrowser for help on using the repository browser.