Index: trunk/platforms/tsarv4_generic_mmu/top.cpp
===================================================================
--- trunk/platforms/tsarv4_generic_mmu/top.cpp	(revision 249)
+++ trunk/platforms/tsarv4_generic_mmu/top.cpp	(revision 255)
@@ -3,5 +3,5 @@
 // Author: Alain Greiner 
 // Copyright: UPMC/LIP6
-// Date : june 2011
+// Date : august 2012
 // This program is released under the GNU public license
 /////////////////////////////////////////////////////////////////////////
@@ -11,24 +11,28 @@
 // - It uses the vci_cc_vcache_wrapper_v4 
 // - It uses the vci_mem_cache_v4
-// - It uses one vci_xicu, one vci_multi_tty, 
-//   and one vci_multi_dma controler per cluster.
-// 
+// - It contains one vci_xicu and one vci_multi_dma per cluster.
+// The peripherals BDEV, FBUF, MTTY, and the boot BROM
+// are in the cluster containing address 0xBFC00000.
+//
 // It is build with one single component implementing a cluster:
 // The Tsarv4ClusterMmu component is defined in files
 // tsarv4_cluster_mmu.* (with * = cpp, h, sd)
 //
+// The IRQs are connected to XICUs as follow:
+// - The IRQ_IN[0] to IRQ_IN[7] ports are not used in all clusters.
+// - The DMA IRQs are connected to IRQ_IN[8] to IRQ_IN[15] in all clusters.
+// - The TTY IRQs are connected to IRQ_IN[16] to IRQ_IN[30] in I/O cluster.
+// - The BDEV IRQ is connected to IRQ_IN[31] in I/O cluster.
+// 
 // The physical address space is 32 bits.
 // The number of clusters cannot be larger than 256.
-// The number of processors per cluster cannot be larger than 4.
-// The parameters must be power of 2.
-// - xmax   : number of clusters in a row
-// - ymax   : number of clusters in a column
-// - nprocs : number of processors per cluster
+// The number of processors per cluster cannot be larger than 8.
 //
-// The peripherals BDEV, FBUF, and the boot BROM
-// are in the cluster containing address 0xBFC00000.
-// - The nprocs TTY IRQs are connected to IRQ_IN[0] to IRQ_IN[3]
-// - The nprocs DMA IRQs are connected to IRQ_IN[4] to IRQ_IN[7]
-// - The IOC IRQ is connected to IRQ_IN[8]
+// The hardware parameters are :
+// - xmax     : number of clusters in a row (power of 2)
+// - ymax     : number of clusters in a column (power of 2)
+// - nb_procs : number of processors per cluster (power of 2)
+// - nb_dmas  : number of DMA channels per cluster (< 9)
+// - nb_ttys  : number of TTYs in I/O cluster (< 16)
 // 
 // General policy for 32 bits physical address decoding:
@@ -97,28 +101,34 @@
 ///////////////////////////////////////////////////
 
-#define MESH_XMAX      2
-#define MESH_YMAX      2
-
-#define NPROCS         4
-#define XRAM_LATENCY            0
-
-#define MEMC_WAYS               16
-#define MEMC_SETS               256
-
-#define L1_IWAYS                4
-#define L1_ISETS                64
-
-#define L1_DWAYS                4
-#define L1_DSETS                64
-
-#define FBUF_X_SIZE             512
-#define FBUF_Y_SIZE             512
-
-#define   BDEV_SECTOR_SIZE    128
-#define BDEV_IMAGE_NAME           "../../softs/soft_transpose_giet/couple_512.raw"
-
-#define BOOT_SOFT_NAME       "../../softs/soft_transpose_giet/bin.soft"
-
-#define MAX_FROZEN_CYCLES   100000
+#define MESH_XMAX             2
+#define MESH_YMAX             2
+
+#define NB_PROCS              1
+#define NB_TTYS               8
+#define NB_DMAS               1
+
+#define XRAM_LATENCY          0
+
+#define MEMC_WAYS             16
+#define MEMC_SETS             256
+
+#define L1_IWAYS              4
+#define L1_ISETS              64
+
+#define L1_DWAYS              4
+#define L1_DSETS              64
+
+#define FBUF_X_SIZE           128
+#define FBUF_Y_SIZE           128
+
+#define BDEV_SECTOR_SIZE      512
+#define BDEV_IMAGE_NAME       "/Users/alain/Documents/licence/almo_svn_2011/soft/giet_vm/display/images.raw"
+
+#define BOOT_SOFT_NAME        "/Users/alain/Documents/licence/almo_svn_2011/soft/giet_vm/soft.elf"
+
+#define MAX_FROZEN_CYCLES     10000
+
+#define TRACE_MEMC_ID         1000000
+#define TRACE_PROC_ID         1000000
 
 /////////////////////////////////////////////////////////
@@ -132,5 +142,5 @@
 // There is 4 specific segments in the "IO" cluster 
 // (containing address 0xBF000000)
-// - seg_reset   -> BROM / BASE = 0xBFC00000   (1 Mbytes)
+// - seg_reset  -> BROM / BASE = 0xBFC00000   (1 Mbytes)
 // - seg_fbuf   -> FBUF / BASE = 0xBFD00000   (2 M bytes)
 // - seg_bdev   -> BDEV / BASE = 0xBFF10000
@@ -142,19 +152,20 @@
 ///////////////////////////////////////////////////
 
-// specific segments in "IO" cluster
+// specific segments in "IO" cluster : absolute physical address
 
 #define BROM_BASE               0xBFC00000      
 #define BROM_SIZE               0x00100000
 
-#define FBUF_BASE               0xBFD00000      
+#define FBUF_BASE               0x80D00000      
 #define FBUF_SIZE               0x00200000
 
-#define BDEV_BASE               0xBFF10000      
-#define BDEV_SIZE               0x00000020
-
-#define MTTY_BASE               0xBFF20000      
-#define MTTY_SIZE               0x00000040
-
-// replicated segments
+#define BDEV_BASE               0x80F10000      
+#define BDEV_SIZE               0x00001000
+
+#define MTTY_BASE               0x80F20000      
+#define MTTY_SIZE               0x00001000
+
+// replicated segments : physical address is incremented by an offset 
+//     offset  = cluster(x,y) << (address_width-x_width-y_width);
 
 #define MEMC_BASE               0x00000000      
@@ -165,8 +176,5 @@
 
 #define CDMA_BASE               0x00F30000      
-#define CDMA_SIZE               0x00004000
-
-#define PROC_BASE               0x00D00000      
-#define PROC_SIZE               0x00000010
+#define CDMA_SIZE               0x00008000
 
 ////////////////////////////////////////////////////////////////////
@@ -191,10 +199,12 @@
 
 
-   char     soft_name[256] = BOOT_SOFT_NAME;       // pathname to binary code
+   char     soft_name[256] = BOOT_SOFT_NAME;     // pathname to binary code
    size_t   ncycles        = 1000000000;         // simulated cycles
-   size_t   xmax           = MESH_XMAX;       // number of clusters in a row
+   size_t   xmax           = MESH_XMAX;          // number of clusters in a row
    size_t   ymax           = MESH_YMAX;          // number of clusters in a column
-   size_t   nprocs         = NPROCS;         // number of processors per cluster
-   size_t   xfb            = FBUF_X_SIZE;     // frameBuffer column number
+   size_t   nb_procs       = NB_PROCS;           // number of processors per cluster
+   size_t   nb_dmas        = NB_DMAS;            // number of RDMA channels per cluster
+   size_t   nb_ttys        = NB_TTYS;            // number of TTY terminals in I/O cluster
+   size_t   xfb            = FBUF_X_SIZE;        // frameBuffer column number
    size_t   yfb            = FBUF_Y_SIZE;        // frameBuffer lines number
    size_t   memc_ways      = MEMC_WAYS;
@@ -206,22 +216,42 @@
    char     disk_name[256] = BDEV_IMAGE_NAME;    // pathname to the disk image
    size_t   blk_size       = BDEV_SECTOR_SIZE;   // block size (in bytes)
-   size_t   xram_latency   = XRAM_LATENCY;     // external RAM latency
-   bool     trace_ok       = false;              // trace activated
-   size_t   trace_period   = 1;                  // trace period
-   uint32_t from_cycle     = 0;                  // debug start cycle
+   size_t   xram_latency   = XRAM_LATENCY;       // external RAM latency
+   bool     debug_ok       = false;              // trace activated
+   size_t   debug_period   = 1;                  // trace period
+   size_t   debug_memc_id  = TRACE_MEMC_ID;      // index of memc to be traced (cluster_id)  
+   size_t   debug_proc_id  = TRACE_PROC_ID;      // index of proc to be traced
+   uint32_t debug_from     = 0;                  // trace start cycle
    uint32_t frozen_cycles  = MAX_FROZEN_CYCLES;  // monitoring frozen processor
 
    ////////////// command line arguments //////////////////////
-   if (argc > 1){
-      for (int n = 1; n < argc; n = n + 2){
-         if ((strcmp(argv[n],"-NCYCLES") == 0) && (n+1<argc)){
+   if (argc > 1)
+   {
+      for (int n = 1; n < argc; n = n + 2)
+      {
+         if ((strcmp(argv[n],"-NCYCLES") == 0) && (n+1<argc))
+         {
             ncycles = atoi(argv[n+1]);
          }
-         else if ((strcmp(argv[n],"-NPROCS") == 0) && (n+1<argc)){
-            nprocs = atoi(argv[n+1]);
-            assert( ((nprocs == 1) || (nprocs == 2) || (nprocs == 4)) &&
-                  "NPROCS must be equal to 1, 2, or 4");
-         }
-         else if ((strcmp(argv[n],"-XMAX") == 0) && (n+1<argc)){
+         else if ((strcmp(argv[n],"-NPROCS") == 0) && (n+1<argc))
+         {
+            nb_procs = atoi(argv[n+1]);
+            assert( ((nb_procs == 1) || (nb_procs == 2) || 
+                     (nb_procs == 4) || (nb_procs == 8)) &&
+                  "NPROCS must be equal to 1, 2, 4, or 8");
+         }
+         else if ((strcmp(argv[n],"-NTTYS") == 0) && (n+1<argc))
+         {
+            nb_ttys = atoi(argv[n+1]);
+            assert( (nb_ttys < 16) &&
+                   "The number of TTY terminals cannot be larger than 15");
+         }
+         else if ((strcmp(argv[n],"-NDMAS") == 0) && (n+1<argc))
+         {
+            nb_dmas = atoi(argv[n+1]);
+            assert( (nb_dmas < 9) &&
+                   "The number of DMA channels per cluster cannot be larger than 8");
+         }
+         else if ((strcmp(argv[n],"-XMAX") == 0) && (n+1<argc))
+         {
             xmax = atoi(argv[n+1]);
             assert( ((xmax == 1) || (xmax == 2) || (xmax == 4) || (xmax == 8) || (xmax == 16)) 
@@ -229,39 +259,62 @@
          }
 
-         else if ((strcmp(argv[n],"-YMAX") == 0) && (n+1<argc)){
+         else if ((strcmp(argv[n],"-YMAX") == 0) && (n+1<argc))
+         {
             ymax = atoi(argv[n+1]);
             assert( ((ymax == 1) || (ymax == 2) || (ymax == 4) || (ymax == 8) || (ymax == 16)) 
                   && "The YMAX parameter must be 2, 4, 8, or 16" );
          }
-         else if ((strcmp(argv[n],"-XFB") == 0) && (n+1<argc)){
+         else if ((strcmp(argv[n],"-XFB") == 0) && (n+1<argc))
+         {
             xfb = atoi(argv[n+1]);
          }
-         else if ((strcmp(argv[n],"-YFB") == 0) && (n+1<argc) ){
+         else if ((strcmp(argv[n],"-YFB") == 0) && (n+1<argc) )
+         {
             yfb = atoi(argv[n+1]);
          }
-         else if ((strcmp(argv[n],"-SOFT") == 0) && (n+1<argc) ){
+         else if ((strcmp(argv[n],"-SOFT") == 0) && (n+1<argc) )
+         {
             strcpy(soft_name, argv[n+1]);
          }
-         else if ((strcmp(argv[n],"-DISK") == 0) && (n+1<argc) ){
+         else if ((strcmp(argv[n],"-DISK") == 0) && (n+1<argc) )
+         {
             strcpy(disk_name, argv[n+1]);
          }
-         else if ((strcmp(argv[n],"-TRACE") == 0) && (n+1<argc) ){
-            trace_ok = true;
-            from_cycle = atoi(argv[n+1]);
-         }
-         else if ((strcmp(argv[n], "-MCWAYS") == 0) && (n+1 < argc)){
+         else if ((strcmp(argv[n],"-TRACE") == 0) && (n+1<argc) )
+         {
+            debug_ok = true;
+            debug_from = atoi(argv[n+1]);
+         }
+         else if ((strcmp(argv[n],"-MEMCID") == 0) && (n+1<argc) )
+         {
+            debug_memc_id = atoi(argv[n+1]);
+            assert( (debug_memc_id < (xmax*ymax) ) && 
+                   "debug_memc_id larger than XMAX * YMAX" );
+         }
+         else if ((strcmp(argv[n],"-PROCID") == 0) && (n+1<argc) )
+         {
+            debug_proc_id = atoi(argv[n+1]);
+            assert( (debug_proc_id < (xmax*ymax*nb_procs) ) && 
+                   "debug_proc_id larger than XMAX * YMAX * BN_PROCS" );
+         }
+         else if ((strcmp(argv[n], "-MCWAYS") == 0) && (n+1 < argc))
+         {
             memc_ways = atoi(argv[n+1]);
          }
-         else if ((strcmp(argv[n], "-MCSETS") == 0) && (n+1 < argc)){
+         else if ((strcmp(argv[n], "-MCSETS") == 0) && (n+1 < argc))
+         {
             memc_sets = atoi(argv[n+1]);
          }
-         else if ((strcmp(argv[n], "-XLATENCY") == 0) && (n+1 < argc)){
+         else if ((strcmp(argv[n], "-XLATENCY") == 0) && (n+1 < argc))
+         {
             xram_latency = atoi(argv[n+1]);
          }
-         else if ((strcmp(argv[n], "-FROZEN") == 0) && (n+1 < argc)){
+         else if ((strcmp(argv[n], "-FROZEN") == 0) && (n+1 < argc))
+         {
             frozen_cycles = atoi(argv[n+1]);
          }
-         else if ((strcmp(argv[n], "-PERIOD") == 0) && (n+1 < argc)){
-            trace_period = atoi(argv[n+1]);
+         else if ((strcmp(argv[n], "-PERIOD") == 0) && (n+1 < argc))
+         {
+            debug_period = atoi(argv[n+1]);
          }
          else
@@ -274,4 +327,6 @@
             std::cout << "     -NCYCLES number_of_simulated_cycles" << std::endl;
             std::cout << "     -NPROCS number_of_processors_per_cluster" << std::endl;
+            std::cout << "     -NTTYS total_number_of_TTY_terminals" << std::endl;
+            std::cout << "     -NDMAS number_of_DMA_channels_per_cluster" << std::endl;
             std::cout << "     -XMAX number_of_clusters_in_a_row" << std::endl;
             std::cout << "     -YMAX number_of_clusters_in_a_column" << std::endl;
@@ -284,4 +339,6 @@
             std::cout << "     -FROZEN max_number_of_lines" << std::endl;
             std::cout << "     -PERIOD number_of_cycles between trace" << std::endl;
+            std::cout << "     -MEMCID index_memc_to_be_traced" << std::endl;
+            std::cout << "     -PROCID index_proc_to_be_traced" << std::endl;
             exit(0);
          }
@@ -290,7 +347,9 @@
 
    std::cout << std::endl;
-   std::cout << " - NPROCS      = " << nprocs <<  std::endl;
-   std::cout << " - NCLUSTERS   = " << xmax*ymax << std::endl;
-   std::cout << " - MAX FROZEN  = " << frozen_cycles << std::endl;
+   std::cout << " - NB_CLUSTERS = " << xmax*ymax << std::endl;
+   std::cout << " - NB_PROCS    = " << nb_procs <<  std::endl;
+   std::cout << " - NB_TTYS     = " << nb_ttys <<  std::endl;
+   std::cout << " - NB_DMAS     = " << nb_dmas <<  std::endl;
+   std::cout << " - MAX_FROZEN  = " << frozen_cycles << std::endl;
    std::cout << " - MEMC_WAYS   = " << memc_ways << std::endl;
    std::cout << " - MEMC_SETS   = " << memc_sets << std::endl;
@@ -317,5 +376,6 @@
            wrplen_width> vci_param;
 
-   size_t   cluster_io_index;
+   // Define parameters depending on mesh size
+   size_t   cluster_io_id;
    size_t   x_width;
    size_t   y_width;
@@ -333,5 +393,5 @@
    else                y_width = 4;
 
-   cluster_io_index = 0xBF >> (8 - x_width - y_width);
+   cluster_io_id = 0xBF >> (8 - x_width - y_width);
 
    /////////////////////
@@ -345,6 +405,8 @@
          0x00FF0000);
 
-   for (size_t x = 0; x < xmax; x++){
-      for (size_t y = 0; y < ymax; y++){
+   for (size_t x = 0; x < xmax; x++)
+   {
+      for (size_t y = 0; y < ymax; y++)
+      {
          sc_uint<address_width> offset  = cluster(x,y) << (address_width-x_width-y_width);
 
@@ -361,10 +423,10 @@
          maptabd.add(Segment(sd.str(), CDMA_BASE+offset, CDMA_SIZE, IntTab(cluster(x,y),CDMA_TGTID), false));
 
-         if ( cluster(x,y) == cluster_io_index )
-         {
-            maptabd.add(Segment("d_seg_mtty    ", MTTY_BASE, MTTY_SIZE, IntTab(cluster(x,y),MTTY_TGTID), false));
-            maptabd.add(Segment("d_seg_fbuf    ", FBUF_BASE, FBUF_SIZE, IntTab(cluster(x,y),FBUF_TGTID), false));
-            maptabd.add(Segment("d_seg_bdev    ", BDEV_BASE, BDEV_SIZE, IntTab(cluster(x,y),BDEV_TGTID), false));
-            maptabd.add(Segment("d_seg_brom    ", BROM_BASE, BROM_SIZE, IntTab(cluster(x,y),BROM_TGTID), true));
+         if ( cluster(x,y) == cluster_io_id )
+         {
+            maptabd.add(Segment("d_seg_mtty", MTTY_BASE, MTTY_SIZE, IntTab(cluster(x,y),MTTY_TGTID), false));
+            maptabd.add(Segment("d_seg_fbuf", FBUF_BASE, FBUF_SIZE, IntTab(cluster(x,y),FBUF_TGTID), false));
+            maptabd.add(Segment("d_seg_bdev", BDEV_BASE, BDEV_SIZE, IntTab(cluster(x,y),BDEV_TGTID), false));
+            maptabd.add(Segment("d_seg_brom", BROM_BASE, BROM_SIZE, IntTab(cluster(x,y),BROM_TGTID), true));
          }
       }
@@ -374,5 +436,5 @@
    // coherence network
    // - tgtid_c_proc = srcid_c_proc = local procid
-   // - tgtid_c_memc = srcid_c_memc = nprocs
+   // - tgtid_c_memc = srcid_c_memc = nb_procs
    MappingTable maptabc(address_width, 
          IntTab(x_width + y_width, srcid_width - x_width - y_width), 
@@ -380,18 +442,23 @@
          0x00FF0000);
 
-   for (size_t x = 0; x < xmax; x++){
-      for (size_t y = 0; y < ymax; y++){
+   for (size_t x = 0; x < xmax; x++)
+   {
+      for (size_t y = 0; y < ymax; y++)
+      {
          sc_uint<address_width> offset  = cluster(x,y) << (address_width-x_width-y_width);
 
-         // cleanup requests regarding the memc segment must be routed to the memory cache
+         // cleanup requests must be routed to the memory cache
          std::ostringstream sh;
          sh << "c_seg_memc_" << x << "_" << y;
-         maptabc.add(Segment(sh.str(), (nprocs << (address_width - srcid_width)) + offset, 0x10, IntTab(cluster(x,y), nprocs), false));
+         maptabc.add(Segment(sh.str(), (nb_procs << (address_width - srcid_width)) + offset, 
+                     0x10, IntTab(cluster(x,y), nb_procs), false));
 
          // update & invalidate requests must be routed to the proper processor
-         for ( size_t p = 0 ; p < nprocs ; p++) {
+         for ( size_t p = 0 ; p < nb_procs ; p++) 
+         {
             std::ostringstream sp;
             sp << "c_seg_proc_" << x << "_" << y << "_" << p;
-            maptabc.add( Segment( sp.str() , (p << (address_width - srcid_width)) + offset , 0x10 , IntTab(cluster(x,y), p) , false)); 
+            maptabc.add( Segment( sp.str() , (p << (address_width - srcid_width)) + offset , 
+                         0x10 , IntTab(cluster(x,y), p) , false)); 
          }
       }
@@ -402,10 +469,13 @@
    MappingTable maptabx(address_width, IntTab(1), IntTab(x_width+y_width), 0xF0000000);
 
-   for (size_t x = 0; x < xmax; x++){
-      for (size_t y = 0; y < ymax ; y++){ 
+   for (size_t x = 0; x < xmax; x++)
+   {
+      for (size_t y = 0; y < ymax ; y++)
+      { 
          sc_uint<address_width> offset  = cluster(x,y) << (address_width-x_width-y_width);
          std::ostringstream sh;
          sh << "x_seg_memc_" << x << "_" << y;
-         maptabx.add(Segment(sh.str(), MEMC_BASE+offset, MEMC_SIZE, IntTab(cluster(x,y)), false));
+         maptabx.add(Segment(sh.str(), MEMC_BASE+offset, 
+                     MEMC_SIZE, IntTab(cluster(x,y)), false));
       }
    }
@@ -472,14 +542,19 @@
    {
 #pragma omp for
-      for(size_t i = 0; i  < (xmax * ymax); i++){
-         size_t x = i / ymax;
-         size_t y = i % ymax;
-
+      for(size_t i = 0; i  < (xmax * ymax); i++)
+      {
+          size_t x = i / ymax;
+          size_t y = i % ymax;
 #pragma omp critical
-         std::ostringstream sc;
-         sc << "cluster_" << x << "_" << y;
-         clusters[x][y] = new TsarV4ClusterMmu<vci_param, proc_iss, cmd_width, rsp_width>
+
+          std::cout << "building cluster_" << x << "_" << y << std::endl;
+
+          std::ostringstream sc;
+          sc << "cluster_" << x << "_" << y;
+          clusters[x][y] = new TsarV4ClusterMmu<vci_param, proc_iss, cmd_width, rsp_width>
             (sc.str().c_str(),
-             nprocs,
+             nb_procs,
+             nb_ttys,  
+             nb_dmas, 
              x,
              y,
@@ -504,5 +579,5 @@
              l1_d_sets,
              xram_latency,
-             (cluster(x,y) == cluster_io_index),
+             (cluster(x,y) == cluster_io_id),
              xfb,
              yfb,
@@ -511,13 +586,19 @@
              loader,
              frozen_cycles,
-             from_cycle,
-             trace_ok and (cluster_io_index == cluster(x,y)) );
-      }
+             debug_from,
+             debug_ok and (cluster(x,y) == debug_memc_id),
+             debug_ok and (cluster(x,y) == debug_proc_id) );
+
+         std::cout << "cluster_" << x << "_" << y << " constructed" << std::endl;
+
+       }
    }
 
 #else  // NO OPENMP
 
-   for (size_t x = 0; x  < xmax; x++){
-      for (size_t y = 0; y < ymax; y++){
+   for (size_t x = 0; x  < xmax; x++)
+   {
+       for (size_t y = 0; y < ymax; y++)
+       {
 
          std::cout << "building cluster_" << x << "_" << y << std::endl;
@@ -527,5 +608,7 @@
          clusters[x][y] = new TsarV4ClusterMmu<vci_param, proc_iss, cmd_width, rsp_width>
             (sc.str().c_str(),
-             nprocs,
+             nb_procs,
+             nb_ttys,
+             nb_dmas,
              x,
              y,
@@ -550,5 +633,5 @@
              l1_d_sets,
              xram_latency,
-             (cluster(x,y) == cluster_io_index),
+             (cluster(x,y) == cluster_io_id),
              xfb,
              yfb,
@@ -557,6 +640,7 @@
              loader,
              frozen_cycles,
-             from_cycle,
-             trace_ok and (cluster_io_index == cluster(x,y)) );
+             debug_from,
+             debug_ok and ( cluster(x,y) == debug_memc_id ),
+             debug_ok and ( cluster(x,y) == debug_proc_id ) );
 
          std::cout << "cluster_" << x << "_" << y << " constructed" << std::endl;
@@ -618,6 +702,8 @@
 
    // East & West boundary cluster connections
-   for (size_t y = 0; y < ymax; y++){
-      for (size_t k = 0; k < 2; k++){
+   for (size_t y = 0; y < ymax; y++)
+   {
+      for (size_t k = 0; k < 2; k++)
+      {
          clusters[0][y]->p_cmd_in[k][WEST]          (signal_dspin_false_cmd_in[0][y][k][WEST]);
          clusters[0][y]->p_cmd_out[k][WEST]         (signal_dspin_false_cmd_out[0][y][k][WEST]);
@@ -633,6 +719,8 @@
 
    // North & South boundary clusters connections
-   for (size_t x = 0; x < xmax; x++){
-      for (size_t k = 0; k < 2; k++){
+   for (size_t x = 0; x < xmax; x++)
+   {
+      for (size_t k = 0; k < 2; k++)
+      {
          clusters[x][0]->p_cmd_in[k][SOUTH]         (signal_dspin_false_cmd_in[x][0][k][SOUTH]);
          clusters[x][0]->p_cmd_out[k][SOUTH]        (signal_dspin_false_cmd_out[x][0][k][SOUTH]);
@@ -677,58 +765,65 @@
    signal_resetn = true;
 
-   for (size_t n = 1; n < ncycles; n++){
-      if (trace_ok and (n > from_cycle) and (n % trace_period == 0)){
+   for (size_t n = 1; n < ncycles; n++)
+   {
+
+      if (debug_ok and (n > debug_from) and (n % debug_period == 0))
+      {
          std::cout << "****************** cycle " << std::dec << n ;
          std::cout << " ************************************************" << std::endl;
 
-         // components cluster 00 /////////////////////
-         //            clusters[0][0]->proc[0]->print_trace();
-         //            clusters[0][0]->memc->print_trace();
-
-         // signals cluster 00 ////////////////////////
-         //            clusters[0][0]->signal_vci_ini_d_proc[0].print_trace("proc_0_0_0_ini_d");
-         //            clusters[0][0]->signal_vci_ini_c_proc[0].print_trace("proc_0_0_0_ini_c");
-         //            clusters[0][0]->signal_vci_tgt_c_proc[0].print_trace("proc_0_0_0_tgt_c");
-         //            clusters[0][0]->signal_vci_xram.print_trace("memc_0_0_xram");
-
-         // components cluster 01 /////////////////////
-         //            clusters[0][1]->proc[0]->print_trace();
-         //            clusters[0][1]->memc->print_trace();
-
-         // signals cluster 01 ///////////////////////
-         //            clusters[0][1]->signal_vci_ini_d_proc[0].print_trace("proc_0_1_0_ini_d");
-         //            clusters[0][1]->signal_vci_ini_c_proc[0].print_trace("proc_0_1_0_ini_c");
-         //            clusters[0][1]->signal_vci_tgt_c_proc[0].print_trace("proc_0_1_0_tgt_c");
-         //            clusters[0][1]->signal_vci_xram.print_trace("memc_0_1_xram");
-
-         // components cluster 10 ////////////////////
-         clusters[1][0]->proc[0]->print_trace(1);
-         clusters[1][0]->memc->print_trace();
-         //            clusters[1][0]->bdev->print_trace();
-         //            clusters[1][0]->mdma->print_trace();
-
-         // signals cluster 10 ///////////////////////
-         clusters[1][0]->signal_vci_ini_d_proc[0].print_trace("proc_1_0_0_ini_d");
-         //            clusters[1][0]->signal_vci_ini_c_proc[0].print_trace("proc_1_0_0_ini_c");
-         //            clusters[1][0]->signal_vci_tgt_c_proc[0].print_trace("proc_1_0_0_tgt_c");
-         clusters[1][0]->signal_vci_tgt_d_memc.print_trace("memc_1_0_tgt_d  ");
-         //            clusters[1][0]->signal_vci_ini_c_memc.print_trace("memc_1_0_ini_c  ");
-         //            clusters[1][0]->signal_vci_tgt_c_memc.print_trace("memc_1_0_tgt_c  ");
-         //            clusters[1][0]->signal_vci_tgt_d_bdev.print_trace("bdev_1_0_tgt_d  ");
-         //            clusters[1][0]->signal_vci_ini_d_bdev.print_trace("bdev_1_0_ini_d  ");
-         //            clusters[1][0]->signal_vci_tgt_d_mdma.print_trace("mdma_1_0_tgt_d  ");
-         //            clusters[1][0]->signal_vci_ini_d_mdma.print_trace("mdma_1_0_ini_d  ");
-         clusters[1][0]->signal_vci_tgt_d_mtty.print_trace("mtty_1_0_tgt_d  ");
-         clusters[1][0]->signal_vci_xram.print_trace("memc_1_0_xram");
-
-         // components cluster 11 /////////////////////
-         //            clusters[1][1]->proc[0]->print_trace();
-         //            clusters[1][1]->memc->print_trace();
-
-         // signals cluster 11 ////////////////////////
-         //            clusters[1][1]->signal_vci_ini_d_proc[0].print_trace("proc_1_1_0_ini_d");
-         //            clusters[1][1]->signal_vci_ini_c_proc[0].print_trace("proc_1_1_0_ini_c");
-         //            clusters[1][1]->signal_vci_tgt_c_proc[0].print_trace("proc_1_1_0_tgt_c");
-         //            clusters[1][1]->signal_vci_xram.print_trace("memc_1_1_xram");
+         // trace proc[debug_proc_id] 
+         if ( debug_proc_id < (xmax * ymax * nb_procs) )
+         {
+             size_t proc_x = debug_proc_id / ymax;
+             size_t proc_y = debug_proc_id % ymax;
+
+             clusters[proc_x][proc_y]->proc[0]->print_trace();
+
+             clusters[proc_x][proc_y]->signal_vci_ini_d_proc[0].print_trace("proc_ini_d");
+             clusters[proc_x][proc_y]->signal_vci_ini_c_proc[0].print_trace("proc_ini_c");
+             clusters[proc_x][proc_y]->signal_vci_tgt_c_proc[0].print_trace("proc_tgt_c");
+         }
+
+         // trace memc[debug_memc_id] 
+         if ( debug_memc_id < (xmax * ymax) )
+         {
+             size_t memc_x = debug_memc_id / ymax;
+             size_t memc_y = debug_memc_id % ymax;
+
+             clusters[memc_x][memc_y]->memc->print_trace();
+
+             clusters[memc_x][memc_y]->signal_vci_tgt_d_memc.print_trace("memc_tgt_d");
+             clusters[memc_x][memc_y]->signal_vci_ini_c_memc.print_trace("memc_ini_c");
+             clusters[memc_x][memc_y]->signal_vci_tgt_c_memc.print_trace("memc_tgt_c");
+         }
+
+         // clusters[0][0]->signal_vci_tgt_d_xicu.print_trace("xicu_0_0");
+         // clusters[0][1]->signal_vci_tgt_d_xicu.print_trace("xicu_0_1");
+         // clusters[1][0]->signal_vci_tgt_d_xicu.print_trace("xicu_1_0");
+         // clusters[1][1]->signal_vci_tgt_d_xicu.print_trace("xicu_1_1");
+
+         clusters[1][1]->mdma->print_trace();
+         clusters[1][1]->signal_vci_tgt_d_mdma.print_trace("dma_tgt_1_1");
+         clusters[1][1]->signal_vci_ini_d_mdma.print_trace("dma_ini_1_1");
+         if ( clusters[1][1]->signal_irq_mdma[0].read() ) 
+             std::cout << std::endl << " IRQ_DMA_1_1 activated" << std::endl;
+         if ( clusters[1][1]->signal_proc_it[0].read() )
+             std::cout <<  " IRQ_PROC_1_1 activated" << std::endl << std::endl;
+
+         // trace peripherals components 
+         if ( false )
+         {
+            size_t io_x   = cluster_io_id / ymax;
+            size_t io_y   = cluster_io_id % ymax;
+
+            clusters[io_x][io_y]->bdev->print_trace();
+            clusters[io_x][io_y]->mdma->print_trace();
+
+            clusters[io_x][io_y]->signal_vci_tgt_d_bdev.print_trace("bdev_1_0_tgt_d  ");
+            clusters[io_x][io_y]->signal_vci_ini_d_bdev.print_trace("bdev_1_0_ini_d  ");
+            clusters[io_x][io_y]->signal_vci_tgt_d_mdma.print_trace("mdma_1_0_tgt_d  ");
+            clusters[io_x][io_y]->signal_vci_ini_d_mdma.print_trace("mdma_1_0_ini_d  ");
+         }
       }
 
