Index: trunk/platforms/tsar_generic_iob/tsar_iob_cluster/caba/source/src/tsar_iob_cluster.cpp
===================================================================
--- trunk/platforms/tsar_generic_iob/tsar_iob_cluster/caba/source/src/tsar_iob_cluster.cpp	(revision 972)
+++ trunk/platforms/tsar_generic_iob/tsar_iob_cluster/caba/source/src/tsar_iob_cluster.cpp	(revision 1002)
@@ -97,11 +97,22 @@
 
     // Vectors of DSPIN ports for inter-cluster communications
-    p_dspin_int_cmd_in  = alloc_elems<DspinInput<dspin_int_cmd_width> >("p_int_cmd_in", 4, 3);
-    p_dspin_int_cmd_out = alloc_elems<DspinOutput<dspin_int_cmd_width> >("p_int_cmd_out", 4, 3);
-    p_dspin_int_rsp_in  = alloc_elems<DspinInput<dspin_int_rsp_width> >("p_int_rsp_in", 4, 2);
-    p_dspin_int_rsp_out = alloc_elems<DspinOutput<dspin_int_rsp_width> >("p_int_rsp_out", 4, 2);
+    p_dspin_int_cmd_in  = alloc_elems<DspinInput<dspin_int_cmd_width> >("p_int_cmd_in", 4);
+    p_dspin_int_cmd_out = alloc_elems<DspinOutput<dspin_int_cmd_width> >("p_int_cmd_out", 4);
+
+    p_dspin_int_rsp_in  = alloc_elems<DspinInput<dspin_int_rsp_width> >("p_int_rsp_in", 4);
+    p_dspin_int_rsp_out = alloc_elems<DspinOutput<dspin_int_rsp_width> >("p_int_rsp_out", 4);
+
+    p_dspin_int_m2p_in  = alloc_elems<DspinInput<dspin_int_cmd_width> >("p_int_m2p_in", 4);
+    p_dspin_int_m2p_out = alloc_elems<DspinOutput<dspin_int_cmd_width> >("p_int_m2p_out", 4);
+
+    p_dspin_int_p2m_in  = alloc_elems<DspinInput<dspin_int_rsp_width> >("p_int_p2m_in", 4);
+    p_dspin_int_p2m_out = alloc_elems<DspinOutput<dspin_int_rsp_width> >("p_int_p2m_out", 4);
+
+    p_dspin_int_cla_in  = alloc_elems<DspinInput<dspin_int_cmd_width> >("p_int_cla_in", 4);
+    p_dspin_int_cla_out = alloc_elems<DspinOutput<dspin_int_cmd_width> >("p_int_cla_out", 4);
 
     p_dspin_ram_cmd_in  = alloc_elems<DspinInput<dspin_ram_cmd_width> >("p_ext_cmd_in", 4);
     p_dspin_ram_cmd_out = alloc_elems<DspinOutput<dspin_ram_cmd_width> >("p_ext_cmd_out", 4);
+
     p_dspin_ram_rsp_in  = alloc_elems<DspinInput<dspin_ram_rsp_width> >("p_ext_rsp_in", 4);
     p_dspin_ram_rsp_out = alloc_elems<DspinOutput<dspin_ram_rsp_width> >("p_ext_rsp_out", 4);
@@ -114,9 +125,9 @@
     }
 
-    /////////////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////////////////
     //    Hardware components
-    /////////////////////////////////////////////////////////////////////////////
-
-    ////////////  PROCS
+    //////////////////////////////////////////////////////////////////////////////////
+
+    ////////////  PROCS  /////////////////////////////////////////////////////////////
     for (size_t p = 0; p < nb_procs; p++)
     {
@@ -147,5 +158,5 @@
     }
 
-    ///////////  MEMC
+    ////////////  MEMC   /////////////////////////////////////////////////////////////
     std::ostringstream s_memc;
     s_memc << "memc_" << x_id << "_" << y_id;
@@ -178,5 +189,5 @@
                      x_width + y_width + l_width);
 
-    ///////////   XICU
+    ///////////   XICU  //////////////////////////////////////////////////////////////
     std::ostringstream s_xicu;
     s_xicu << "xicu_" << x_id << "_" << y_id;
@@ -190,5 +201,5 @@
                      xcu_nb_out);                         // number of output IRQs
 
-    ////////////  MWMR controller and coprocessor
+    ////////////  MWMR controller and COPROC  ////////////////////////////////////////
     std::ostringstream s_mwmr;
     std::ostringstream s_copro;
@@ -244,5 +255,5 @@
     }
 
-    ///////////  Direct LOCAL_XBAR(S)
+    ///////////  VCI INT_CMD/RSP LOCAL_XBAR  ////////////////////////////////////// 
     size_t nb_direct_initiators = is_io ? nb_procs + 2 : nb_procs + 1;
     size_t nb_direct_targets    = is_io ? 4 : 3;
@@ -276,5 +287,5 @@
                      x_width + y_width + l_width);
 
-    ////////////  Coherence LOCAL_XBAR(S)
+    ////////////  DSPIN INT_M2P LOCAL_XBAR  ////////////////////////////////////////
     std::ostringstream s_int_xbar_m2p_c;
     s_int_xbar_m2p_c << "int_xbar_m2p_c_" << x_id << "_" << y_id;
@@ -291,4 +302,5 @@
                      true );                       // broacast
 
+    ////////////  DSPIN INT_P2M LOCAL_XBAR  ////////////////////////////////////////
     std::ostringstream s_int_xbar_p2m_c;
     s_int_xbar_p2m_c << "int_xbar_p2m_c_" << x_id << "_" << y_id;
@@ -305,4 +317,5 @@
                      false );                      // no broacast
 
+    ////////////  DSPIN INT_CLA LOCAL_XBAR  ////////////////////////////////////////
     std::ostringstream s_int_xbar_clack_c;
     s_int_xbar_clack_c << "int_xbar_clack_c_" << x_id << "_" << y_id;
@@ -319,24 +332,51 @@
                      false);                       // broadcast
 
-    //////////////  INT ROUTER(S)
+    ////////////  DSPIN INT_CMD ROUTER ////////////////////////////////////////////
     std::ostringstream s_int_router_cmd;
-    s_int_router_cmd << "router_cmd_" << x_id << "_" << y_id;
-    int_router_cmd = new VirtualDspinRouter<dspin_int_cmd_width>(
+    s_int_router_cmd << "int_router_cmd_" << x_id << "_" << y_id;
+    int_router_cmd = new DspinRouter<dspin_int_cmd_width>(
                      s_int_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
 
+    ////////////  DSPIN INT_RSP ROUTER ////////////////////////////////////////////
     std::ostringstream s_int_router_rsp;
-    s_int_router_rsp << "router_rsp_" << x_id << "_" << y_id;
-    int_router_rsp = new VirtualDspinRouter<dspin_int_rsp_width>(
+    s_int_router_rsp << "int_router_rsp_" << x_id << "_" << y_id;
+    int_router_rsp = new DspinRouter<dspin_int_rsp_width>(
                      s_int_router_rsp.str().c_str(),
-                     x_id,y_id,                    // router coordinates in mesh
+                     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
 
-    //////////////  XRAM
+    ////////////  DSPIN INT_M2P ROUTER ////////////////////////////////////////////
+    std::ostringstream s_int_router_m2p;
+    s_int_router_m2p << "int_router_m2p_" << x_id << "_" << y_id;
+    int_router_m2p = new DspinRouter<dspin_int_cmd_width>(
+                     s_int_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
+
+    ////////////  DSPIN INT_P2M ROUTER ////////////////////////////////////////////
+    std::ostringstream s_int_router_p2m;
+    s_int_router_p2m << "int_router_p2m_" << x_id << "_" << y_id;
+    int_router_p2m = new DspinRouter<dspin_int_rsp_width>(
+                     s_int_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
+
+    ////////////  DSPIN INT_CLA ROUTER ////////////////////////////////////////////
+    std::ostringstream s_int_router_cla;
+    s_int_router_cla << "int_router_cla_" << x_id << "_" << y_id;
+    int_router_cla = new DspinRouter<dspin_int_cmd_width>(
+                     s_int_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
+
+    //////////////  XRAM  /////////////////////////////////////////////////////////
     std::ostringstream s_xram;
     s_xram << "xram_" << x_id << "_" << y_id;
@@ -356,5 +396,5 @@
                      x_width + y_width + l_width);
 
-    /////////////  RAM ROUTER(S)
+    ////////////  DSPIN RAM_CMD ROUTER  ///////////////////////////////////////////
     std::ostringstream s_ram_router_cmd;
     s_ram_router_cmd << "ram_router_cmd_" << x_id << "_" << y_id;
@@ -366,4 +406,5 @@
                      4, 4);                          // input & output fifo depths
 
+    ////////////  DSPIN RAM_RSP ROUTER  ///////////////////////////////////////////
     std::ostringstream s_ram_router_rsp;
     s_ram_router_rsp << "ram_router_rsp_" << x_id << "_" << y_id;
@@ -376,8 +417,8 @@
 
 
-    ////////////////////// I/O  CLUSTER ONLY    ///////////////////////
+    ////////////////////// I/O  CLUSTER ONLY    ///////////////////////////////////
     if ( is_io )
     {
-        ///////////  IO_BRIDGE
+        ///////////  IO_BRIDGE ////////////////////////////////////////////////////
         std::ostringstream s_iob;
         s_iob << "iob_" << x_id << "_" << y_id;
@@ -406,4 +447,5 @@
                      vci_param_int::S);
 
+        ////////////  DSPIN RAM_CMD LOCAL_XBAR  ///////////////////////////////////
         std::ostringstream s_ram_xbar_cmd;
         s_ram_xbar_cmd << "s_ram_xbar_cmd_" << x_id << "_" << y_id;
@@ -419,4 +461,5 @@
               false);                       // support broadcast ?
 
+        ////////////  DSPIN RAM_RSP LOCAL_XBAR  ///////////////////////////////////
         std::ostringstream s_ram_xbar_rsp;
         s_ram_xbar_rsp << "s_ram_xbar_rsp_" << x_id << "_" << y_id;
@@ -431,4 +474,5 @@
               true,                         // use routing table ?
               false);                       // support broadcast ?
+
     } // end if IO
 
@@ -440,96 +484,4 @@
     //                      : local srcid[memc] = nb_procs
 
-    //////////////////////// internal CMD & RSP routers
-    int_router_cmd->p_clk                        (this->p_clk);
-    int_router_cmd->p_resetn                     (this->p_resetn);
-    int_router_rsp->p_clk                        (this->p_clk);
-    int_router_rsp->p_resetn                     (this->p_resetn);
-
-    for (int i = 0; i < 4; i++)
-    {
-        for(int k = 0; k < 3; k++)
-        {
-            int_router_cmd->p_out[i][k]          (this->p_dspin_int_cmd_out[i][k]);
-            int_router_cmd->p_in[i][k]           (this->p_dspin_int_cmd_in[i][k]);
-        }
-
-        for(int k = 0; k < 2; k++)
-        {
-            int_router_rsp->p_out[i][k]          (this->p_dspin_int_rsp_out[i][k]);
-            int_router_rsp->p_in[i][k]           (this->p_dspin_int_rsp_in[i][k]);
-        }
-    }
-
-    // local ports
-    int_router_cmd->p_out[4][0]                  (signal_int_dspin_cmd_g2l_d);
-    int_router_cmd->p_out[4][1]                  (signal_int_dspin_m2p_g2l_c);
-    int_router_cmd->p_out[4][2]                  (signal_int_dspin_clack_g2l_c);
-    int_router_cmd->p_in[4][0]                   (signal_int_dspin_cmd_l2g_d);
-    int_router_cmd->p_in[4][1]                   (signal_int_dspin_m2p_l2g_c);
-    int_router_cmd->p_in[4][2]                   (signal_int_dspin_clack_l2g_c);
-
-    int_router_rsp->p_out[4][0]                  (signal_int_dspin_rsp_g2l_d);
-    int_router_rsp->p_out[4][1]                  (signal_int_dspin_p2m_g2l_c);
-    int_router_rsp->p_in[4][0]                   (signal_int_dspin_rsp_l2g_d);
-    int_router_rsp->p_in[4][1]                   (signal_int_dspin_p2m_l2g_c);
-
-    ///////////////////// CMD DSPIN  local crossbar direct
-    int_xbar_d->p_clk                                 (this->p_clk);
-    int_xbar_d->p_resetn                              (this->p_resetn);
-    int_xbar_d->p_initiator_to_up                     (signal_int_vci_l2g);
-    int_xbar_d->p_target_to_up                        (signal_int_vci_g2l);
-
-    int_xbar_d->p_to_target[int_memc_tgt_id]          (signal_int_vci_tgt_memc);
-    int_xbar_d->p_to_target[int_xicu_tgt_id]          (signal_int_vci_tgt_xicu);
-    int_xbar_d->p_to_target[int_mwmr_tgt_id]          (signal_int_vci_tgt_mwmr);
-    int_xbar_d->p_to_initiator[int_mwmr_ini_id]       (signal_int_vci_ini_mwmr);
-    for (size_t p = 0; p < nb_procs; p++)
-       int_xbar_d->p_to_initiator[int_proc_ini_id + p] (signal_int_vci_ini_proc[p]);
-
-    if ( is_io )
-    {
-       int_xbar_d->p_to_target[int_iobx_tgt_id]        (signal_int_vci_tgt_iobx);
-       int_xbar_d->p_to_initiator[int_iobx_ini_id]     (signal_int_vci_ini_iobx);
-    }
-
-    int_wi_gate_d->p_clk                         (this->p_clk);
-    int_wi_gate_d->p_resetn                      (this->p_resetn);
-    int_wi_gate_d->p_vci                         (signal_int_vci_l2g);
-    int_wi_gate_d->p_dspin_cmd                   (signal_int_dspin_cmd_l2g_d);
-    int_wi_gate_d->p_dspin_rsp                   (signal_int_dspin_rsp_g2l_d);
-
-    int_wt_gate_d->p_clk                         (this->p_clk);
-    int_wt_gate_d->p_resetn                      (this->p_resetn);
-    int_wt_gate_d->p_vci                         (signal_int_vci_g2l);
-    int_wt_gate_d->p_dspin_cmd                   (signal_int_dspin_cmd_g2l_d);
-    int_wt_gate_d->p_dspin_rsp                   (signal_int_dspin_rsp_l2g_d);
-
-    ////////////////////// M2P DSPIN local crossbar coherence
-    int_xbar_m2p_c->p_clk                        (this->p_clk);
-    int_xbar_m2p_c->p_resetn                     (this->p_resetn);
-    int_xbar_m2p_c->p_global_out                 (signal_int_dspin_m2p_l2g_c);
-    int_xbar_m2p_c->p_global_in                  (signal_int_dspin_m2p_g2l_c);
-    int_xbar_m2p_c->p_local_in[0]                (signal_int_dspin_m2p_memc);
-    for (size_t p = 0; p < nb_procs; p++)
-        int_xbar_m2p_c->p_local_out[p]           (signal_int_dspin_m2p_proc[p]);
-
-    ////////////////////////// P2M DSPIN local crossbar coherence
-    int_xbar_p2m_c->p_clk                        (this->p_clk);
-    int_xbar_p2m_c->p_resetn                     (this->p_resetn);
-    int_xbar_p2m_c->p_global_out                 (signal_int_dspin_p2m_l2g_c);
-    int_xbar_p2m_c->p_global_in                  (signal_int_dspin_p2m_g2l_c);
-    int_xbar_p2m_c->p_local_out[0]               (signal_int_dspin_p2m_memc);
-    for (size_t p = 0; p < nb_procs; p++)
-        int_xbar_p2m_c->p_local_in[p]            (signal_int_dspin_p2m_proc[p]);
-
-    ////////////////////// CLACK DSPIN local crossbar coherence
-    int_xbar_clack_c->p_clk                      (this->p_clk);
-    int_xbar_clack_c->p_resetn                   (this->p_resetn);
-    int_xbar_clack_c->p_global_out               (signal_int_dspin_clack_l2g_c);
-    int_xbar_clack_c->p_global_in                (signal_int_dspin_clack_g2l_c);
-    int_xbar_clack_c->p_local_in[0]              (signal_int_dspin_clack_memc);
-    for (size_t p = 0; p < nb_procs; p++)
-        int_xbar_clack_c->p_local_out[p]         (signal_int_dspin_clack_proc[p]);
-
     //////////////////////////////////// Processors
     for (size_t p = 0; p < nb_procs; p++)
@@ -537,8 +489,9 @@
         proc[p]->p_clk                           (this->p_clk);
         proc[p]->p_resetn                        (this->p_resetn);
+
         proc[p]->p_vci                           (signal_int_vci_ini_proc[p]);
         proc[p]->p_dspin_m2p                     (signal_int_dspin_m2p_proc[p]);
         proc[p]->p_dspin_p2m                     (signal_int_dspin_p2m_proc[p]);
-        proc[p]->p_dspin_clack                   (signal_int_dspin_clack_proc[p]);
+        proc[p]->p_dspin_clack                   (signal_int_dspin_cla_proc[p]);
 
         for ( size_t j = 0 ; j < 6 ; j++)
@@ -549,4 +502,6 @@
     }
 
+    std::cout << "  - processors connected" << std::endl;
+
     ///////////////////////////////////// XICU
     xicu->p_clk                                  (this->p_clk);
@@ -563,4 +518,6 @@
         else                     xicu->p_hwi[i]  (signal_false);
     }
+
+    std::cout << "  - xcu connected" << std::endl;
 
     ///////////////////////////////////// MEMC
@@ -571,5 +528,5 @@
     memc->p_dspin_p2m                            (signal_int_dspin_p2m_memc);
     memc->p_dspin_m2p                            (signal_int_dspin_m2p_memc);
-    memc->p_dspin_clack                          (signal_int_dspin_clack_memc);
+    memc->p_dspin_clack                          (signal_int_dspin_cla_memc);
     memc->p_irq                                  (signal_irq_memc);
 
@@ -581,4 +538,6 @@
     memc_ram_wi->p_vci                           (signal_ram_vci_ini_memc);
 
+    std::cout << "  - memc connected" << std::endl;
+
     //////////////////////////////////// XRAM
     xram->p_clk                                  (this->p_clk);
@@ -592,4 +551,6 @@
     xram_ram_wt->p_dspin_rsp                     (signal_ram_dspin_rsp_xram_t);
     xram_ram_wt->p_vci                           (signal_ram_vci_tgt_xram);
+
+    std::cout << "  - xram connected" << std::endl;
 
     /////////////////////////////////// GCD coprocessor
@@ -633,4 +594,6 @@
     }
 
+    std::cout << "  - coproc connected" << std::endl;
+
     /////////////////////////////////// CPY coprocessor
     if ( coproc_type == MWR_COPROC_CPY )
@@ -652,9 +615,10 @@
     }
 
-    //////////////////////////// RAM network CMD & RSP routers
+    //////////////////////////// RAM NETWORK ROUTERS
     ram_router_cmd->p_clk                        (this->p_clk);
     ram_router_cmd->p_resetn                     (this->p_resetn);
     ram_router_rsp->p_clk                        (this->p_clk);
     ram_router_rsp->p_resetn                     (this->p_resetn);
+
     for( size_t n=0 ; n<4 ; n++)
     {
@@ -678,4 +642,112 @@
        ram_router_rsp->p_out[4]                  (signal_ram_dspin_rsp_memc_i);
     }
+
+    ///////////////////////////// INT NETWORK ROUTERS
+    int_router_cmd->p_clk                        (this->p_clk);
+    int_router_cmd->p_resetn                     (this->p_resetn);
+    int_router_rsp->p_clk                        (this->p_clk);
+    int_router_rsp->p_resetn                     (this->p_resetn);
+    int_router_m2p->p_clk                        (this->p_clk);
+    int_router_m2p->p_resetn                     (this->p_resetn);
+    int_router_p2m->p_clk                        (this->p_clk);
+    int_router_p2m->p_resetn                     (this->p_resetn);
+    int_router_cla->p_clk                        (this->p_clk);
+    int_router_cla->p_resetn                     (this->p_resetn);
+
+    // loop on N/S/E/W ports
+    for (size_t i = 0; i < 4; i++)
+    {
+        int_router_cmd->p_out[i]                 (this->p_dspin_int_cmd_out[i]);
+        int_router_cmd->p_in[i]                  (this->p_dspin_int_cmd_in[i]);
+
+        int_router_rsp->p_out[i]                 (this->p_dspin_int_rsp_out[i]);
+        int_router_rsp->p_in[i]                  (this->p_dspin_int_rsp_in[i]);
+
+        int_router_m2p->p_out[i]                 (this->p_dspin_int_m2p_out[i]);
+        int_router_m2p->p_in[i]                  (this->p_dspin_int_m2p_in[i]);
+
+        int_router_p2m->p_out[i]                 (this->p_dspin_int_p2m_out[i]);
+        int_router_p2m->p_in[i]                  (this->p_dspin_int_p2m_in[i]);
+
+        int_router_cla->p_out[i]                 (this->p_dspin_int_cla_out[i]);
+        int_router_cla->p_in[i]                  (this->p_dspin_int_cla_in[i]);
+    }
+
+    int_router_cmd->p_out[4]                     (signal_int_dspin_cmd_g2l_d);
+    int_router_cmd->p_in[4]                      (signal_int_dspin_cmd_l2g_d);
+
+    int_router_rsp->p_out[4]                     (signal_int_dspin_rsp_g2l_d);
+    int_router_rsp->p_in[4]                      (signal_int_dspin_rsp_l2g_d);
+
+    int_router_m2p->p_out[4]                     (signal_int_dspin_m2p_g2l_c);
+    int_router_m2p->p_in[4]                      (signal_int_dspin_m2p_l2g_c);
+
+    int_router_p2m->p_out[4]                     (signal_int_dspin_p2m_g2l_c);
+    int_router_p2m->p_in[4]                      (signal_int_dspin_p2m_l2g_c);
+
+    int_router_cla->p_out[4]                     (signal_int_dspin_cla_g2l_c);
+    int_router_cla->p_in[4]                      (signal_int_dspin_cla_l2g_c);
+
+    std::cout << "  - internal routers connected" << std::endl;
+
+
+    ///////////////////// CMD DSPIN  local crossbar direct
+    int_xbar_d->p_clk                            (this->p_clk);
+    int_xbar_d->p_resetn                         (this->p_resetn);
+    int_xbar_d->p_initiator_to_up                (signal_int_vci_l2g);
+    int_xbar_d->p_target_to_up                   (signal_int_vci_g2l);
+
+    int_xbar_d->p_to_target[int_memc_tgt_id]     (signal_int_vci_tgt_memc);
+    int_xbar_d->p_to_target[int_xicu_tgt_id]     (signal_int_vci_tgt_xicu);
+    int_xbar_d->p_to_target[int_mwmr_tgt_id]     (signal_int_vci_tgt_mwmr);
+    int_xbar_d->p_to_initiator[int_mwmr_ini_id]  (signal_int_vci_ini_mwmr);
+    for (size_t p = 0; p < nb_procs; p++)
+       int_xbar_d->p_to_initiator[int_proc_ini_id + p] (signal_int_vci_ini_proc[p]);
+
+    if ( is_io )
+    {
+       int_xbar_d->p_to_target[int_iobx_tgt_id]        (signal_int_vci_tgt_iobx);
+       int_xbar_d->p_to_initiator[int_iobx_ini_id]     (signal_int_vci_ini_iobx);
+    }
+
+    int_wi_gate_d->p_clk                         (this->p_clk);
+    int_wi_gate_d->p_resetn                      (this->p_resetn);
+    int_wi_gate_d->p_vci                         (signal_int_vci_l2g);
+    int_wi_gate_d->p_dspin_cmd                   (signal_int_dspin_cmd_l2g_d);
+    int_wi_gate_d->p_dspin_rsp                   (signal_int_dspin_rsp_g2l_d);
+
+    int_wt_gate_d->p_clk                         (this->p_clk);
+    int_wt_gate_d->p_resetn                      (this->p_resetn);
+    int_wt_gate_d->p_vci                         (signal_int_vci_g2l);
+    int_wt_gate_d->p_dspin_cmd                   (signal_int_dspin_cmd_g2l_d);
+    int_wt_gate_d->p_dspin_rsp                   (signal_int_dspin_rsp_l2g_d);
+
+    ////////////////////// M2P DSPIN local crossbar coherence
+    int_xbar_m2p_c->p_clk                        (this->p_clk);
+    int_xbar_m2p_c->p_resetn                     (this->p_resetn);
+    int_xbar_m2p_c->p_global_out                 (signal_int_dspin_m2p_l2g_c);
+    int_xbar_m2p_c->p_global_in                  (signal_int_dspin_m2p_g2l_c);
+    int_xbar_m2p_c->p_local_in[0]                (signal_int_dspin_m2p_memc);
+    for (size_t p = 0; p < nb_procs; p++)
+        int_xbar_m2p_c->p_local_out[p]           (signal_int_dspin_m2p_proc[p]);
+
+    ////////////////////////// P2M DSPIN local crossbar coherence
+    int_xbar_p2m_c->p_clk                        (this->p_clk);
+    int_xbar_p2m_c->p_resetn                     (this->p_resetn);
+    int_xbar_p2m_c->p_global_out                 (signal_int_dspin_p2m_l2g_c);
+    int_xbar_p2m_c->p_global_in                  (signal_int_dspin_p2m_g2l_c);
+    int_xbar_p2m_c->p_local_out[0]               (signal_int_dspin_p2m_memc);
+    for (size_t p = 0; p < nb_procs; p++)
+        int_xbar_p2m_c->p_local_in[p]            (signal_int_dspin_p2m_proc[p]);
+
+    ////////////////////// CLACK DSPIN local crossbar coherence
+    int_xbar_clack_c->p_clk                      (this->p_clk);
+    int_xbar_clack_c->p_resetn                   (this->p_resetn);
+    int_xbar_clack_c->p_global_out               (signal_int_dspin_cla_l2g_c);
+    int_xbar_clack_c->p_global_in                (signal_int_dspin_cla_g2l_c);
+    int_xbar_clack_c->p_local_in[0]              (signal_int_dspin_cla_memc);
+    for (size_t p = 0; p < nb_procs; p++)
+        int_xbar_clack_c->p_local_out[p]         (signal_int_dspin_cla_proc[p]);
+
 
     ///////////////////////// IOB exists only in cluster_iob0 & cluster_iob1.
