Index: trunk/platforms/tsar_generic_leti/tsar_leti_cluster/caba/source/include/tsar_leti_cluster.h
===================================================================
--- trunk/platforms/tsar_generic_leti/tsar_leti_cluster/caba/source/include/tsar_leti_cluster.h	(revision 621)
+++ trunk/platforms/tsar_generic_leti/tsar_leti_cluster/caba/source/include/tsar_leti_cluster.h	(revision 628)
@@ -25,14 +25,9 @@
 #include "vci_dspin_initiator_wrapper.h"
 #include "vci_dspin_target_wrapper.h"
-#include "virtual_dspin_router.h"
+#include "dspin_router.h"
 #include "vci_multi_tty.h"
-#include "vci_multi_nic.h"
-#include "vci_chbuf_dma.h"
 #include "vci_block_device_tsar.h"
-#include "vci_framebuffer.h"
-#include "vci_multi_dma.h"
 #include "vci_mem_cache.h"
 #include "vci_cc_vcache_wrapper.h"
-#include "vci_simhelper.h"
 
 namespace soclib { namespace caba {
@@ -54,17 +49,24 @@
     sc_in<bool>                                     p_clk;
     sc_in<bool>                                     p_resetn;
-    soclib::caba::DspinOutput<dspin_cmd_width>      **p_cmd_out;
-    soclib::caba::DspinInput<dspin_cmd_width>       **p_cmd_in;
-    soclib::caba::DspinOutput<dspin_rsp_width>      **p_rsp_out;
-    soclib::caba::DspinInput<dspin_rsp_width>       **p_rsp_in;
+
+    soclib::caba::DspinOutput<dspin_cmd_width>      *p_cmd_out;
+    soclib::caba::DspinInput<dspin_cmd_width>       *p_cmd_in;
+
+    soclib::caba::DspinOutput<dspin_rsp_width>      *p_rsp_out;
+    soclib::caba::DspinInput<dspin_rsp_width>       *p_rsp_in;
+
+    soclib::caba::DspinOutput<dspin_cmd_width>      *p_m2p_out;
+    soclib::caba::DspinInput<dspin_cmd_width>       *p_m2p_in;
+
+    soclib::caba::DspinOutput<dspin_rsp_width>      *p_p2m_out;
+    soclib::caba::DspinInput<dspin_rsp_width>       *p_p2m_in;
+
+    soclib::caba::DspinOutput<dspin_cmd_width>      *p_cla_out;
+    soclib::caba::DspinInput<dspin_cmd_width>       *p_cla_in;
 
     // interrupt signals
     sc_signal<bool>         signal_false;
-    sc_signal<bool>         signal_proc_it[8];
-    sc_signal<bool>         signal_irq_mdma[8];
-    sc_signal<bool>         signal_irq_mtty[23];
-    sc_signal<bool>         signal_irq_mnic_rx[8];  // unused
-    sc_signal<bool>         signal_irq_mnic_tx[8];  // unused
-    sc_signal<bool>         signal_irq_chbuf[8];  // unused
+    sc_signal<bool>         signal_proc_irq[16];
+    sc_signal<bool>         signal_irq_mtty;
     sc_signal<bool>         signal_irq_memc;
     sc_signal<bool>         signal_irq_bdev;
@@ -83,5 +85,5 @@
 
     // Direct VCI signals to VCI/DSPIN wrappers
-    VciSignals<vci_param_int>       signal_vci_ini_proc[8];
+    VciSignals<vci_param_int>       signal_vci_ini_proc[4];
     VciSignals<vci_param_int>       signal_vci_ini_mdma;
     VciSignals<vci_param_int>       signal_vci_ini_bdev;
@@ -99,6 +101,6 @@
 
     // Direct DSPIN signals to local crossbars
-    DspinSignals<dspin_cmd_width>     signal_dspin_cmd_proc_i[8];
-    DspinSignals<dspin_rsp_width>     signal_dspin_rsp_proc_i[8];
+    DspinSignals<dspin_cmd_width>     signal_dspin_cmd_proc_i[4];
+    DspinSignals<dspin_rsp_width>     signal_dspin_rsp_proc_i[4];
     DspinSignals<dspin_cmd_width>     signal_dspin_cmd_mdma_i;
     DspinSignals<dspin_rsp_width>     signal_dspin_rsp_mdma_i;
@@ -131,7 +133,7 @@
     DspinSignals<dspin_cmd_width>     signal_dspin_clack_memc;
     DspinSignals<dspin_rsp_width>     signal_dspin_p2m_memc;
-    DspinSignals<dspin_cmd_width>     signal_dspin_m2p_proc[8];
-    DspinSignals<dspin_cmd_width>     signal_dspin_clack_proc[8];
-    DspinSignals<dspin_rsp_width>     signal_dspin_p2m_proc[8];
+    DspinSignals<dspin_cmd_width>     signal_dspin_m2p_proc[4];
+    DspinSignals<dspin_cmd_width>     signal_dspin_clack_proc[4];
+    DspinSignals<dspin_rsp_width>     signal_dspin_p2m_proc[4];
 
     // external RAM to MEMC VCI signal
@@ -143,9 +145,9 @@
                        dspin_cmd_width,
                        dspin_rsp_width,
-                       GdbServer<Mips32ElIss> >*  proc[8];
+                       GdbServer<Mips32ElIss> >*  proc[4];
 
     VciDspinInitiatorWrapper<vci_param_int,
                              dspin_cmd_width,
-                             dspin_rsp_width>*    wi_proc[8];
+                             dspin_rsp_width>*    wi_proc[4];
 
     VciMemCache<vci_param_int,
@@ -164,14 +166,4 @@
                           dspin_rsp_width>*       wt_xicu;
 
-    VciMultiDma<vci_param_int>*                   mdma;
-
-    VciDspinInitiatorWrapper<vci_param_int,
-                             dspin_cmd_width,
-                             dspin_rsp_width>*    wi_mdma;
-
-    VciDspinTargetWrapper<vci_param_int,
-                          dspin_cmd_width,
-                          dspin_rsp_width>*       wt_mdma;
-
     VciSimpleRam<vci_param_ext>*                  xram;
 
@@ -181,32 +173,4 @@
                           dspin_cmd_width,
                           dspin_rsp_width>*       wt_mtty;
-
-    VciSimhelper<vci_param_int>*                  simhelper;
-
-    VciDspinTargetWrapper<vci_param_int,
-                          dspin_cmd_width,
-                          dspin_rsp_width>*       wt_simhelper;
-
-    VciFrameBuffer<vci_param_int>*                fbuf;
-
-    VciDspinTargetWrapper<vci_param_int,
-                          dspin_cmd_width,
-                          dspin_rsp_width>*       wt_fbuf;
-
-    VciMultiNic<vci_param_int>*                   mnic;
-
-    VciDspinTargetWrapper<vci_param_int,
-                          dspin_cmd_width,
-                          dspin_rsp_width>*       wt_mnic;
-
-    VciChbufDma<vci_param_int>*                   chbuf;
-
-    VciDspinTargetWrapper<vci_param_int,
-                          dspin_cmd_width,
-                          dspin_rsp_width>*       wt_chbuf;
-
-    VciDspinInitiatorWrapper<vci_param_int,
-                          dspin_cmd_width,
-                          dspin_rsp_width>*       wi_chbuf;
 
     VciBlockDeviceTsar<vci_param_int>*            bdev;
@@ -220,17 +184,18 @@
                           dspin_rsp_width>*       wt_bdev;
 
-    DspinLocalCrossbar<dspin_cmd_width>*          xbar_cmd_d;
-    DspinLocalCrossbar<dspin_rsp_width>*          xbar_rsp_d;
-    DspinLocalCrossbar<dspin_cmd_width>*          xbar_m2p_c;
-    DspinLocalCrossbar<dspin_rsp_width>*          xbar_p2m_c;
-    DspinLocalCrossbar<dspin_cmd_width>*          xbar_clack_c;
-
-    VirtualDspinRouter<dspin_cmd_width>*          router_cmd;
-    VirtualDspinRouter<dspin_rsp_width>*          router_rsp;
+    DspinLocalCrossbar<dspin_cmd_width>*          xbar_cmd;
+    DspinLocalCrossbar<dspin_rsp_width>*          xbar_rsp;
+    DspinLocalCrossbar<dspin_cmd_width>*          xbar_m2p;
+    DspinLocalCrossbar<dspin_rsp_width>*          xbar_p2m;
+    DspinLocalCrossbar<dspin_cmd_width>*          xbar_cla;
+
+    DspinRouter<dspin_cmd_width>*                 router_cmd;
+    DspinRouter<dspin_rsp_width>*                 router_rsp;
+    DspinRouter<dspin_cmd_width>*                 router_m2p;
+    DspinRouter<dspin_rsp_width>*                 router_p2m;
+    DspinRouter<dspin_cmd_width>*                 router_cla;
 
     TsarLetiCluster( sc_module_name                     insname,
                      size_t                             nb_procs,      // processors
-                     size_t                             nb_ttys,       // TTY terminals
-                     size_t                             nb_dmas,       //  DMA channels
                      size_t                             x,             // x coordinate
                      size_t                             y,             // y coordinate
@@ -244,11 +209,7 @@
                      size_t                             tgtid_memc,
                      size_t                             tgtid_xicu,
-                     size_t                             tgtid_mdma,
-                     size_t                             tgtid_fbuf,
                      size_t                             tgtid_mtty,
-                     size_t                             tgtid_mnic,
-                     size_t                             tgtid_chbuf,
                      size_t                             tgtid_bdev,
-                     size_t                             tgtid_simh,
+                     const char*                        disk_pathname,
                      size_t                             memc_ways,
                      size_t                             memc_sets,
@@ -258,14 +219,4 @@
                      size_t                             l1_d_sets,
                      size_t                             xram_latency,  // external ram
-                     bool                               io,            // I/O cluster
-                     size_t                             xfb,           // fbf pixels
-                     size_t                             yfb,           // fbf lines
-                     char*                              disk_name,     // virtual disk
-                     size_t                             block_size,    // block size
-                     size_t                             nic_channels,  // number channels
-                     char*                              nic_rx_name,   // filename rx
-                     char*                              nic_tx_name,   // filename tx
-                     uint32_t                           nic_timeout,   // cycles
-                     size_t                             chbufdma_channels,  // number channels
                      const Loader                       &loader,
                      uint32_t                           frozen_cycles,
Index: trunk/platforms/tsar_generic_leti/tsar_leti_cluster/caba/source/src/tsar_leti_cluster.cpp
===================================================================
--- trunk/platforms/tsar_generic_leti/tsar_leti_cluster/caba/source/src/tsar_leti_cluster.cpp	(revision 621)
+++ trunk/platforms/tsar_generic_leti/tsar_leti_cluster/caba/source/src/tsar_leti_cluster.cpp	(revision 628)
@@ -3,26 +3,9 @@
 // Author: Alain Greiner
 // Copyright: UPMC/LIP6
-// Date : march 2011
+// Date : february 2014
 // This program is released under the GNU public license
 //////////////////////////////////////////////////////////////////////////////
-// This file define a TSAR cluster architecture with virtual memory:
-// - It uses two virtual_dspin_router as distributed global interconnect
-// - It uses five dspin_local_crossbar as local interconnect
-// - It uses the vci_cc_vcache_wrapper
-// - It uses the vci_mem_cache
-// - It contains a private RAM with a variable latency to emulate the L3 cache
-// - It can contains 1, 2 or 4 processors
-// - Each processor has a private dma channel (vci_multi_dma)
-// - It uses the vci_xicu interrupt controller
-// - The peripherals MTTY, BDEV, FBUF, MNIC,CDMA are in cluster (0,0)
-// - The Multi-TTY component controls up to 16 terminals.
-// - The BDEV IRQ is connected to IRQ_IN[0] in cluster(0,0).
-// - The DMA IRQs are connected to IRQ_IN[8:11] in all clusters.
-// - The MEMC IRQ is connected to IRQ_IN[12] in all clusters.
-// - The TTY IRQs are connected to IRQ_IN[16:31] in cluster (0,0).
-//////////////////////////////////////////////////////////////////////////////////
 
 #include "../include/tsar_leti_cluster.h"
-
 
 namespace soclib {
@@ -40,6 +23,4 @@
          sc_module_name                     insname,
          size_t                             nb_procs,
-         size_t                             nb_ttys,
-         size_t                             nb_dmas,
          size_t                             x_id,
          size_t                             y_id,
@@ -53,11 +34,7 @@
          size_t                             tgtid_memc,
          size_t                             tgtid_xicu,
-         size_t                             tgtid_mdma,
-         size_t                             tgtid_fbuf,
          size_t                             tgtid_mtty,
-         size_t                             tgtid_mnic,
-         size_t                             tgtid_chbuf,
          size_t                             tgtid_bdev,
-         size_t                             tgtid_simh,
+         const char*                        disk_pathname,
          size_t                             memc_ways,
          size_t                             memc_sets,
@@ -67,14 +44,4 @@
          size_t                             l1_d_sets,
          size_t                             xram_latency,
-         bool                               io,
-         size_t                             xfb,
-         size_t                             yfb,
-         char*                              disk_name,
-         size_t                             block_size,
-         size_t                             nic_channels,
-         char*                              nic_rx_name,
-         char*                              nic_tx_name,
-         uint32_t                           nic_timeout,
-         size_t                             chbufdma_channels,
          const Loader                      &loader,
          uint32_t                           frozen_cycles,
@@ -89,15 +56,25 @@
 
 {
-
-    n_procs = nb_procs;
-
-    // Vectors of ports definition
-    p_cmd_in  = alloc_elems<DspinInput<dspin_cmd_width> >  ("p_cmd_in",  4, 3);
-    p_cmd_out = alloc_elems<DspinOutput<dspin_cmd_width> > ("p_cmd_out", 4, 3);
-    p_rsp_in  = alloc_elems<DspinInput<dspin_rsp_width> >  ("p_rsp_in",  4, 2);
-    p_rsp_out = alloc_elems<DspinOutput<dspin_rsp_width> > ("p_rsp_out", 4, 2);
-
-    /////////////////////////////////////////////////////////////////////////////
-    // Components definition
+    /////////////////////////////////////////////////////////////////////////////
+    // Vectors of ports definition and allocation
+    /////////////////////////////////////////////////////////////////////////////
+
+    p_cmd_in  = alloc_elems<DspinInput<dspin_cmd_width> >  ("p_cmd_in",  4);
+    p_cmd_out = alloc_elems<DspinOutput<dspin_cmd_width> > ("p_cmd_out", 4);
+
+    p_rsp_in  = alloc_elems<DspinInput<dspin_rsp_width> >  ("p_rsp_in",  4);
+    p_rsp_out = alloc_elems<DspinOutput<dspin_rsp_width> > ("p_rsp_out", 4);
+
+    p_m2p_in  = alloc_elems<DspinInput<dspin_cmd_width> >  ("p_m2p_in",  4);
+    p_m2p_out = alloc_elems<DspinOutput<dspin_cmd_width> > ("p_m2p_out", 4);
+
+    p_p2m_in  = alloc_elems<DspinInput<dspin_rsp_width> >  ("p_p2m_in",  4);
+    p_p2m_out = alloc_elems<DspinOutput<dspin_rsp_width> > ("p_p2m_out", 4);
+
+    p_cla_in  = alloc_elems<DspinInput<dspin_cmd_width> >  ("p_cla_in",  4);
+    p_cla_out = alloc_elems<DspinOutput<dspin_cmd_width> > ("p_cla_out", 4);
+
+    /////////////////////////////////////////////////////////////////////////////
+    // Components definition and allocation
     /////////////////////////////////////////////////////////////////////////////
 
@@ -194,8 +171,8 @@
                      mtd,                               // mapping table
                      IntTab(cluster_xy, tgtid_xicu),    // TGTID_D
-                     32,                                // number of timer IRQs
-                     32,                                // number of hard IRQs
-                     32,                                // number of soft IRQs
-                     nb_procs);                         // number of output IRQs
+                     16,                                // number of timer IRQs
+                     16,                                // number of hard IRQs
+                     16,                                // number of soft IRQs
+                     16 );                              // number of output IRQs
 
     wt_xicu = new VciDspinTargetWrapper<vci_param_int,
@@ -206,42 +183,22 @@
 
     /////////////////////////////////////////////////////////////////////////////
-    std::ostringstream smdma;
-    smdma << "mdma_" << x_id << "_" << y_id;
-    mdma = new VciMultiDma<vci_param_int>(
-                     smdma.str().c_str(),
-                     mtd,
-                     IntTab(cluster_xy, nb_procs),        // SRCID
-                     IntTab(cluster_xy, tgtid_mdma),      // TGTID
-                     64,                                  // burst size
-                     nb_dmas);                            // number of IRQs
-
-    wt_mdma = new VciDspinTargetWrapper<vci_param_int,
-                                        dspin_cmd_width,
-                                        dspin_rsp_width>(
-                     "wt_mdma",
-                     x_width + y_width + l_width);
-
-    wi_mdma = new VciDspinInitiatorWrapper<vci_param_int,
-                                           dspin_cmd_width,
-                                           dspin_rsp_width>(
-                     "wi_mdma",
-                     x_width + y_width + l_width);
-
-    /////////////////////////////////////////////////////////////////////////////
-    size_t nb_direct_initiators      = nb_procs + 1;
-    size_t nb_direct_targets         = 3;
-    if (io)
-    {
-        nb_direct_initiators         = nb_procs + 3;
-        nb_direct_targets            = 9;
-    }
-
-    xbar_cmd_d = new DspinLocalCrossbar<dspin_cmd_width>(
-                     "xbar_cmd_d",
+    size_t nb_initiators = nb_procs;
+    size_t nb_targets    = 2;
+
+    if ((x_id == 0) and (y_id == 0))  // cluster(0,0)
+    {
+        nb_initiators = nb_procs + 1;
+        nb_targets    = 4;
+    }
+
+    std::ostringstream s_xbar_cmd;
+    s_xbar_cmd << "xbar_cmd_" << x_id << "_" << y_id;
+    xbar_cmd = new DspinLocalCrossbar<dspin_cmd_width>(
+                     s_xbar_cmd.str().c_str(),
                      mtd,                          // mapping table
                      x_id, y_id,                   // cluster coordinates
                      x_width, y_width, l_width,
-                     nb_direct_initiators,         // number of local of sources
-                     nb_direct_targets,            // number of local dests 
+                     nb_initiators,                // number of local of sources
+                     nb_targets,                   // number of local dests 
                      2, 2,                         // fifo depths  
                      true,                         // CMD
@@ -250,11 +207,13 @@
 
     /////////////////////////////////////////////////////////////////////////////
-    xbar_rsp_d = new DspinLocalCrossbar<dspin_rsp_width>(
-                     "xbar_rsp_d",
+    std::ostringstream s_xbar_rsp;
+    s_xbar_rsp << "xbar_rsp_" << x_id << "_" << y_id;
+    xbar_rsp = new DspinLocalCrossbar<dspin_rsp_width>(
+                     s_xbar_rsp.str().c_str(),
                      mtd,                          // mapping table
                      x_id, y_id,                   // cluster coordinates
                      x_width, y_width, l_width,
-                     nb_direct_targets,            // number of local sources
-                     nb_direct_initiators,         // number of local dests
+                     nb_targets,                   // number of local sources
+                     nb_initiators,                // number of local dests
                      2, 2,                         // fifo depths  
                      false,                        // RSP
@@ -263,11 +222,13 @@
 
     /////////////////////////////////////////////////////////////////////////////
-    xbar_m2p_c = new DspinLocalCrossbar<dspin_cmd_width>(
-                     "xbar_m2p_c",
+    std::ostringstream s_xbar_m2p;
+    s_xbar_m2p << "xbar_m2p_" << x_id << "_" << y_id;
+    xbar_m2p = new DspinLocalCrossbar<dspin_cmd_width>(
+                     s_xbar_m2p.str().c_str(),
                      mtd,                          // mapping table
                      x_id, y_id,                   // cluster coordinates
                      x_width, y_width, l_width,
                      1,                            // number of local sources
-                     nb_procs,                     // number of local targets 
+                     nb_procs,                     // number of local dests 
                      2, 2,                         // fifo depths
                      true,                         // CMD
@@ -276,6 +237,8 @@
 
     /////////////////////////////////////////////////////////////////////////////
-    xbar_p2m_c = new DspinLocalCrossbar<dspin_rsp_width>(
-                     "xbar_p2m_c",
+    std::ostringstream s_xbar_p2m;
+    s_xbar_p2m << "xbar_p2m_" << x_id << "_" << y_id;
+    xbar_p2m = new DspinLocalCrossbar<dspin_rsp_width>(
+                     s_xbar_p2m.str().c_str(),
                      mtd,                          // mapping table
                      x_id, y_id,                   // cluster coordinates
@@ -289,57 +252,75 @@
 
     /////////////////////////////////////////////////////////////////////////////
-    xbar_clack_c = new DspinLocalCrossbar<dspin_cmd_width>(
-                     "xbar_clack_c",
+    std::ostringstream s_xbar_cla;
+    s_xbar_cla << "xbar_cla_" << x_id << "_" << y_id;
+    xbar_cla = new DspinLocalCrossbar<dspin_cmd_width>(
+                     s_xbar_cla.str().c_str(),
                      mtd,                          // mapping table
                      x_id, y_id,                   // cluster coordinates
                      x_width, y_width, l_width,
                      1,                            // number of local sources
-                     nb_procs,                     // number of local targets 
-                     1, 1,                         // fifo depths
+                     nb_procs,                     // number of local dests 
+                     2, 2,                         // fifo depths
                      true,                         // CMD
                      false,                        // don't use local routing table
-                     false);                       // broadcast
-
-    /////////////////////////////////////////////////////////////////////////////
-    router_cmd = new VirtualDspinRouter<dspin_cmd_width>(
-                     "router_cmd",
+                     false);                       // no broadcast
+
+    /////////////////////////////////////////////////////////////////////////////
+    std::ostringstream s_router_cmd;
+    s_router_cmd << "router_cmd_" << x_id << "_" << y_id;
+    router_cmd = new DspinRouter<dspin_cmd_width>(
+                     s_router_cmd.str().c_str(),
                      x_id,y_id,                    // coordinate in the mesh
                      x_width, y_width,             // x & y fields width
-                     3,                            // nb virtual channels
                      4,4);                         // input & output fifo depths
 
     /////////////////////////////////////////////////////////////////////////////
-    router_rsp = new VirtualDspinRouter<dspin_rsp_width>(
-                     "router_rsp",
+    std::ostringstream s_router_rsp;
+    s_router_rsp << "router_rsp_" << x_id << "_" << y_id;
+    router_rsp = new DspinRouter<dspin_rsp_width>(
+                     s_router_rsp.str().c_str(),
                      x_id,y_id,                    // coordinates in mesh
                      x_width, y_width,             // x & y fields width
-                     2,                            // nb virtual channels
                      4,4);                         // input & output fifo depths
 
-    // IO cluster components
-    if (io)
-    {
-        /////////////////////////////////////////////
-        fbuf = new VciFrameBuffer<vci_param_int>(
-                     "fbuf",
-                     IntTab(cluster_xy, tgtid_fbuf),
-                     mtd,
-                     xfb, yfb);
-
-        wt_fbuf = new VciDspinTargetWrapper<vci_param_int,
-                                            dspin_cmd_width,
-                                            dspin_rsp_width>(
-                     "wt_fbuf",
-                     x_width + y_width + l_width);
-
+    /////////////////////////////////////////////////////////////////////////////
+    std::ostringstream s_router_m2p;
+    s_router_m2p << "router_m2p_" << x_id << "_" << y_id;
+    router_m2p = new DspinRouter<dspin_cmd_width>(
+                     s_router_m2p.str().c_str(),
+                     x_id,y_id,                    // coordinate in the mesh
+                     x_width, y_width,             // x & y fields width
+                     4,4,                          // input & output fifo depths
+                     true);                        // broadcast supported
+
+    /////////////////////////////////////////////////////////////////////////////
+    std::ostringstream s_router_p2m;
+    s_router_p2m << "router_p2m_" << x_id << "_" << y_id;
+    router_p2m = new DspinRouter<dspin_rsp_width>(
+                     s_router_p2m.str().c_str(),
+                     x_id,y_id,                    // coordinates in mesh
+                     x_width, y_width,             // x & y fields width
+                     4,4);                         // input & output fifo depths
+
+    /////////////////////////////////////////////////////////////////////////////
+    std::ostringstream s_router_cla;
+    s_router_cla << "router_cla_" << x_id << "_" << y_id;
+    router_cla = new DspinRouter<dspin_cmd_width>(
+                     s_router_cla.str().c_str(),
+                     x_id,y_id,                    // coordinate in the mesh
+                     x_width, y_width,             // x & y fields width
+                     4,4);                         // input & output fifo depths
+
+    if ((x_id == 0) and (y_id == 0))
+    {
         /////////////////////////////////////////////
         bdev = new VciBlockDeviceTsar<vci_param_int>(
                      "bdev",
                      mtd,
-                     IntTab(cluster_xy, nb_procs + 1),
+                     IntTab(cluster_xy, nb_procs),
                      IntTab(cluster_xy, tgtid_bdev),
-                     disk_name,
-                     block_size,
-                     64);            // burst size
+                     disk_pathname,
+                     512,
+                     64 );            // burst size
 
         wt_bdev = new VciDspinTargetWrapper<vci_param_int,
@@ -355,55 +336,10 @@
                      x_width + y_width + l_width);
 
-        ////////////////////////////////////// 
-        mnic = new VciMultiNic<vci_param_int>(
-                     "mnic",
-                     IntTab(cluster_xy, tgtid_mnic),
-                     mtd,
-                     nic_channels,
-                     0xBEEF0000,      // mac_4 address
-                     0xBABE,          // mac_2 address
-                     nic_rx_name,
-                     nic_tx_name);
-
-        wt_mnic = new VciDspinTargetWrapper<vci_param_int,
-                                           dspin_cmd_width,
-                                           dspin_rsp_width>(
-                    "wt_mnic",
-                    x_width + y_width + l_width);
-
         /////////////////////////////////////////////
-        chbuf = new VciChbufDma<vci_param_int>(
-                     "chbuf_dma",
-                     mtd,
-                     IntTab(cluster_xy, nb_procs + 2),
-                     IntTab(cluster_xy, tgtid_chbuf),
-                     64,
-                     chbufdma_channels); 
-
-        wt_chbuf = new VciDspinTargetWrapper<vci_param_int,
-                                            dspin_cmd_width,
-                                            dspin_rsp_width>(
-                     "wt_chbuf",
-                     x_width + y_width + l_width);
-
-        wi_chbuf = new VciDspinInitiatorWrapper<vci_param_int,
-                                            dspin_cmd_width,
-                                            dspin_rsp_width>(
-                     "wi_chbuf",
-                     x_width + y_width + l_width);
-
-        /////////////////////////////////////////////
-        std::vector<std::string> vect_names;
-        for (size_t tid = 0; tid < nb_ttys; tid++)
-        {
-            std::ostringstream term_name;
-            term_name <<  "term" << tid;
-            vect_names.push_back(term_name.str().c_str());
-        }
         mtty = new VciMultiTty<vci_param_int>(
                      "mtty",
                      IntTab(cluster_xy, tgtid_mtty),
                      mtd,
-                     vect_names);
+                     "tty_0_0", NULL );
 
         wt_mtty = new VciDspinTargetWrapper<vci_param_int,
@@ -412,17 +348,7 @@
                      "wt_mtty",
                      x_width + y_width + l_width);
-
-        ////////////////////////////////////////////
-        simhelper = new VciSimhelper<vci_param_int>(
-                     "sim_helper",
-                     IntTab(cluster_xy, tgtid_simh),
-                     mtd);
-
-        wt_simhelper = new VciDspinTargetWrapper<vci_param_int,
-                                                 dspin_cmd_width,
-                                                 dspin_rsp_width>(
-                     "wt_simhelper",
-                     x_width + y_width + l_width);
-    }
+    }
+
+    std::cout << std::endl;
 
     ////////////////////////////////////
@@ -430,133 +356,128 @@
     ////////////////////////////////////
 
-    //////////////////////// CMD ROUTER and RSP ROUTER
-    router_cmd->p_clk                        (this->p_clk);
-    router_cmd->p_resetn                     (this->p_resetn);
-    router_rsp->p_clk                        (this->p_clk);
-    router_rsp->p_resetn                     (this->p_resetn);
-
-    for (int i = 0; i < 4; i++)
-    {
-        for (int k = 0; k < 3; k++)
-        {
-            router_cmd->p_out[i][k]          (this->p_cmd_out[i][k]);
-            router_cmd->p_in[i][k]           (this->p_cmd_in[i][k]);
-        }
-
-        for (int k = 0; k < 2; k++)
-        {
-            router_rsp->p_out[i][k]          (this->p_rsp_out[i][k]);
-            router_rsp->p_in[i][k]           (this->p_rsp_in[i][k]);
-        }
-    }
-
-    router_cmd->p_out[4][0]                  (signal_dspin_cmd_g2l_d);
-    router_cmd->p_out[4][1]                  (signal_dspin_m2p_g2l_c);
-    router_cmd->p_out[4][2]                  (signal_dspin_clack_g2l_c);
-    router_cmd->p_in[4][0]                   (signal_dspin_cmd_l2g_d);
-    router_cmd->p_in[4][1]                   (signal_dspin_m2p_l2g_c);
-    router_cmd->p_in[4][2]                   (signal_dspin_clack_l2g_c);
-
-    router_rsp->p_out[4][0]                  (signal_dspin_rsp_g2l_d);
-    router_rsp->p_out[4][1]                  (signal_dspin_p2m_g2l_c);
-    router_rsp->p_in[4][0]                   (signal_dspin_rsp_l2g_d);
-    router_rsp->p_in[4][1]                   (signal_dspin_p2m_l2g_c);
-
-
-    std::cout << "  - CMD & RSP routers connected" << std::endl;
+    //////////////////////// ROUTERS
+    router_cmd->p_clk                      (this->p_clk);
+    router_cmd->p_resetn                   (this->p_resetn);
+    router_rsp->p_clk                      (this->p_clk);
+    router_rsp->p_resetn                   (this->p_resetn);
+    router_m2p->p_clk                      (this->p_clk);
+    router_m2p->p_resetn                   (this->p_resetn);
+    router_p2m->p_clk                      (this->p_clk);
+    router_p2m->p_resetn                   (this->p_resetn);
+    router_cla->p_clk                      (this->p_clk);
+    router_cla->p_resetn                   (this->p_resetn);
+
+    // loop on N/S/E/W ports
+    for (size_t i = 0; i < 4; i++)
+    {
+        router_cmd->p_out[i]               (this->p_cmd_out[i]);
+        router_cmd->p_in[i]                (this->p_cmd_in[i]);
+
+        router_rsp->p_out[i]               (this->p_rsp_out[i]);
+        router_rsp->p_in[i]                (this->p_rsp_in[i]);
+
+        router_m2p->p_out[i]               (this->p_m2p_out[i]);
+        router_m2p->p_in[i]                (this->p_m2p_in[i]);
+
+        router_p2m->p_out[i]               (this->p_p2m_out[i]);
+        router_p2m->p_in[i]                (this->p_p2m_in[i]);
+
+        router_cla->p_out[i]               (this->p_cla_out[i]);
+        router_cla->p_in[i]                (this->p_cla_in[i]);
+    }
+
+    router_cmd->p_out[4]                   (signal_dspin_cmd_g2l_d);
+    router_cmd->p_in[4]                    (signal_dspin_cmd_l2g_d);
+
+    router_rsp->p_out[4]                   (signal_dspin_rsp_g2l_d);
+    router_rsp->p_in[4]                    (signal_dspin_rsp_l2g_d);
+
+    router_m2p->p_out[4]                   (signal_dspin_m2p_g2l_c);
+    router_m2p->p_in[4]                    (signal_dspin_m2p_l2g_c);
+
+    router_p2m->p_out[4]                   (signal_dspin_p2m_g2l_c);
+    router_p2m->p_in[4]                    (signal_dspin_p2m_l2g_c);
+
+    router_cla->p_out[4]                   (signal_dspin_clack_g2l_c);
+    router_cla->p_in[4]                    (signal_dspin_clack_l2g_c);
+
+    std::cout << "  - routers connected" << std::endl;
 
     ///////////////////// CMD DSPIN  local crossbar direct
-    xbar_cmd_d->p_clk                            (this->p_clk);
-    xbar_cmd_d->p_resetn                         (this->p_resetn);
-    xbar_cmd_d->p_global_out                     (signal_dspin_cmd_l2g_d);
-    xbar_cmd_d->p_global_in                      (signal_dspin_cmd_g2l_d);
-
-    xbar_cmd_d->p_local_out[tgtid_memc]          (signal_dspin_cmd_memc_t);
-    xbar_cmd_d->p_local_out[tgtid_xicu]          (signal_dspin_cmd_xicu_t);
-    xbar_cmd_d->p_local_out[tgtid_mdma]          (signal_dspin_cmd_mdma_t);
-
-    xbar_cmd_d->p_local_in[nb_procs]             (signal_dspin_cmd_mdma_i);
+    xbar_cmd->p_clk                            (this->p_clk);
+    xbar_cmd->p_resetn                         (this->p_resetn);
+    xbar_cmd->p_global_out                     (signal_dspin_cmd_l2g_d);
+    xbar_cmd->p_global_in                      (signal_dspin_cmd_g2l_d);
+
+    xbar_cmd->p_local_out[tgtid_memc]          (signal_dspin_cmd_memc_t);
+    xbar_cmd->p_local_out[tgtid_xicu]          (signal_dspin_cmd_xicu_t);
 
     for (size_t p = 0; p < nb_procs; p++)
-        xbar_cmd_d->p_local_in[p]                (signal_dspin_cmd_proc_i[p]);
-
-    if (io)
-    {
-        xbar_cmd_d->p_local_out[tgtid_mtty]      (signal_dspin_cmd_mtty_t);
-        xbar_cmd_d->p_local_out[tgtid_bdev]      (signal_dspin_cmd_bdev_t);
-        xbar_cmd_d->p_local_out[tgtid_fbuf]      (signal_dspin_cmd_fbuf_t);
-        xbar_cmd_d->p_local_out[tgtid_mnic]      (signal_dspin_cmd_mnic_t);
-        xbar_cmd_d->p_local_out[tgtid_chbuf]     (signal_dspin_cmd_chbuf_t);
-        xbar_cmd_d->p_local_out[tgtid_simh]      (signal_dspin_cmd_simh_t);
-
-        xbar_cmd_d->p_local_in[nb_procs + 1]     (signal_dspin_cmd_bdev_i);
-        xbar_cmd_d->p_local_in[nb_procs + 2]     (signal_dspin_cmd_chbuf_i);
-    }
-
-    std::cout << "  - Command Direct crossbar connected" << std::endl;
+        xbar_cmd->p_local_in[p]                (signal_dspin_cmd_proc_i[p]);
+
+    if ((x_id == 0) and (y_id == 0))  // cluster(0,0)
+    {
+        xbar_cmd->p_local_out[tgtid_mtty]      (signal_dspin_cmd_mtty_t);
+        xbar_cmd->p_local_out[tgtid_bdev]      (signal_dspin_cmd_bdev_t);
+
+        xbar_cmd->p_local_in[nb_procs]         (signal_dspin_cmd_bdev_i);
+    }
+
+    std::cout << "  - CMD Direct crossbar connected" << std::endl;
 
     //////////////////////// RSP DSPIN  local crossbar direct
-    xbar_rsp_d->p_clk                            (this->p_clk);
-    xbar_rsp_d->p_resetn                         (this->p_resetn);
-    xbar_rsp_d->p_global_out                     (signal_dspin_rsp_l2g_d);
-    xbar_rsp_d->p_global_in                      (signal_dspin_rsp_g2l_d);
-
-    xbar_rsp_d->p_local_in[tgtid_memc]           (signal_dspin_rsp_memc_t);
-    xbar_rsp_d->p_local_in[tgtid_xicu]           (signal_dspin_rsp_xicu_t);
-    xbar_rsp_d->p_local_in[tgtid_mdma]           (signal_dspin_rsp_mdma_t);
-
-    xbar_rsp_d->p_local_out[nb_procs]            (signal_dspin_rsp_mdma_i);
+    xbar_rsp->p_clk                            (this->p_clk);
+    xbar_rsp->p_resetn                         (this->p_resetn);
+    xbar_rsp->p_global_out                     (signal_dspin_rsp_l2g_d);
+    xbar_rsp->p_global_in                      (signal_dspin_rsp_g2l_d);
+
+    xbar_rsp->p_local_in[tgtid_memc]           (signal_dspin_rsp_memc_t);
+    xbar_rsp->p_local_in[tgtid_xicu]           (signal_dspin_rsp_xicu_t);
 
     for (size_t p = 0; p < nb_procs; p++)
-        xbar_rsp_d->p_local_out[p]               (signal_dspin_rsp_proc_i[p]);
-
-    if (io)
-    {
-        xbar_rsp_d->p_local_in[tgtid_mtty]       (signal_dspin_rsp_mtty_t);
-        xbar_rsp_d->p_local_in[tgtid_bdev]       (signal_dspin_rsp_bdev_t);
-        xbar_rsp_d->p_local_in[tgtid_fbuf]       (signal_dspin_rsp_fbuf_t);
-        xbar_rsp_d->p_local_in[tgtid_mnic]       (signal_dspin_rsp_mnic_t);
-        xbar_rsp_d->p_local_in[tgtid_chbuf]      (signal_dspin_rsp_chbuf_t);
-        xbar_rsp_d->p_local_in[tgtid_simh]       (signal_dspin_rsp_simh_t);
-
-        xbar_rsp_d->p_local_out[nb_procs + 1]    (signal_dspin_rsp_bdev_i);
-        xbar_rsp_d->p_local_out[nb_procs + 2]    (signal_dspin_rsp_chbuf_i);
-    }
-
-    std::cout << "  - Response Direct crossbar connected" << std::endl;
+        xbar_rsp->p_local_out[p]               (signal_dspin_rsp_proc_i[p]);
+
+    if ((x_id == 0) and (y_id == 0))  // cluster(0,0)
+    {
+        xbar_rsp->p_local_in[tgtid_mtty]       (signal_dspin_rsp_mtty_t);
+        xbar_rsp->p_local_in[tgtid_bdev]       (signal_dspin_rsp_bdev_t);
+
+        xbar_rsp->p_local_out[nb_procs]        (signal_dspin_rsp_bdev_i);
+    }
+
+    std::cout << "  - RSP Direct crossbar connected" << std::endl;
 
     ////////////////////// M2P DSPIN local crossbar coherence
-    xbar_m2p_c->p_clk                            (this->p_clk);
-    xbar_m2p_c->p_resetn                         (this->p_resetn);
-    xbar_m2p_c->p_global_out                     (signal_dspin_m2p_l2g_c);
-    xbar_m2p_c->p_global_in                      (signal_dspin_m2p_g2l_c);
-    xbar_m2p_c->p_local_in[0]                    (signal_dspin_m2p_memc);
+    xbar_m2p->p_clk                            (this->p_clk);
+    xbar_m2p->p_resetn                         (this->p_resetn);
+    xbar_m2p->p_global_out                     (signal_dspin_m2p_l2g_c);
+    xbar_m2p->p_global_in                      (signal_dspin_m2p_g2l_c);
+    xbar_m2p->p_local_in[0]                    (signal_dspin_m2p_memc);
     for (size_t p = 0; p < nb_procs; p++)
-        xbar_m2p_c->p_local_out[p]               (signal_dspin_m2p_proc[p]);
+        xbar_m2p->p_local_out[p]               (signal_dspin_m2p_proc[p]);
 
     std::cout << "  - M2P Coherence crossbar connected" << std::endl;
 
+    ////////////////////////// P2M DSPIN local crossbar coherence
+    xbar_p2m->p_clk                            (this->p_clk);
+    xbar_p2m->p_resetn                         (this->p_resetn);
+    xbar_p2m->p_global_out                     (signal_dspin_p2m_l2g_c);
+    xbar_p2m->p_global_in                      (signal_dspin_p2m_g2l_c);
+    xbar_p2m->p_local_out[0]                   (signal_dspin_p2m_memc);
+    for (size_t p = 0; p < nb_procs; p++)
+        xbar_p2m->p_local_in[p]                (signal_dspin_p2m_proc[p]);
+
+    std::cout << "  - P2M Coherence crossbar connected" << std::endl;
+
     ////////////////////// CLACK DSPIN local crossbar coherence
-    xbar_clack_c->p_clk                          (this->p_clk);
-    xbar_clack_c->p_resetn                       (this->p_resetn);
-    xbar_clack_c->p_global_out                   (signal_dspin_clack_l2g_c);
-    xbar_clack_c->p_global_in                    (signal_dspin_clack_g2l_c);
-    xbar_clack_c->p_local_in[0]                  (signal_dspin_clack_memc);
+    xbar_cla->p_clk                          (this->p_clk);
+    xbar_cla->p_resetn                       (this->p_resetn);
+    xbar_cla->p_global_out                   (signal_dspin_clack_l2g_c);
+    xbar_cla->p_global_in                    (signal_dspin_clack_g2l_c);
+    xbar_cla->p_local_in[0]                  (signal_dspin_clack_memc);
     for (size_t p = 0; p < nb_procs; p++)
-        xbar_clack_c->p_local_out[p]             (signal_dspin_clack_proc[p]);
-
-    std::cout << "  - Clack Coherence crossbar connected" << std::endl;
-
-    ////////////////////////// P2M DSPIN local crossbar coherence
-    xbar_p2m_c->p_clk                            (this->p_clk);
-    xbar_p2m_c->p_resetn                         (this->p_resetn);
-    xbar_p2m_c->p_global_out                     (signal_dspin_p2m_l2g_c);
-    xbar_p2m_c->p_global_in                      (signal_dspin_p2m_g2l_c);
-    xbar_p2m_c->p_local_out[0]                   (signal_dspin_p2m_memc);
-    for (size_t p = 0; p < nb_procs; p++)
-        xbar_p2m_c->p_local_in[p]                (signal_dspin_p2m_proc[p]);
-
-    std::cout << "  - P2M Coherence crossbar connected" << std::endl;
-
+        xbar_cla->p_local_out[p]             (signal_dspin_clack_proc[p]);
+
+    std::cout << "  - CLA Coherence crossbar connected" << std::endl;
 
     //////////////////////////////////// Processors
@@ -569,8 +490,9 @@
         proc[p]->p_dspin_p2m                (signal_dspin_p2m_proc[p]);
         proc[p]->p_dspin_clack              (signal_dspin_clack_proc[p]);
-        proc[p]->p_irq[0]                   (signal_proc_it[p]);
-        for ( size_t j = 1 ; j < 6 ; j++)
+
+        for ( size_t j = 0 ; j < 6 ; j++)
         {
-            proc[p]->p_irq[j]               (signal_false);
+            if ( j < 4 ) proc[p]->p_irq[j]  (signal_proc_irq[4*p + j]);
+            else         proc[p]->p_irq[j]  (signal_false);
         }
 
@@ -588,29 +510,23 @@
     xicu->p_resetn                     (this->p_resetn);
     xicu->p_vci                        (signal_vci_tgt_xicu);
-    for (size_t p = 0; p < nb_procs; p++)
-    {
-        xicu->p_irq[p]                 (signal_proc_it[p]);
-    }
-
-    for (size_t i = 0; i < 32; i++)
-    {
-        if (io) // I/O cluster
+
+    for (size_t i = 0 ; i < 16  ; i++)
+    {
+        xicu->p_irq[i]                 (signal_proc_irq[i]);
+    }
+
+    for (size_t i = 0; i < 16; i++)
+    {
+        if ((x_id == 0) and (y_id == 0)) // cluster (0,0)
         {
-            if      (i == 0)                 xicu->p_hwi[i] (signal_irq_bdev);
-            else if (i < 8)                  xicu->p_hwi[i] (signal_false);
-            else if (i < (8 + nb_dmas))      xicu->p_hwi[i] (signal_irq_mdma[i - 8]);
-            else if (i < 12)                 xicu->p_hwi[i] (signal_false);
-            else if (i == 12)                xicu->p_hwi[i] (signal_irq_memc);
-            else if (i < 16)                 xicu->p_hwi[i] (signal_false);
-            else if (i < (16 + nb_ttys))     xicu->p_hwi[i] (signal_irq_mtty[i - 16]);
-            else                             xicu->p_hwi[i] (signal_false);
+            if      (i == 8)           xicu->p_hwi[i] (signal_irq_memc);
+            else if (i == 9)           xicu->p_hwi[i] (signal_irq_bdev);
+            else if (i == 10)          xicu->p_hwi[i] (signal_irq_mtty);
+            else                       xicu->p_hwi[i] (signal_false);
         }
-        else      // other clusters
+        else                             // other clusters
         {
-            if      (i < 8)                  xicu->p_hwi[i] (signal_false);
-            else if (i < (8 + nb_dmas))      xicu->p_hwi[i] (signal_irq_mdma[i - 8]);
-            else if (i < 12)                 xicu->p_hwi[i] (signal_false);
-            else if (i == 12)                xicu->p_hwi[i] (signal_irq_memc);
-            else                             xicu->p_hwi[i] (signal_false);
+            if (i == 1)                xicu->p_hwi[i] (signal_irq_memc);
+            else                       xicu->p_hwi[i] (signal_false);
         }
     }
@@ -651,31 +567,7 @@
     std::cout << "  - XRAM connected" << std::endl;
 
-    ////////////////////////////////////////////// MDMA
-    mdma->p_clk                        (this->p_clk);
-    mdma->p_resetn                     (this->p_resetn);
-    mdma->p_vci_target                 (signal_vci_tgt_mdma);
-    mdma->p_vci_initiator              (signal_vci_ini_mdma);
-    for (size_t i = 0; i < nb_dmas; i++)
-        mdma->p_irq[i]                 (signal_irq_mdma[i]);
-
-    // wrapper tgt MDMA
-    wt_mdma->p_clk                     (this->p_clk);
-    wt_mdma->p_resetn                  (this->p_resetn);
-    wt_mdma->p_dspin_cmd               (signal_dspin_cmd_mdma_t);
-    wt_mdma->p_dspin_rsp               (signal_dspin_rsp_mdma_t);
-    wt_mdma->p_vci                     (signal_vci_tgt_mdma);
-
-    // wrapper ini MDMA
-    wi_mdma->p_clk                     (this->p_clk);
-    wi_mdma->p_resetn                  (this->p_resetn);
-    wi_mdma->p_dspin_cmd               (signal_dspin_cmd_mdma_i);
-    wi_mdma->p_dspin_rsp               (signal_dspin_rsp_mdma_i);
-    wi_mdma->p_vci                     (signal_vci_ini_mdma);
-
-    std::cout << "  - MDMA connected" << std::endl;
-
-    /////////////////////////////// Components in I/O cluster
-
-    if (io)
+    /////////////////////////////// Extra Components in cluster(0,0)
+
+    if ((x_id == 0) and (y_id == 0))
     {
         // BDEV
@@ -702,71 +594,9 @@
         std::cout << "  - BDEV connected" << std::endl;
 
-        // FBUF
-        fbuf->p_clk                    (this->p_clk);
-        fbuf->p_resetn                 (this->p_resetn);
-        fbuf->p_vci                    (signal_vci_tgt_fbuf);
-
-        // wrapper tgt FBUF
-        wt_fbuf->p_clk                 (this->p_clk);
-        wt_fbuf->p_resetn              (this->p_resetn);
-        wt_fbuf->p_dspin_cmd           (signal_dspin_cmd_fbuf_t);
-        wt_fbuf->p_dspin_rsp           (signal_dspin_rsp_fbuf_t);
-        wt_fbuf->p_vci                 (signal_vci_tgt_fbuf);
-
-        std::cout << "  - FBUF connected" << std::endl;
-
-        // MNIC
-        mnic->p_clk                    (this->p_clk);
-        mnic->p_resetn                 (this->p_resetn);
-        mnic->p_vci                    (signal_vci_tgt_mnic);
-        for (size_t i = 0; i < nic_channels; i++)
-        {
-            mnic->p_rx_irq[i]          (signal_irq_mnic_rx[i]);
-            mnic->p_tx_irq[i]          (signal_irq_mnic_tx[i]);
-        }
-
-        // wrapper tgt MNIC
-        wt_mnic->p_clk                 (this->p_clk);
-        wt_mnic->p_resetn              (this->p_resetn);
-        wt_mnic->p_dspin_cmd           (signal_dspin_cmd_mnic_t);
-        wt_mnic->p_dspin_rsp           (signal_dspin_rsp_mnic_t);
-        wt_mnic->p_vci                 (signal_vci_tgt_mnic);
-
-        std::cout << "  - MNIC connected" << std::endl;
-
-        // CHBUF
-        chbuf->p_clk                    (this->p_clk);
-        chbuf->p_resetn                 (this->p_resetn);
-        chbuf->p_vci_target             (signal_vci_tgt_chbuf);
-        chbuf->p_vci_initiator          (signal_vci_ini_chbuf);
-        for (size_t i = 0; i < chbufdma_channels; i++)
-        {
-            chbuf->p_irq[i]          (signal_irq_chbuf[i]);
-        }
-
-        // wrapper tgt CHBUF
-        wt_chbuf->p_clk                 (this->p_clk);
-        wt_chbuf->p_resetn              (this->p_resetn);
-        wt_chbuf->p_dspin_cmd           (signal_dspin_cmd_chbuf_t);
-        wt_chbuf->p_dspin_rsp           (signal_dspin_rsp_chbuf_t);
-        wt_chbuf->p_vci                 (signal_vci_tgt_chbuf);
-
-        // wrapper ini CHBUF
-        wi_chbuf->p_clk                 (this->p_clk);
-        wi_chbuf->p_resetn              (this->p_resetn);
-        wi_chbuf->p_dspin_cmd           (signal_dspin_cmd_chbuf_i);
-        wi_chbuf->p_dspin_rsp           (signal_dspin_rsp_chbuf_i);
-        wi_chbuf->p_vci                 (signal_vci_ini_chbuf);
-
-        std::cout << "  - CHBUF connected" << std::endl;
-
-        // MTTY
+        // MTTY (single channel)
         mtty->p_clk                    (this->p_clk);
         mtty->p_resetn                 (this->p_resetn);
         mtty->p_vci                    (signal_vci_tgt_mtty);
-        for (size_t i = 0; i < nb_ttys; i++)
-        {
-            mtty->p_irq[i]             (signal_irq_mtty[i]);
-        }
+        mtty->p_irq[0]                 (signal_irq_mtty);
 
         // wrapper tgt MTTY
@@ -777,19 +607,6 @@
         wt_mtty->p_vci                 (signal_vci_tgt_mtty);
 
-
-        // Sim Helper
-        simhelper->p_clk               (this->p_clk);
-        simhelper->p_resetn            (this->p_resetn);
-        simhelper->p_vci               (signal_vci_tgt_simh);
-        
-        // wrapper tgt Sim Helper
-        wt_simhelper->p_clk            (this->p_clk);
-        wt_simhelper->p_resetn         (this->p_resetn);
-        wt_simhelper->p_dspin_cmd      (signal_dspin_cmd_simh_t);
-        wt_simhelper->p_dspin_rsp      (signal_dspin_rsp_simh_t);
-        wt_simhelper->p_vci            (signal_vci_tgt_simh);
-
         std::cout << "  - MTTY connected" << std::endl;
-   }
+    }
 } // end constructor
 
@@ -804,13 +621,23 @@
                                                  vci_param_ext>::~TsarLetiCluster() {
 
-    dealloc_elems<DspinInput<dspin_cmd_width> > (p_cmd_in, 4, 3);
-    dealloc_elems<DspinOutput<dspin_cmd_width> >(p_cmd_out, 4, 3);
-    dealloc_elems<DspinInput<dspin_rsp_width> > (p_rsp_in, 4, 2);
-    dealloc_elems<DspinOutput<dspin_rsp_width> >(p_rsp_out, 4, 2);
-
-    for (size_t p = 0; p < n_procs; p++)
-    {
-        delete proc[p];
-        delete wi_proc[p];
+    dealloc_elems<DspinInput<dspin_cmd_width> > (p_cmd_in, 4);
+    dealloc_elems<DspinOutput<dspin_cmd_width> >(p_cmd_out, 4);
+
+    dealloc_elems<DspinInput<dspin_rsp_width> > (p_rsp_in, 4);
+    dealloc_elems<DspinOutput<dspin_rsp_width> >(p_rsp_out, 4);
+
+    dealloc_elems<DspinInput<dspin_cmd_width> > (p_m2p_in, 4);
+    dealloc_elems<DspinOutput<dspin_cmd_width> >(p_m2p_out, 4);
+
+    dealloc_elems<DspinInput<dspin_rsp_width> > (p_p2m_in, 4);
+    dealloc_elems<DspinOutput<dspin_rsp_width> >(p_p2m_out, 4);
+
+    dealloc_elems<DspinInput<dspin_cmd_width> > (p_cla_in, 4);
+    dealloc_elems<DspinOutput<dspin_cmd_width> >(p_cla_out, 4);
+
+    for (size_t p = 0; p < 4 ; p++)
+    {
+        if ( proc[p] )     delete proc[p];
+        if ( wi_proc[p] )  delete wi_proc[p];
     }
 
@@ -820,30 +647,26 @@
     delete xicu;
     delete wt_xicu;
-    delete mdma;
-    delete wt_mdma;
-    delete wi_mdma;
-    delete xbar_cmd_d;
-    delete xbar_rsp_d;
-    delete xbar_m2p_c;
-    delete xbar_p2m_c;
-    delete xbar_clack_c;
+    delete xbar_cmd;
+    delete xbar_rsp;
+    delete xbar_m2p;
+    delete xbar_p2m;
+    delete xbar_cla;
     delete router_cmd;
     delete router_rsp;
-    if (bdev != NULL)
-    {
-        delete fbuf;
-        delete wt_fbuf;
+    delete router_m2p;
+    delete router_p2m;
+    delete router_cla;
+
+    if ( bdev )
+    {
         delete bdev;
         delete wt_bdev;
         delete wi_bdev;
-        delete mnic;
-        delete wt_mnic;
-        delete chbuf;
-        delete wt_chbuf;
-        delete wi_chbuf;
+    }
+
+    if ( mtty )
+    {
         delete mtty;
         delete wt_mtty;
-        delete simhelper;
-        delete wt_simhelper;
     }
 }
