Ignore:
Timestamp:
Aug 9, 2012, 11:26:59 AM (11 years ago)
Author:
meunier
Message:

Formatting of topcell and cluster files

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/platforms/tsarv4_generic_mmu/top.cpp

    r247 r249  
    5555
    5656///////////////////////////////////////////////////
    57 //              OS
     57//      OS
    5858///////////////////////////////////////////////////
    5959
    … …  
    7575
    7676//  cluster index (computed from x,y coordinates)
    77 #define cluster(x,y)    (y + ymax*x)
     77#define cluster(x,y)   (y + ymax*x)
    7878
    7979// flit widths for the DSPIN network
    80 #define cmd_width                40
    81 #define rsp_width                33
     80#define cmd_width            40
     81#define rsp_width            33
    8282
    8383// VCI format
    84 #define cell_width               4
    85 #define address_width            32
    86 #define plen_width               8
    87 #define error_width              2
    88 #define clen_width               1
    89 #define rflag_width              1
    90 #define srcid_width              14
    91 #define pktid_width              4
    92 #define trdid_width              4
    93 #define wrplen_width             1
     84#define cell_width            4
     85#define address_width         32
     86#define plen_width            8
     87#define error_width           2
     88#define clen_width            1
     89#define rflag_width           1
     90#define srcid_width           14
     91#define pktid_width           4
     92#define trdid_width           4
     93#define wrplen_width          1
    9494
    9595///////////////////////////////////////////////////
    … …  
    9797///////////////////////////////////////////////////
    9898
    99 #define MESH_XMAX               2
    100 #define MESH_YMAX               2
    101 
    102 #define NPROCS                  4
     99#define MESH_XMAX      2
     100#define MESH_YMAX      2
     101
     102#define NPROCS         4
    103103#define XRAM_LATENCY            0
    104104
    … …  
    115115#define FBUF_Y_SIZE             512
    116116
    117 #define BDEV_SECTOR_SIZE        128
    118 #define BDEV_IMAGE_NAME         "../../softs/soft_transpose_giet/images.raw"
    119 
    120 #define BOOT_SOFT_NAME          "../../softs/soft_transpose_giet/bin.soft"
    121 
    122 #define MAX_FROZEN_CYCLES       100000
     117#define   BDEV_SECTOR_SIZE    128
     118#define BDEV_IMAGE_NAME           "../../softs/soft_transpose_giet/couple_512.raw"
     119
     120#define BOOT_SOFT_NAME       "../../softs/soft_transpose_giet/bin.soft"
     121
     122#define MAX_FROZEN_CYCLES   100000
    123123
    124124/////////////////////////////////////////////////////////
    125 //      Physical segments definition
     125//    Physical segments definition
    126126/////////////////////////////////////////////////////////
    127127// There is 3 segments replicated in all clusters:
    128 // - seg_memc   -> MEMC / BASE = 0x**000000     (12 M bytes)
    129 // - seg_icu    -> ICU  / BASE = 0x**F00000
    130 // - seg_dma    -> CDMA / BASE = 0x**F30000
     128// - seg_memc   -> MEMC / BASE = 0x**000000    (12 M bytes)
     129// - seg_icu    -> ICU  / BASE = 0x**F00000
     130// - seg_dma    -> CDMA / BASE = 0x**F30000
    131131//
    132132// There is 4 specific segments in the "IO" cluster
    133133// (containing address 0xBF000000)
    134 // - seg_reset  -> BROM / BASE = 0xBFC00000     (1 Mbytes)
    135 // - seg_fbuf   -> FBUF / BASE = 0xBFD00000     (2 M bytes)
    136 // - seg_bdev   -> BDEV / BASE = 0xBFF10000
    137 // - seg_tty    -> MTTY / BASE = 0x**F20000
     134// - seg_reset   -> BROM / BASE = 0xBFC00000   (1 Mbytes)
     135// - seg_fbuf   -> FBUF / BASE = 0xBFD00000   (2 M bytes)
     136// - seg_bdev   -> BDEV / BASE = 0xBFF10000
     137// - seg_tty    -> MTTY / BASE = 0x**F20000
    138138//
    139139// There is one special segment corresponding to
    140140// the processors in the coherence address space
    141 // - seg_proc   -> PROC / BASE = 0x**B0 to 0xBF
     141// - seg_proc   -> PROC / BASE = 0x**B0 to 0xBF
    142142///////////////////////////////////////////////////
    143143
    … …  
    186186int _main(int argc, char *argv[])
    187187{
    188     using namespace sc_core;
    189     using namespace soclib::caba;
    190     using namespace soclib::common;
    191    
    192    
    193     char     soft_name[256] = BOOT_SOFT_NAME;     // pathname to binary code
    194     size_t   ncycles        = 1000000000;         // simulated cycles
    195     size_t   xmax           = MESH_XMAX;          // number of clusters in a row
    196     size_t   ymax           = MESH_YMAX;          // number of clusters in a column
    197     size_t   nprocs         = NPROCS;             // number of processors per cluster
    198     size_t   xfb            = FBUF_X_SIZE;        // frameBuffer column number
    199     size_t   yfb            = FBUF_Y_SIZE;        // frameBuffer lines number
    200     size_t   memc_ways      = MEMC_WAYS;
    201     size_t   memc_sets      = MEMC_SETS;
    202     size_t   l1_d_ways      = L1_DWAYS;
    203     size_t   l1_d_sets      = L1_DSETS;
    204     size_t   l1_i_ways      = L1_IWAYS;
    205     size_t   l1_i_sets      = L1_ISETS;
    206     char     disk_name[256] = BDEV_IMAGE_NAME;    // pathname to the disk image
    207     size_t   blk_size       = BDEV_SECTOR_SIZE;   // block size (in bytes)
    208     size_t   xram_latency   = XRAM_LATENCY;       // external RAM latency
    209     bool     trace_ok       = false;              // trace activated
    210     size_t   trace_period   = 1;                  // trace period
    211     uint32_t from_cycle     = 0;                  // debug start cycle
    212     uint32_t frozen_cycles  = MAX_FROZEN_CYCLES;  // monitoring frozen processor
    213 
    214     ////////////// command line arguments //////////////////////
    215     if (argc > 1)
    216     {
    217         for( int n=1 ; n<argc ; n=n+2 )
    218         {
    219             if( (strcmp(argv[n],"-NCYCLES") == 0) && (n+1<argc) )
    220             {
    221                 ncycles = atoi(argv[n+1]);
    222             }
    223             else if( (strcmp(argv[n],"-NPROCS") == 0) && (n+1<argc) )
    224             {
    225                 nprocs = atoi(argv[n+1]);
    226                 assert( ((nprocs == 1) || (nprocs == 2) || (nprocs == 4)) &&
    227                         "NPROCS must be equal to 1, 2, or 4");
    228             }
    229             else if( (strcmp(argv[n],"-XMAX") == 0) && (n+1<argc) )
    230             {
    231                 xmax = atoi(argv[n+1]);
    232                 assert( ((xmax == 1) || (xmax == 2) || (xmax == 4) || (xmax == 8) || (xmax == 16))
    233                          && "The XMAX parameter must be 2, 4, 8, or 16" );
    234             }
    235            
    236             else if( (strcmp(argv[n],"-YMAX") == 0) && (n+1<argc) )
    237             {
    238                 ymax = atoi(argv[n+1]);
    239                 assert( ((ymax == 1) || (ymax == 2) || (ymax == 4) || (ymax == 8) || (ymax == 16))
    240                          && "The YMAX parameter must be 2, 4, 8, or 16" );
    241             }
    242             else if( (strcmp(argv[n],"-XFB") == 0) && (n+1<argc) )
    243             {
    244                 xfb = atoi(argv[n+1]);
    245             }
    246             else if( (strcmp(argv[n],"-YFB") == 0) && (n+1<argc) )
    247             {
    248                 yfb = atoi(argv[n+1]);
    249             }
    250             else if( (strcmp(argv[n],"-SOFT") == 0) && (n+1<argc) )
    251             {
    252                 strcpy(soft_name, argv[n+1]);
    253             }
    254             else if( (strcmp(argv[n],"-DISK") == 0) && (n+1<argc) )
    255             {
    256                 strcpy(disk_name, argv[n+1]);
    257             }
    258             else if( (strcmp(argv[n],"-TRACE") == 0) && (n+1<argc) )
    259             {
    260                 trace_ok = true;
    261                 from_cycle = atoi(argv[n+1]);
    262             }
    263             else if((strcmp(argv[n], "-MCWAYS") == 0) && (n+1 < argc))
    264             {
    265                 memc_ways = atoi(argv[n+1]);
    266             }
    267             else if((strcmp(argv[n], "-MCSETS") == 0) && (n+1 < argc))
    268             {
    269                 memc_sets = atoi(argv[n+1]);
    270             }
    271             else if((strcmp(argv[n], "-XLATENCY") == 0) && (n+1 < argc))
    272             {
    273                 xram_latency = atoi(argv[n+1]);
    274             }
    275             else if((strcmp(argv[n], "-FROZEN") == 0) && (n+1 < argc))
    276             {
    277                 frozen_cycles = atoi(argv[n+1]);
    278             }
    279             else if((strcmp(argv[n], "-PERIOD") == 0) && (n+1 < argc))
    280             {
    281                 trace_period = atoi(argv[n+1]);
    282             }
    283             else
    284             {
    285                 std::cout << "   Arguments on the command line are (key,value) couples." << std::endl;
    286                 std::cout << "   The order is not important." << std::endl;
    287                 std::cout << "   Accepted arguments are :" << std::endl << std::endl;
    288                 std::cout << "     -SOFT pathname_for_embedded_soft" << std::endl;
    289                 std::cout << "     -DISK pathname_for_disk_image" << std::endl;
    290                 std::cout << "     -NCYCLES number_of_simulated_cycles" << std::endl;
    291                 std::cout << "     -NPROCS number_of_processors_per_cluster" << std::endl;
    292                 std::cout << "     -XMAX number_of_clusters_in_a_row" << std::endl;
    293                 std::cout << "     -YMAX number_of_clusters_in_a_column" << std::endl;
    294                 std::cout << "     -TRACE debug_start_cycle" << std::endl;
    295                 std::cout << "     -MCWAYS memory_cache_number_of_ways" << std::endl;
    296                 std::cout << "     -MCSETS memory_cache_number_of_sets" << std::endl;
    297                 std::cout << "     -XLATENCY external_ram_latency_value" << std::endl;
    298                 std::cout << "     -XFB fram_buffer_number_of_pixels" << std::endl;
    299                 std::cout << "     -YFB fram_buffer_number_of_lines" << std::endl;
    300                 std::cout << "     -FROZEN max_number_of_lines" << std::endl;
    301                 std::cout << "     -PERIOD number_of_cycles between trace" << std::endl;
    302                 exit(0);
    303             }
    304         }
    305     }
    306 
    307     std::cout << std::endl;
    308     std::cout << " - NPROCS      = " << nprocs <<  std::endl;
    309     std::cout << " - NCLUSTERS   = " << xmax*ymax << std::endl;
    310     std::cout << " - MAX FROZEN  = " << frozen_cycles << std::endl;
    311     std::cout << " - MEMC_WAYS   = " << memc_ways << std::endl;
    312     std::cout << " - MEMC_SETS   = " << memc_sets << std::endl;
    313     std::cout << " - RAM_LATENCY = " << xram_latency << std::endl;
    314 
    315     std::cout << std::endl;
     188   using namespace sc_core;
     189   using namespace soclib::caba;
     190   using namespace soclib::common;
     191
     192
     193   char     soft_name[256] = BOOT_SOFT_NAME;       // pathname to binary code
     194   size_t   ncycles        = 1000000000;         // simulated cycles
     195   size_t   xmax           = MESH_XMAX;       // number of clusters in a row
     196   size_t   ymax           = MESH_YMAX;          // number of clusters in a column
     197   size_t   nprocs         = NPROCS;         // number of processors per cluster
     198   size_t   xfb            = FBUF_X_SIZE;     // frameBuffer column number
     199   size_t   yfb            = FBUF_Y_SIZE;        // frameBuffer lines number
     200   size_t   memc_ways      = MEMC_WAYS;
     201   size_t   memc_sets      = MEMC_SETS;
     202   size_t   l1_d_ways      = L1_DWAYS;
     203   size_t   l1_d_sets      = L1_DSETS;
     204   size_t   l1_i_ways      = L1_IWAYS;
     205   size_t   l1_i_sets      = L1_ISETS;
     206   char     disk_name[256] = BDEV_IMAGE_NAME;    // pathname to the disk image
     207   size_t   blk_size       = BDEV_SECTOR_SIZE;   // block size (in bytes)
     208   size_t   xram_latency   = XRAM_LATENCY;     // external RAM latency
     209   bool     trace_ok       = false;              // trace activated
     210   size_t   trace_period   = 1;                  // trace period
     211   uint32_t from_cycle     = 0;                  // debug start cycle
     212   uint32_t frozen_cycles  = MAX_FROZEN_CYCLES;  // monitoring frozen processor
     213
     214   ////////////// command line arguments //////////////////////
     215   if (argc > 1){
     216      for (int n = 1; n < argc; n = n + 2){
     217         if ((strcmp(argv[n],"-NCYCLES") == 0) && (n+1<argc)){
     218            ncycles = atoi(argv[n+1]);
     219         }
     220         else if ((strcmp(argv[n],"-NPROCS") == 0) && (n+1<argc)){
     221            nprocs = atoi(argv[n+1]);
     222            assert( ((nprocs == 1) || (nprocs == 2) || (nprocs == 4)) &&
     223                  "NPROCS must be equal to 1, 2, or 4");
     224         }
     225         else if ((strcmp(argv[n],"-XMAX") == 0) && (n+1<argc)){
     226            xmax = atoi(argv[n+1]);
     227            assert( ((xmax == 1) || (xmax == 2) || (xmax == 4) || (xmax == 8) || (xmax == 16))
     228                  && "The XMAX parameter must be 2, 4, 8, or 16" );
     229         }
     230
     231         else if ((strcmp(argv[n],"-YMAX") == 0) && (n+1<argc)){
     232            ymax = atoi(argv[n+1]);
     233            assert( ((ymax == 1) || (ymax == 2) || (ymax == 4) || (ymax == 8) || (ymax == 16))
     234                  && "The YMAX parameter must be 2, 4, 8, or 16" );
     235         }
     236         else if ((strcmp(argv[n],"-XFB") == 0) && (n+1<argc)){
     237            xfb = atoi(argv[n+1]);
     238         }
     239         else if ((strcmp(argv[n],"-YFB") == 0) && (n+1<argc) ){
     240            yfb = atoi(argv[n+1]);
     241         }
     242         else if ((strcmp(argv[n],"-SOFT") == 0) && (n+1<argc) ){
     243            strcpy(soft_name, argv[n+1]);
     244         }
     245         else if ((strcmp(argv[n],"-DISK") == 0) && (n+1<argc) ){
     246            strcpy(disk_name, argv[n+1]);
     247         }
     248         else if ((strcmp(argv[n],"-TRACE") == 0) && (n+1<argc) ){
     249            trace_ok = true;
     250            from_cycle = atoi(argv[n+1]);
     251         }
     252         else if ((strcmp(argv[n], "-MCWAYS") == 0) && (n+1 < argc)){
     253            memc_ways = atoi(argv[n+1]);
     254         }
     255         else if ((strcmp(argv[n], "-MCSETS") == 0) && (n+1 < argc)){
     256            memc_sets = atoi(argv[n+1]);
     257         }
     258         else if ((strcmp(argv[n], "-XLATENCY") == 0) && (n+1 < argc)){
     259            xram_latency = atoi(argv[n+1]);
     260         }
     261         else if ((strcmp(argv[n], "-FROZEN") == 0) && (n+1 < argc)){
     262            frozen_cycles = atoi(argv[n+1]);
     263         }
     264         else if ((strcmp(argv[n], "-PERIOD") == 0) && (n+1 < argc)){
     265            trace_period = atoi(argv[n+1]);
     266         }
     267         else
     268         {
     269            std::cout << "   Arguments on the command line are (key,value) couples." << std::endl;
     270            std::cout << "   The order is not important." << std::endl;
     271            std::cout << "   Accepted arguments are :" << std::endl << std::endl;
     272            std::cout << "     -SOFT pathname_for_embedded_soft" << std::endl;
     273            std::cout << "     -DISK pathname_for_disk_image" << std::endl;
     274            std::cout << "     -NCYCLES number_of_simulated_cycles" << std::endl;
     275            std::cout << "     -NPROCS number_of_processors_per_cluster" << std::endl;
     276            std::cout << "     -XMAX number_of_clusters_in_a_row" << std::endl;
     277            std::cout << "     -YMAX number_of_clusters_in_a_column" << std::endl;
     278            std::cout << "     -TRACE debug_start_cycle" << std::endl;
     279            std::cout << "     -MCWAYS memory_cache_number_of_ways" << std::endl;
     280            std::cout << "     -MCSETS memory_cache_number_of_sets" << std::endl;
     281            std::cout << "     -XLATENCY external_ram_latency_value" << std::endl;
     282            std::cout << "     -XFB fram_buffer_number_of_pixels" << std::endl;
     283            std::cout << "     -YFB fram_buffer_number_of_lines" << std::endl;
     284            std::cout << "     -FROZEN max_number_of_lines" << std::endl;
     285            std::cout << "     -PERIOD number_of_cycles between trace" << std::endl;
     286            exit(0);
     287         }
     288      }
     289   }
     290
     291   std::cout << std::endl;
     292   std::cout << " - NPROCS      = " << nprocs <<  std::endl;
     293   std::cout << " - NCLUSTERS   = " << xmax*ymax << std::endl;
     294   std::cout << " - MAX FROZEN  = " << frozen_cycles << std::endl;
     295   std::cout << " - MEMC_WAYS   = " << memc_ways << std::endl;
     296   std::cout << " - MEMC_SETS   = " << memc_sets << std::endl;
     297   std::cout << " - RAM_LATENCY = " << xram_latency << std::endl;
     298
     299   std::cout << std::endl;
    316300
    317301#if USE_OPENMP
    318         omp_set_dynamic(false);
    319         omp_set_num_threads(threads_nr);
    320         std::cerr << "Built with openmp version " << _OPENMP << std::endl;
     302   omp_set_dynamic(false);
     303   omp_set_num_threads(threads_nr);
     304   std::cerr << "Built with openmp version " << _OPENMP << std::endl;
    321305#endif
    322306
    323     // Define VCI parameters
    324     typedef soclib::caba::VciParams<cell_width,
    325                                     plen_width,
    326                                     address_width,
    327                                     error_width,                                   
    328                                     clen_width,
    329                                     rflag_width,
    330                                     srcid_width,
    331                                     pktid_width,
    332                                     trdid_width,
    333                                     wrplen_width> vci_param;
    334 
    335     size_t      cluster_io_index;
    336     size_t      x_width;
    337     size_t      y_width;
    338 
    339     if      (xmax == 1) x_width = 0;
    340     else if (xmax == 2) x_width = 1;
    341     else if (xmax <= 4) x_width = 2;
    342     else if (xmax <= 8) x_width = 3;
    343     else                x_width = 4;
    344 
    345     if      (ymax == 1) y_width = 0;
    346     else if (ymax == 2) y_width = 1;
    347     else if (ymax <= 4) y_width = 2;
    348     else if (ymax <= 8) y_width = 3;
    349     else                y_width = 4;
    350 
    351     cluster_io_index = 0xBF >> (8 - x_width - y_width);
    352    
    353     /////////////////////
    354     //  Mapping Tables
    355     /////////////////////
    356 
    357     // direct network
    358     MappingTable maptabd(address_width,
    359                          IntTab(x_width + y_width, 16 - x_width - y_width),
    360                          IntTab(x_width + y_width, srcid_width - x_width - y_width),
    361                          0x00FF0000);
    362 
    363     for ( size_t x = 0 ; x < xmax ; x++)
    364     {
    365         for ( size_t y = 0 ; y < ymax ; y++)
    366         {
    367             sc_uint<address_width> offset  = cluster(x,y) << (address_width-x_width-y_width);
    368 
    369             std::ostringstream  sh;
    370             sh << "d_seg_memc_" << x << "_" << y;
    371             maptabd.add(Segment(sh.str(), MEMC_BASE+offset, MEMC_SIZE, IntTab(cluster(x,y),MEMC_TGTID), true));
    372 
    373             std::ostringstream  si;
    374             si << "d_seg_xicu_" << x << "_" << y;
    375             maptabd.add(Segment(si.str(), XICU_BASE+offset, XICU_SIZE, IntTab(cluster(x,y),XICU_TGTID), false));
    376 
    377             std::ostringstream  sd;
    378             sd << "d_seg_mdma_" << x << "_" << y;
    379             maptabd.add(Segment(sd.str(), CDMA_BASE+offset, CDMA_SIZE, IntTab(cluster(x,y),CDMA_TGTID), false));
    380 
    381             if ( cluster(x,y) == cluster_io_index )
    382             {
    383               maptabd.add(Segment("d_seg_mtty    ", MTTY_BASE, MTTY_SIZE, IntTab(cluster(x,y),MTTY_TGTID), false));
    384               maptabd.add(Segment("d_seg_fbuf    ", FBUF_BASE, FBUF_SIZE, IntTab(cluster(x,y),FBUF_TGTID), false));
    385               maptabd.add(Segment("d_seg_bdev    ", BDEV_BASE, BDEV_SIZE, IntTab(cluster(x,y),BDEV_TGTID), false));
    386               maptabd.add(Segment("d_seg_brom    ", BROM_BASE, BROM_SIZE, IntTab(cluster(x,y),BROM_TGTID), true));
    387             }
    388         }
    389     }
    390     std::cout << maptabd << std::endl;
    391 
    392     // coherence network
    393     // - tgtid_c_proc = srcid_c_proc = local procid
    394     // - tgtid_c_memc = srcid_c_memc = nprocs
    395     MappingTable maptabc(address_width,
    396                          IntTab(x_width + y_width, srcid_width - x_width - y_width),
    397                          IntTab(x_width + y_width, srcid_width - x_width - y_width),
    398                          0x00FF0000);
    399 
    400     for ( size_t x = 0 ; x < xmax ; x++)
    401     {
    402         for ( size_t y = 0 ; y < ymax ; y++)
    403         {
    404             sc_uint<address_width> offset  = cluster(x,y) << (address_width-x_width-y_width);
    405 
    406             // cleanup requests regarding the memc segment must be routed to the memory cache
    407             std::ostringstream sh;
    408             sh << "c_seg_memc_" << x << "_" << y;
    409             maptabc.add(
    410                 Segment(
    411                     sh.str()
    412                   , (nprocs << (address_width - srcid_width)) + offset
    413                   , 0x10
    414                   , IntTab(cluster(x,y), nprocs)
    415                   , false
    416                 )
    417             );
    418 
    419             // update & invalidate requests must be routed to the proper processor
    420             for ( size_t p = 0 ; p < nprocs ; p++)
    421             {
    422                 std::ostringstream sp;
    423                 sp << "c_seg_proc_" << x << "_" << y << "_" << p;
    424                 maptabc.add(
    425                     Segment(
    426                         sp.str()
    427                       , (p << (address_width - srcid_width)) + offset
    428                       , 0x10
    429                       , IntTab(cluster(x,y), p)
    430                       , false
    431                     )
    432                 );
    433             }
    434         }
    435     }
    436     std::cout << maptabc << std::endl;
    437 
    438     // external network
    439     MappingTable maptabx(address_width, IntTab(1), IntTab(x_width+y_width), 0xF0000000);
    440 
    441     for ( size_t x = 0 ; x < xmax ; x++)
    442     {
    443         for ( size_t y = 0 ; y < ymax ; y++)
    444         {
    445             sc_uint<address_width> offset  = cluster(x,y) << (address_width-x_width-y_width);
    446             std::ostringstream sh;
    447             sh << "x_seg_memc_" << x << "_" << y;
    448             maptabx.add(Segment(sh.str(), MEMC_BASE+offset, MEMC_SIZE, IntTab(cluster(x,y)), false));
    449         }
    450     }
    451     std::cout << maptabx << std::endl;
    452 
    453     ////////////////////
    454     // Signals
    455     ///////////////////
    456 
    457     sc_clock            signal_clk("clk");
    458     sc_signal<bool>     signal_resetn("resetn");
    459 
    460     // Horizontal inter-clusters DSPIN signals
    461     DspinSignals<cmd_width>*** signal_dspin_h_cmd_inc =
     307   // Define VCI parameters
     308   typedef soclib::caba::VciParams<cell_width,
     309           plen_width,
     310           address_width,
     311           error_width,                                   
     312           clen_width,
     313           rflag_width,
     314           srcid_width,
     315           pktid_width,
     316           trdid_width,
     317           wrplen_width> vci_param;
     318
     319   size_t   cluster_io_index;
     320   size_t   x_width;
     321   size_t   y_width;
     322
     323   if      (xmax == 1) x_width = 0;
     324   else if (xmax == 2) x_width = 1;
     325   else if (xmax <= 4) x_width = 2;
     326   else if (xmax <= 8) x_width = 3;
     327   else                x_width = 4;
     328
     329   if      (ymax == 1) y_width = 0;
     330   else if (ymax == 2) y_width = 1;
     331   else if (ymax <= 4) y_width = 2;
     332   else if (ymax <= 8) y_width = 3;
     333   else                y_width = 4;
     334
     335   cluster_io_index = 0xBF >> (8 - x_width - y_width);
     336
     337   /////////////////////
     338   //  Mapping Tables
     339   /////////////////////
     340
     341   // direct network
     342   MappingTable maptabd(address_width,
     343         IntTab(x_width + y_width, 16 - x_width - y_width),
     344         IntTab(x_width + y_width, srcid_width - x_width - y_width),
     345         0x00FF0000);
     346
     347   for (size_t x = 0; x < xmax; x++){
     348      for (size_t y = 0; y < ymax; y++){
     349         sc_uint<address_width> offset  = cluster(x,y) << (address_width-x_width-y_width);
     350
     351         std::ostringstream    sh;
     352         sh << "d_seg_memc_" << x << "_" << y;
     353         maptabd.add(Segment(sh.str(), MEMC_BASE+offset, MEMC_SIZE, IntTab(cluster(x,y),MEMC_TGTID), true));
     354
     355         std::ostringstream    si;
     356         si << "d_seg_xicu_" << x << "_" << y;
     357         maptabd.add(Segment(si.str(), XICU_BASE+offset, XICU_SIZE, IntTab(cluster(x,y),XICU_TGTID), false));
     358
     359         std::ostringstream    sd;
     360         sd << "d_seg_mdma_" << x << "_" << y;
     361         maptabd.add(Segment(sd.str(), CDMA_BASE+offset, CDMA_SIZE, IntTab(cluster(x,y),CDMA_TGTID), false));
     362
     363         if ( cluster(x,y) == cluster_io_index )
     364         {
     365            maptabd.add(Segment("d_seg_mtty    ", MTTY_BASE, MTTY_SIZE, IntTab(cluster(x,y),MTTY_TGTID), false));
     366            maptabd.add(Segment("d_seg_fbuf    ", FBUF_BASE, FBUF_SIZE, IntTab(cluster(x,y),FBUF_TGTID), false));
     367            maptabd.add(Segment("d_seg_bdev    ", BDEV_BASE, BDEV_SIZE, IntTab(cluster(x,y),BDEV_TGTID), false));
     368            maptabd.add(Segment("d_seg_brom    ", BROM_BASE, BROM_SIZE, IntTab(cluster(x,y),BROM_TGTID), true));
     369         }
     370      }
     371   }
     372   std::cout << maptabd << std::endl;
     373
     374   // coherence network
     375   // - tgtid_c_proc = srcid_c_proc = local procid
     376   // - tgtid_c_memc = srcid_c_memc = nprocs
     377   MappingTable maptabc(address_width,
     378         IntTab(x_width + y_width, srcid_width - x_width - y_width),
     379         IntTab(x_width + y_width, srcid_width - x_width - y_width),
     380         0x00FF0000);
     381
     382   for (size_t x = 0; x < xmax; x++){
     383      for (size_t y = 0; y < ymax; y++){
     384         sc_uint<address_width> offset  = cluster(x,y) << (address_width-x_width-y_width);
     385
     386         // cleanup requests regarding the memc segment must be routed to the memory cache
     387         std::ostringstream sh;
     388         sh << "c_seg_memc_" << x << "_" << y;
     389         maptabc.add(Segment(sh.str(), (nprocs << (address_width - srcid_width)) + offset, 0x10, IntTab(cluster(x,y), nprocs), false));
     390
     391         // update & invalidate requests must be routed to the proper processor
     392         for ( size_t p = 0 ; p < nprocs ; p++) {
     393            std::ostringstream sp;
     394            sp << "c_seg_proc_" << x << "_" << y << "_" << p;
     395            maptabc.add( Segment( sp.str() , (p << (address_width - srcid_width)) + offset , 0x10 , IntTab(cluster(x,y), p) , false));
     396         }
     397      }
     398   }
     399   std::cout << maptabc << std::endl;
     400
     401   // external network
     402   MappingTable maptabx(address_width, IntTab(1), IntTab(x_width+y_width), 0xF0000000);
     403
     404   for (size_t x = 0; x < xmax; x++){
     405      for (size_t y = 0; y < ymax ; y++){
     406         sc_uint<address_width> offset  = cluster(x,y) << (address_width-x_width-y_width);
     407         std::ostringstream sh;
     408         sh << "x_seg_memc_" << x << "_" << y;
     409         maptabx.add(Segment(sh.str(), MEMC_BASE+offset, MEMC_SIZE, IntTab(cluster(x,y)), false));
     410      }
     411   }
     412   std::cout << maptabx << std::endl;
     413
     414   ////////////////////
     415   // Signals
     416   ///////////////////
     417
     418   sc_clock      signal_clk("clk");
     419   sc_signal<bool>    signal_resetn("resetn");
     420
     421   // Horizontal inter-clusters DSPIN signals
     422   DspinSignals<cmd_width>*** signal_dspin_h_cmd_inc =
    462423      alloc_elems<DspinSignals<cmd_width> >("signal_dspin_h_cmd_inc", xmax-1, ymax, 2);
    463     DspinSignals<cmd_width>*** signal_dspin_h_cmd_dec =
     424   DspinSignals<cmd_width>*** signal_dspin_h_cmd_dec =
    464425      alloc_elems<DspinSignals<cmd_width> >("signal_dspin_h_cmd_dec", xmax-1, ymax, 2);
    465     DspinSignals<rsp_width>*** signal_dspin_h_rsp_inc =
     426   DspinSignals<rsp_width>*** signal_dspin_h_rsp_inc =
    466427      alloc_elems<DspinSignals<rsp_width> >("signal_dspin_h_rsp_inc", xmax-1, ymax, 2);
    467     DspinSignals<rsp_width>*** signal_dspin_h_rsp_dec =
     428   DspinSignals<rsp_width>*** signal_dspin_h_rsp_dec =
    468429      alloc_elems<DspinSignals<rsp_width> >("signal_dspin_h_rsp_dec", xmax-1, ymax, 2);
    469430
    470     // Vertical inter-clusters DSPIN signals
    471     DspinSignals<cmd_width>*** signal_dspin_v_cmd_inc =
    472         alloc_elems<DspinSignals<cmd_width> >("signal_dspin_v_cmd_inc", xmax, ymax-1, 2);
    473     DspinSignals<cmd_width>*** signal_dspin_v_cmd_dec =
    474         alloc_elems<DspinSignals<cmd_width> >("signal_dspin_v_cmd_dec", xmax, ymax-1, 2);
    475     DspinSignals<rsp_width>*** signal_dspin_v_rsp_inc =
    476         alloc_elems<DspinSignals<rsp_width> >("signal_dspin_v_rsp_inc", xmax, ymax-1, 2);
    477     DspinSignals<rsp_width>*** signal_dspin_v_rsp_dec =
    478         alloc_elems<DspinSignals<rsp_width> >("signal_dspin_v_rsp_dec", xmax, ymax-1, 2);
    479 
    480     // Mesh boundaries DSPIN signals
    481     DspinSignals<cmd_width>**** signal_dspin_false_cmd_in =
    482         alloc_elems<DspinSignals<cmd_width> >("signal_dspin_false_cmd_in", xmax, ymax, 2, 4);
    483     DspinSignals<cmd_width>**** signal_dspin_false_cmd_out =
    484         alloc_elems<DspinSignals<cmd_width> >("signal_dspin_false_cmd_out", xmax, ymax, 2, 4);
    485     DspinSignals<rsp_width>**** signal_dspin_false_rsp_in =
    486         alloc_elems<DspinSignals<rsp_width> >("signal_dspin_false_rsp_in", xmax, ymax, 2, 4);
    487     DspinSignals<rsp_width>**** signal_dspin_false_rsp_out =
    488         alloc_elems<DspinSignals<rsp_width> >("signal_dspin_false_rsp_out", xmax, ymax, 2, 4);
    489 
    490 
    491     ////////////////////////////
    492     //      Components
    493     ////////////////////////////
     431   // Vertical inter-clusters DSPIN signals
     432   DspinSignals<cmd_width>*** signal_dspin_v_cmd_inc =
     433      alloc_elems<DspinSignals<cmd_width> >("signal_dspin_v_cmd_inc", xmax, ymax-1, 2);
     434   DspinSignals<cmd_width>*** signal_dspin_v_cmd_dec =
     435      alloc_elems<DspinSignals<cmd_width> >("signal_dspin_v_cmd_dec", xmax, ymax-1, 2);
     436   DspinSignals<rsp_width>*** signal_dspin_v_rsp_inc =
     437      alloc_elems<DspinSignals<rsp_width> >("signal_dspin_v_rsp_inc", xmax, ymax-1, 2);
     438   DspinSignals<rsp_width>*** signal_dspin_v_rsp_dec =
     439      alloc_elems<DspinSignals<rsp_width> >("signal_dspin_v_rsp_dec", xmax, ymax-1, 2);
     440
     441   // Mesh boundaries DSPIN signals
     442   DspinSignals<cmd_width>**** signal_dspin_false_cmd_in =
     443      alloc_elems<DspinSignals<cmd_width> >("signal_dspin_false_cmd_in", xmax, ymax, 2, 4);
     444   DspinSignals<cmd_width>**** signal_dspin_false_cmd_out =
     445      alloc_elems<DspinSignals<cmd_width> >("signal_dspin_false_cmd_out", xmax, ymax, 2, 4);
     446   DspinSignals<rsp_width>**** signal_dspin_false_rsp_in =
     447      alloc_elems<DspinSignals<rsp_width> >("signal_dspin_false_rsp_in", xmax, ymax, 2, 4);
     448   DspinSignals<rsp_width>**** signal_dspin_false_rsp_out =
     449      alloc_elems<DspinSignals<rsp_width> >("signal_dspin_false_rsp_out", xmax, ymax, 2, 4);
     450
     451
     452   ////////////////////////////
     453   //      Components
     454   ////////////////////////////
    494455
    495456#if USE_ALMOS
    496     soclib::common::Loader loader(almos_bootloader_pathname,
    497                                   almos_archinfo_pathname,
    498                                   almos_kernel_pathname);
     457   soclib::common::Loader loader(almos_bootloader_pathname,
     458         almos_archinfo_pathname,
     459         almos_kernel_pathname);
    499460#else
    500     soclib::common::Loader loader(soft_name);
     461   soclib::common::Loader loader(soft_name);
    501462#endif
    502463
    503     typedef soclib::common::GdbServer<soclib::common::Mips32ElIss> proc_iss;
    504     proc_iss::set_loader(loader);
    505 
    506     TsarV4ClusterMmu<vci_param, proc_iss, cmd_width, rsp_width>* clusters[xmax][ymax];
     464   typedef soclib::common::GdbServer<soclib::common::Mips32ElIss> proc_iss;
     465   proc_iss::set_loader(loader);
     466
     467   TsarV4ClusterMmu<vci_param, proc_iss, cmd_width, rsp_width>* clusters[xmax][ymax];
    507468
    508469#if USE_OPENMP
    509470
    510471#pragma omp parallel
    511 {
     472   {
    512473#pragma omp for
    513     for( size_t i = 0 ; i  < (xmax * ymax); i++)
    514     {
    515         size_t x = i / ymax;
    516         size_t y = i % ymax;
     474      for(size_t i = 0; i  < (xmax * ymax); i++){
     475         size_t x = i / ymax;
     476         size_t y = i % ymax;
    517477
    518478#pragma omp critical
    519         std::ostringstream sc;
    520         sc << "cluster_" << x << "_" << y;
    521         clusters[x][y] = new TsarV4ClusterMmu<vci_param, proc_iss, cmd_width, rsp_width>
    522             (sc.str().c_str(),
     479         std::ostringstream sc;
     480         sc << "cluster_" << x << "_" << y;
     481         clusters[x][y] = new TsarV4ClusterMmu<vci_param, proc_iss, cmd_width, rsp_width>
     482            (sc.str().c_str(),
    523483             nprocs,
    524              x,
    525              y,
    526              cluster(x,y),
    527              maptabd,
    528              maptabc,
    529              maptabx,
    530              x_width,
    531              y_width,
    532              MEMC_TGTID,
    533              XICU_TGTID,
    534              FBUF_TGTID,
    535              MTTY_TGTID,
    536              BROM_TGTID,
    537              BDEV_TGTID,
    538              CDMA_TGTID,
     484             x,
     485             y,
     486             cluster(x,y),
     487             maptabd,
     488             maptabc,
     489             maptabx,
     490             x_width,
     491             y_width,
     492             MEMC_TGTID,
     493             XICU_TGTID,
     494             FBUF_TGTID,
     495             MTTY_TGTID,
     496             BROM_TGTID,
     497             BDEV_TGTID,
     498             CDMA_TGTID,
    539499             memc_ways,
    540500             memc_sets,
    … …  
    544504             l1_d_sets,
    545505             xram_latency,
    546              (cluster(x,y) == cluster_io_index),
    547              xfb,
    548              yfb,
    549              disk_name,
    550              blk_size,
    551              loader,
     506             (cluster(x,y) == cluster_io_index),
     507             xfb,
     508             yfb,
     509             disk_name,
     510             blk_size,
     511             loader,
    552512             frozen_cycles,
    553513             from_cycle,
    554514             trace_ok and (cluster_io_index == cluster(x,y)) );
    555         }
     515      }
     516   }
    556517
    557518#else  // NO OPENMP
    558519
    559     for( size_t x = 0 ; x  < xmax ; x++)
    560     {
    561         for( size_t y = 0 ; y < ymax ; y++ )
    562         {
    563 
    564 std::cout << "building cluster_" << x << "_" << y << std::endl;
    565 
    566             std::ostringstream sc;
    567             sc << "cluster_" << x << "_" << y;
    568             clusters[x][y] = new TsarV4ClusterMmu<vci_param, proc_iss, cmd_width, rsp_width>
    569             (sc.str().c_str(),
     520   for (size_t x = 0; x  < xmax; x++){
     521      for (size_t y = 0; y < ymax; y++){
     522
     523         std::cout << "building cluster_" << x << "_" << y << std::endl;
     524
     525         std::ostringstream sc;
     526         sc << "cluster_" << x << "_" << y;
     527         clusters[x][y] = new TsarV4ClusterMmu<vci_param, proc_iss, cmd_width, rsp_width>
     528            (sc.str().c_str(),
    570529             nprocs,
    571              x,
    572              y,
    573              cluster(x,y),
    574              maptabd,
    575              maptabc,
    576              maptabx,
    577              x_width,
    578              y_width,
    579              MEMC_TGTID,
    580              XICU_TGTID,
    581              FBUF_TGTID,
    582              MTTY_TGTID,
    583              BROM_TGTID,
    584              BDEV_TGTID,
    585              CDMA_TGTID,
     530             x,
     531             y,
     532             cluster(x,y),
     533             maptabd,
     534             maptabc,
     535             maptabx,
     536             x_width,
     537             y_width,
     538             MEMC_TGTID,
     539             XICU_TGTID,
     540             FBUF_TGTID,
     541             MTTY_TGTID,
     542             BROM_TGTID,
     543             BDEV_TGTID,
     544             CDMA_TGTID,
    586545             memc_ways,
    587546             memc_sets,
    … …  
    591550             l1_d_sets,
    592551             xram_latency,
    593              (cluster(x,y) == cluster_io_index),
    594              xfb,
    595              yfb,
    596              disk_name,
    597              blk_size,
    598              loader,
     552             (cluster(x,y) == cluster_io_index),
     553             xfb,
     554             yfb,
     555             disk_name,
     556             blk_size,
     557             loader,
    599558             frozen_cycles,
    600559             from_cycle,
    601560             trace_ok and (cluster_io_index == cluster(x,y)) );
    602561
    603 std::cout << "cluster_" << x << "_" << y << " constructed" << std::endl;
    604 
    605         }
    606     }
    607    
    608 #endif  // USE_OPENMP
    609 
    610     ///////////////////////////////////////////////////////////////
    611     //     Net-list
    612     ///////////////////////////////////////////////////////////////
    613 
    614     // Clock & RESET
    615     for ( size_t x = 0 ; x < (xmax) ; x++ )
    616     {
    617         for ( size_t y = 0 ; y < ymax ; y++ )
    618         {
    619             clusters[x][y]->p_clk                       (signal_clk);
    620             clusters[x][y]->p_resetn                    (signal_resetn);
    621         }
    622     }
    623 
    624     // Inter Clusters horizontal connections
    625     if ( xmax > 1 )
    626     {
    627         for ( size_t x = 0 ; x < (xmax-1) ; x++ )
    628         {
    629             for ( size_t y = 0 ; y < ymax ; y++ )
    630             {
    631                 for ( size_t k = 0 ; k < 2 ; k++ )
    632                 {
    633                 clusters[x][y]->p_cmd_out[k][EAST]      (signal_dspin_h_cmd_inc[x][y][k]);
    634                 clusters[x+1][y]->p_cmd_in[k][WEST]     (signal_dspin_h_cmd_inc[x][y][k]);
    635                 clusters[x][y]->p_cmd_in[k][EAST]       (signal_dspin_h_cmd_dec[x][y][k]);
    636                 clusters[x+1][y]->p_cmd_out[k][WEST]    (signal_dspin_h_cmd_dec[x][y][k]);
    637                 clusters[x][y]->p_rsp_out[k][EAST]      (signal_dspin_h_rsp_inc[x][y][k]);
    638                 clusters[x+1][y]->p_rsp_in[k][WEST]     (signal_dspin_h_rsp_inc[x][y][k]);
    639                 clusters[x][y]->p_rsp_in[k][EAST]       (signal_dspin_h_rsp_dec[x][y][k]);
    640                 clusters[x+1][y]->p_rsp_out[k][WEST]    (signal_dspin_h_rsp_dec[x][y][k]);
    641                 }
     562         std::cout << "cluster_" << x << "_" << y << " constructed" << std::endl;
     563
     564      }
     565   }
     566
     567#endif   // USE_OPENMP
     568
     569   ///////////////////////////////////////////////////////////////
     570   //     Net-list
     571   ///////////////////////////////////////////////////////////////
     572
     573   // Clock & RESET
     574   for (size_t x = 0; x < (xmax); x++){
     575      for (size_t y = 0; y < ymax; y++){
     576         clusters[x][y]->p_clk     (signal_clk);
     577         clusters[x][y]->p_resetn  (signal_resetn);
     578      }
     579   }
     580
     581   // Inter Clusters horizontal connections
     582   if (xmax > 1){
     583      for (size_t x = 0; x < (xmax-1); x++){
     584         for (size_t y = 0; y < ymax; y++){
     585            for (size_t k = 0; k < 2; k++){
     586               clusters[x][y]->p_cmd_out[k][EAST]      (signal_dspin_h_cmd_inc[x][y][k]);
     587               clusters[x+1][y]->p_cmd_in[k][WEST]     (signal_dspin_h_cmd_inc[x][y][k]);
     588               clusters[x][y]->p_cmd_in[k][EAST]       (signal_dspin_h_cmd_dec[x][y][k]);
     589               clusters[x+1][y]->p_cmd_out[k][WEST]    (signal_dspin_h_cmd_dec[x][y][k]);
     590               clusters[x][y]->p_rsp_out[k][EAST]      (signal_dspin_h_rsp_inc[x][y][k]);
     591               clusters[x+1][y]->p_rsp_in[k][WEST]     (signal_dspin_h_rsp_inc[x][y][k]);
     592               clusters[x][y]->p_rsp_in[k][EAST]       (signal_dspin_h_rsp_dec[x][y][k]);
     593               clusters[x+1][y]->p_rsp_out[k][WEST]    (signal_dspin_h_rsp_dec[x][y][k]);
    642594            }
    643         }
    644     }
    645     std::cout << "Horizontal connections established" << std::endl;     
    646 
    647     // Inter Clusters vertical connections
    648     if ( ymax > 1 )
    649     {
    650         for ( size_t y = 0 ; y < (ymax-1) ; y++ )
    651         {
    652             for ( size_t x = 0 ; x < xmax ; x++ )
    653             {
    654                 for ( size_t k = 0 ; k < 2 ; k++ )
    655                 {
    656                 clusters[x][y]->p_cmd_out[k][NORTH]     (signal_dspin_v_cmd_inc[x][y][k]);
    657                 clusters[x][y+1]->p_cmd_in[k][SOUTH]    (signal_dspin_v_cmd_inc[x][y][k]);
    658                 clusters[x][y]->p_cmd_in[k][NORTH]      (signal_dspin_v_cmd_dec[x][y][k]);
    659                 clusters[x][y+1]->p_cmd_out[k][SOUTH]   (signal_dspin_v_cmd_dec[x][y][k]);
    660                 clusters[x][y]->p_rsp_out[k][NORTH]     (signal_dspin_v_rsp_inc[x][y][k]);
    661                 clusters[x][y+1]->p_rsp_in[k][SOUTH]    (signal_dspin_v_rsp_inc[x][y][k]);
    662                 clusters[x][y]->p_rsp_in[k][NORTH]      (signal_dspin_v_rsp_dec[x][y][k]);
    663                 clusters[x][y+1]->p_rsp_out[k][SOUTH]   (signal_dspin_v_rsp_dec[x][y][k]);
    664                 }
     595         }
     596      }
     597   }
     598   std::cout << "Horizontal connections established" << std::endl;   
     599
     600   // Inter Clusters vertical connections
     601   if (ymax > 1) {
     602      for (size_t y = 0; y < (ymax-1); y++){
     603         for (size_t x = 0; x < xmax; x++){
     604            for (size_t k = 0; k < 2; k++){
     605               clusters[x][y]->p_cmd_out[k][NORTH]     (signal_dspin_v_cmd_inc[x][y][k]);
     606               clusters[x][y+1]->p_cmd_in[k][SOUTH]    (signal_dspin_v_cmd_inc[x][y][k]);
     607               clusters[x][y]->p_cmd_in[k][NORTH]      (signal_dspin_v_cmd_dec[x][y][k]);
     608               clusters[x][y+1]->p_cmd_out[k][SOUTH]   (signal_dspin_v_cmd_dec[x][y][k]);
     609               clusters[x][y]->p_rsp_out[k][NORTH]     (signal_dspin_v_rsp_inc[x][y][k]);
     610               clusters[x][y+1]->p_rsp_in[k][SOUTH]    (signal_dspin_v_rsp_inc[x][y][k]);
     611               clusters[x][y]->p_rsp_in[k][NORTH]      (signal_dspin_v_rsp_dec[x][y][k]);
     612               clusters[x][y+1]->p_rsp_out[k][SOUTH]   (signal_dspin_v_rsp_dec[x][y][k]);
    665613            }
    666         }
    667     }
    668     std::cout << "Vertical connections established" << std::endl;
    669 
    670     // East & West boundary cluster connections
    671     for ( size_t y = 0 ; y < ymax ; y++ )
    672     {
    673         for ( size_t k = 0 ; k < 2 ; k++ )
    674         {
    675             clusters[0][y]->p_cmd_in[k][WEST]           (signal_dspin_false_cmd_in[0][y][k][WEST]);
    676             clusters[0][y]->p_cmd_out[k][WEST]          (signal_dspin_false_cmd_out[0][y][k][WEST]);
    677             clusters[0][y]->p_rsp_in[k][WEST]           (signal_dspin_false_rsp_in[0][y][k][WEST]);
    678             clusters[0][y]->p_rsp_out[k][WEST]          (signal_dspin_false_rsp_out[0][y][k][WEST]);
    679          
    680             clusters[xmax-1][y]->p_cmd_in[k][EAST]      (signal_dspin_false_cmd_in[xmax-1][y][k][EAST]);
    681             clusters[xmax-1][y]->p_cmd_out[k][EAST]     (signal_dspin_false_cmd_out[xmax-1][y][k][EAST]);
    682             clusters[xmax-1][y]->p_rsp_in[k][EAST]      (signal_dspin_false_rsp_in[xmax-1][y][k][EAST]);
    683             clusters[xmax-1][y]->p_rsp_out[k][EAST]     (signal_dspin_false_rsp_out[xmax-1][y][k][EAST]);
    684         }
    685     }
    686    
    687     // North & South boundary clusters connections
    688     for ( size_t x = 0 ; x < xmax ; x++ )
    689     {
    690         for ( size_t k = 0 ; k < 2 ; k++ )
    691         {
    692             clusters[x][0]->p_cmd_in[k][SOUTH]          (signal_dspin_false_cmd_in[x][0][k][SOUTH]);
    693             clusters[x][0]->p_cmd_out[k][SOUTH]         (signal_dspin_false_cmd_out[x][0][k][SOUTH]);
    694             clusters[x][0]->p_rsp_in[k][SOUTH]          (signal_dspin_false_rsp_in[x][0][k][SOUTH]);
    695             clusters[x][0]->p_rsp_out[k][SOUTH]         (signal_dspin_false_rsp_out[x][0][k][SOUTH]);
    696            
    697             clusters[x][ymax-1]->p_cmd_in[k][NORTH]     (signal_dspin_false_cmd_in[x][ymax-1][k][NORTH]);
    698             clusters[x][ymax-1]->p_cmd_out[k][NORTH]    (signal_dspin_false_cmd_out[x][ymax-1][k][NORTH]);
    699             clusters[x][ymax-1]->p_rsp_in[k][NORTH]     (signal_dspin_false_rsp_in[x][ymax-1][k][NORTH]);
    700             clusters[x][ymax-1]->p_rsp_out[k][NORTH]    (signal_dspin_false_rsp_out[x][ymax-1][k][NORTH]);
    701         }
    702     }
    703      
    704 
    705     ////////////////////////////////////////////////////////
    706     //   Simulation
    707     ///////////////////////////////////////////////////////
    708 
    709     sc_start(sc_core::sc_time(0, SC_NS));
    710     signal_resetn = false;
    711 
    712     // network boundaries signals
    713     for(size_t x=0; x<xmax ; x++)
    714     {
    715         for(size_t y=0 ; y<ymax ; y++)
    716         {
    717             for (size_t k=0; k<2; k++)
    718             {
    719                 for(size_t a=0; a<4; a++)
    720                 {
    721                         signal_dspin_false_cmd_in[x][y][k][a].write = false;
    722                         signal_dspin_false_cmd_in[x][y][k][a].read = true;
    723                         signal_dspin_false_cmd_out[x][y][k][a].write = false;
    724                         signal_dspin_false_cmd_out[x][y][k][a].read = true;
    725 
    726                         signal_dspin_false_rsp_in[x][y][k][a].write = false;
    727                         signal_dspin_false_rsp_in[x][y][k][a].read = true;
    728                         signal_dspin_false_rsp_out[x][y][k][a].write = false;
    729                         signal_dspin_false_rsp_out[x][y][k][a].read = true;
    730                 }
     614         }
     615      }
     616   }
     617   std::cout << "Vertical connections established" << std::endl;
     618
     619   // East & West boundary cluster connections
     620   for (size_t y = 0; y < ymax; y++){
     621      for (size_t k = 0; k < 2; k++){
     622         clusters[0][y]->p_cmd_in[k][WEST]          (signal_dspin_false_cmd_in[0][y][k][WEST]);
     623         clusters[0][y]->p_cmd_out[k][WEST]         (signal_dspin_false_cmd_out[0][y][k][WEST]);
     624         clusters[0][y]->p_rsp_in[k][WEST]          (signal_dspin_false_rsp_in[0][y][k][WEST]);
     625         clusters[0][y]->p_rsp_out[k][WEST]         (signal_dspin_false_rsp_out[0][y][k][WEST]);
     626
     627         clusters[xmax-1][y]->p_cmd_in[k][EAST]     (signal_dspin_false_cmd_in[xmax-1][y][k][EAST]);
     628         clusters[xmax-1][y]->p_cmd_out[k][EAST]    (signal_dspin_false_cmd_out[xmax-1][y][k][EAST]);
     629         clusters[xmax-1][y]->p_rsp_in[k][EAST]     (signal_dspin_false_rsp_in[xmax-1][y][k][EAST]);
     630         clusters[xmax-1][y]->p_rsp_out[k][EAST]    (signal_dspin_false_rsp_out[xmax-1][y][k][EAST]);
     631      }
     632   }
     633
     634   // North & South boundary clusters connections
     635   for (size_t x = 0; x < xmax; x++){
     636      for (size_t k = 0; k < 2; k++){
     637         clusters[x][0]->p_cmd_in[k][SOUTH]         (signal_dspin_false_cmd_in[x][0][k][SOUTH]);
     638         clusters[x][0]->p_cmd_out[k][SOUTH]        (signal_dspin_false_cmd_out[x][0][k][SOUTH]);
     639         clusters[x][0]->p_rsp_in[k][SOUTH]         (signal_dspin_false_rsp_in[x][0][k][SOUTH]);
     640         clusters[x][0]->p_rsp_out[k][SOUTH]        (signal_dspin_false_rsp_out[x][0][k][SOUTH]);
     641
     642         clusters[x][ymax-1]->p_cmd_in[k][NORTH]    (signal_dspin_false_cmd_in[x][ymax-1][k][NORTH]);
     643         clusters[x][ymax-1]->p_cmd_out[k][NORTH]   (signal_dspin_false_cmd_out[x][ymax-1][k][NORTH]);
     644         clusters[x][ymax-1]->p_rsp_in[k][NORTH]    (signal_dspin_false_rsp_in[x][ymax-1][k][NORTH]);
     645         clusters[x][ymax-1]->p_rsp_out[k][NORTH]   (signal_dspin_false_rsp_out[x][ymax-1][k][NORTH]);
     646      }
     647   }
     648
     649
     650   ////////////////////////////////////////////////////////
     651   //   Simulation
     652   ///////////////////////////////////////////////////////
     653
     654   sc_start(sc_core::sc_time(0, SC_NS));
     655   signal_resetn = false;
     656
     657   // network boundaries signals
     658   for (size_t x = 0; x < xmax ; x++){
     659      for (size_t y = 0; y < ymax ; y++){
     660         for (size_t k = 0; k < 2; k++){
     661            for (size_t a = 0; a < 4; a++){
     662               signal_dspin_false_cmd_in[x][y][k][a].write = false;
     663               signal_dspin_false_cmd_in[x][y][k][a].read = true;
     664               signal_dspin_false_cmd_out[x][y][k][a].write = false;
     665               signal_dspin_false_cmd_out[x][y][k][a].read = true;
     666
     667               signal_dspin_false_rsp_in[x][y][k][a].write = false;
     668               signal_dspin_false_rsp_in[x][y][k][a].read = true;
     669               signal_dspin_false_rsp_out[x][y][k][a].write = false;
     670               signal_dspin_false_rsp_out[x][y][k][a].read = true;
    731671            }
    732         }
    733     }
    734 
    735     sc_start(sc_core::sc_time(1, SC_NS));
    736     signal_resetn = true;
    737 
    738     for ( size_t n=1 ; n<ncycles ; n++)
    739     {
    740         if ( trace_ok and (n > from_cycle) and (n%trace_period == 0) )
    741         {
    742             std::cout << "****************** cycle " << std::dec << n ;
    743             std::cout << " ************************************************" << std::endl;
    744 
    745             // components cluster 00 /////////////////////
    746 //            clusters[0][0]->proc[0]->print_trace();
    747 //            clusters[0][0]->memc->print_trace();
    748 
    749             // signals cluster 00 ////////////////////////
    750 //            clusters[0][0]->signal_vci_ini_d_proc[0].print_trace("proc_0_0_0_ini_d");
    751 //            clusters[0][0]->signal_vci_ini_c_proc[0].print_trace("proc_0_0_0_ini_c");
    752 //            clusters[0][0]->signal_vci_tgt_c_proc[0].print_trace("proc_0_0_0_tgt_c");
    753 //            clusters[0][0]->signal_vci_xram.print_trace("memc_0_0_xram");
    754 
    755             // components cluster 01 /////////////////////
    756 //            clusters[0][1]->proc[0]->print_trace();
    757 //            clusters[0][1]->memc->print_trace();
    758 
    759             // signals cluster 01 ///////////////////////
    760 //            clusters[0][1]->signal_vci_ini_d_proc[0].print_trace("proc_0_1_0_ini_d");
    761 //            clusters[0][1]->signal_vci_ini_c_proc[0].print_trace("proc_0_1_0_ini_c");
    762 //            clusters[0][1]->signal_vci_tgt_c_proc[0].print_trace("proc_0_1_0_tgt_c");
    763 //            clusters[0][1]->signal_vci_xram.print_trace("memc_0_1_xram");
    764 
    765             // components cluster 10 ////////////////////
    766             clusters[1][0]->proc[0]->print_trace(1);
    767             clusters[1][0]->memc->print_trace();
    768 //            clusters[1][0]->bdev->print_trace();
    769 //            clusters[1][0]->mdma->print_trace();
    770 
    771             // signals cluster 10 ///////////////////////
    772             clusters[1][0]->signal_vci_ini_d_proc[0].print_trace("proc_1_0_0_ini_d");
    773 //            clusters[1][0]->signal_vci_ini_c_proc[0].print_trace("proc_1_0_0_ini_c");
    774 //            clusters[1][0]->signal_vci_tgt_c_proc[0].print_trace("proc_1_0_0_tgt_c");
    775             clusters[1][0]->signal_vci_tgt_d_memc.print_trace("memc_1_0_tgt_d  ");
    776 //            clusters[1][0]->signal_vci_ini_c_memc.print_trace("memc_1_0_ini_c  ");
    777 //            clusters[1][0]->signal_vci_tgt_c_memc.print_trace("memc_1_0_tgt_c  ");
    778 //            clusters[1][0]->signal_vci_tgt_d_bdev.print_trace("bdev_1_0_tgt_d  ");
    779 //            clusters[1][0]->signal_vci_ini_d_bdev.print_trace("bdev_1_0_ini_d  ");
    780 //            clusters[1][0]->signal_vci_tgt_d_mdma.print_trace("mdma_1_0_tgt_d  ");
    781 //            clusters[1][0]->signal_vci_ini_d_mdma.print_trace("mdma_1_0_ini_d  ");
    782             clusters[1][0]->signal_vci_tgt_d_mtty.print_trace("mtty_1_0_tgt_d  ");
    783             clusters[1][0]->signal_vci_xram.print_trace("memc_1_0_xram");
    784  
    785             // components cluster 11 /////////////////////
    786 //            clusters[1][1]->proc[0]->print_trace();
    787 //            clusters[1][1]->memc->print_trace();
    788            
    789             // signals cluster 11 ////////////////////////
    790 //            clusters[1][1]->signal_vci_ini_d_proc[0].print_trace("proc_1_1_0_ini_d");
    791 //            clusters[1][1]->signal_vci_ini_c_proc[0].print_trace("proc_1_1_0_ini_c");
    792 //            clusters[1][1]->signal_vci_tgt_c_proc[0].print_trace("proc_1_1_0_tgt_c");
    793 //            clusters[1][1]->signal_vci_xram.print_trace("memc_1_1_xram");
    794         }
    795 
    796         sc_start(sc_core::sc_time(1, SC_NS));
    797     }
    798     return EXIT_SUCCESS;
     672         }
     673      }
     674   }
     675
     676   sc_start(sc_core::sc_time(1, SC_NS));
     677   signal_resetn = true;
     678
     679   for (size_t n = 1; n < ncycles; n++){
     680      if (trace_ok and (n > from_cycle) and (n % trace_period == 0)){
     681         std::cout << "****************** cycle " << std::dec << n ;
     682         std::cout << " ************************************************" << std::endl;
     683
     684         // components cluster 00 /////////////////////
     685         //            clusters[0][0]->proc[0]->print_trace();
     686         //            clusters[0][0]->memc->print_trace();
     687
     688         // signals cluster 00 ////////////////////////
     689         //            clusters[0][0]->signal_vci_ini_d_proc[0].print_trace("proc_0_0_0_ini_d");
     690         //            clusters[0][0]->signal_vci_ini_c_proc[0].print_trace("proc_0_0_0_ini_c");
     691         //            clusters[0][0]->signal_vci_tgt_c_proc[0].print_trace("proc_0_0_0_tgt_c");
     692         //            clusters[0][0]->signal_vci_xram.print_trace("memc_0_0_xram");
     693
     694         // components cluster 01 /////////////////////
     695         //            clusters[0][1]->proc[0]->print_trace();
     696         //            clusters[0][1]->memc->print_trace();
     697
     698         // signals cluster 01 ///////////////////////
     699         //            clusters[0][1]->signal_vci_ini_d_proc[0].print_trace("proc_0_1_0_ini_d");
     700         //            clusters[0][1]->signal_vci_ini_c_proc[0].print_trace("proc_0_1_0_ini_c");
     701         //            clusters[0][1]->signal_vci_tgt_c_proc[0].print_trace("proc_0_1_0_tgt_c");
     702         //            clusters[0][1]->signal_vci_xram.print_trace("memc_0_1_xram");
     703
     704         // components cluster 10 ////////////////////
     705         clusters[1][0]->proc[0]->print_trace(1);
     706         clusters[1][0]->memc->print_trace();
     707         //            clusters[1][0]->bdev->print_trace();
     708         //            clusters[1][0]->mdma->print_trace();
     709
     710         // signals cluster 10 ///////////////////////
     711         clusters[1][0]->signal_vci_ini_d_proc[0].print_trace("proc_1_0_0_ini_d");
     712         //            clusters[1][0]->signal_vci_ini_c_proc[0].print_trace("proc_1_0_0_ini_c");
     713         //            clusters[1][0]->signal_vci_tgt_c_proc[0].print_trace("proc_1_0_0_tgt_c");
     714         clusters[1][0]->signal_vci_tgt_d_memc.print_trace("memc_1_0_tgt_d  ");
     715         //            clusters[1][0]->signal_vci_ini_c_memc.print_trace("memc_1_0_ini_c  ");
     716         //            clusters[1][0]->signal_vci_tgt_c_memc.print_trace("memc_1_0_tgt_c  ");
     717         //            clusters[1][0]->signal_vci_tgt_d_bdev.print_trace("bdev_1_0_tgt_d  ");
     718         //            clusters[1][0]->signal_vci_ini_d_bdev.print_trace("bdev_1_0_ini_d  ");
     719         //            clusters[1][0]->signal_vci_tgt_d_mdma.print_trace("mdma_1_0_tgt_d  ");
     720         //            clusters[1][0]->signal_vci_ini_d_mdma.print_trace("mdma_1_0_ini_d  ");
     721         clusters[1][0]->signal_vci_tgt_d_mtty.print_trace("mtty_1_0_tgt_d  ");
     722         clusters[1][0]->signal_vci_xram.print_trace("memc_1_0_xram");
     723
     724         // components cluster 11 /////////////////////
     725         //            clusters[1][1]->proc[0]->print_trace();
     726         //            clusters[1][1]->memc->print_trace();
     727
     728         // signals cluster 11 ////////////////////////
     729         //            clusters[1][1]->signal_vci_ini_d_proc[0].print_trace("proc_1_1_0_ini_d");
     730         //            clusters[1][1]->signal_vci_ini_c_proc[0].print_trace("proc_1_1_0_ini_c");
     731         //            clusters[1][1]->signal_vci_tgt_c_proc[0].print_trace("proc_1_1_0_tgt_c");
     732         //            clusters[1][1]->signal_vci_xram.print_trace("memc_1_1_xram");
     733      }
     734
     735      sc_start(sc_core::sc_time(1, SC_NS));
     736   }
     737   return EXIT_SUCCESS;
    799738}
    800739
    801740int sc_main (int argc, char *argv[])
    802741{
    803         try {
    804                 return _main(argc, argv);
    805         } catch (std::exception &e) {
    806                 std::cout << e.what() << std::endl;
    807         } catch (...) {
    808                 std::cout << "Unknown exception occured" << std::endl;
    809                 throw;
    810         }
    811         return 1;
     742   try {
     743      return _main(argc, argv);
     744   } catch (std::exception &e) {
     745      std::cout << e.what() << std::endl;
     746   } catch (...) {
     747      std::cout << "Unknown exception occured" << std::endl;
     748      throw;
     749   }
     750   return 1;
    812751}
     752
     753
     754// Local Variables:
     755// tab-width: 3
     756// c-basic-offset: 3
     757// c-file-offsets:((innamespace . 0)(inline-open . 0))
     758// indent-tabs-mode: nil
     759// End:
     760
     761// vim: filetype=cpp:expandtab:shiftwidth=3:tabstop=3:softtabstop=3
     762
     763
     764
     765
Note: See TracChangeset for help on using the changeset viewer.