Changeset 466

Timestamp:

Jul 23, 2013, 5:01:49 PM (11 years ago)

Author:

cfuguet

Message:

Modifications in branches/v5 vci_mem_cache:

• Replacing the third router CLACK by a third virtual channel in the new virtual_dspin_router supporting several virtual channels.

The third channel has been added in the COMMAND router.

Location:

branches/v5/platforms/tsar_generic_xbar

Files:

• top.cpp (modified) (7 diffs)
• tsar_xbar_cluster/caba/source/include/tsar_xbar_cluster.h (modified) (2 diffs)
• tsar_xbar_cluster/caba/source/src/tsar_xbar_cluster.cpp (modified) (4 diffs)

branches/v5/platforms/tsar_generic_xbar/top.cpp

@@ -350 +350 @@
             "The NB_NIC_CHANNELS parameter must be smaller than 9" );
 
-    assert( (vci_address_width == vci_address_width) and
-            "address widths must be equal on internal & external networks" );
-
     assert( (vci_address_width == 40) and
             "VCI address width must be 40 bits" );
@@ -498 +495 @@
    // Horizontal inter-clusters DSPIN signals
    DspinSignals<dspin_cmd_width>*** signal_dspin_h_cmd_inc =
-      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_inc", XMAX-1, YMAX, 2);
+      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_inc", XMAX-1, YMAX, 3);
    DspinSignals<dspin_cmd_width>*** signal_dspin_h_cmd_dec =
-      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_dec", XMAX-1, YMAX, 2);
+      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_dec", XMAX-1, YMAX, 3);
    DspinSignals<dspin_rsp_width>*** signal_dspin_h_rsp_inc =
       alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_rsp_inc", XMAX-1, YMAX, 2);
    DspinSignals<dspin_rsp_width>*** signal_dspin_h_rsp_dec =
       alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_rsp_dec", XMAX-1, YMAX, 2);
-   DspinSignals<dspin_cmd_width>**  signal_dspin_h_clack_inc =
-      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_clack_inc", XMAX-1, YMAX);
-   DspinSignals<dspin_cmd_width>**  signal_dspin_h_clack_dec =
-      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_clack_dec", XMAX-1, YMAX);
 
    // Vertical inter-clusters DSPIN signals
    DspinSignals<dspin_cmd_width>*** signal_dspin_v_cmd_inc =
-      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_inc", XMAX, YMAX-1, 2);
+      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_inc", XMAX, YMAX-1, 3);
    DspinSignals<dspin_cmd_width>*** signal_dspin_v_cmd_dec =
-      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_dec", XMAX, YMAX-1, 2);
+      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_dec", XMAX, YMAX-1, 3);
    DspinSignals<dspin_rsp_width>*** signal_dspin_v_rsp_inc =
       alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_rsp_inc", XMAX, YMAX-1, 2);
    DspinSignals<dspin_rsp_width>*** signal_dspin_v_rsp_dec =
       alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_rsp_dec", XMAX, YMAX-1, 2);
-   DspinSignals<dspin_cmd_width>**  signal_dspin_v_clack_inc =
-      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_clack_inc", XMAX, YMAX-1);
-   DspinSignals<dspin_cmd_width>**  signal_dspin_v_clack_dec =
-      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_clack_dec", XMAX, YMAX-1);
 
    // Mesh boundaries DSPIN signals
    DspinSignals<dspin_cmd_width>**** signal_dspin_false_cmd_in =
-      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_cmd_in", XMAX, YMAX, 2, 4);
+      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_cmd_in" , XMAX, YMAX, 4, 3);
    DspinSignals<dspin_cmd_width>**** signal_dspin_false_cmd_out =
-      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_cmd_out", XMAX, YMAX, 2, 4);
+      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_cmd_out", XMAX, YMAX, 4, 3);
    DspinSignals<dspin_rsp_width>**** signal_dspin_false_rsp_in =
-      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_false_rsp_in", XMAX, YMAX, 2, 4);
+      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_false_rsp_in" , XMAX, YMAX, 4, 2);
    DspinSignals<dspin_rsp_width>**** signal_dspin_false_rsp_out =
-      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_false_rsp_out", XMAX, YMAX, 2, 4);
-   DspinSignals<dspin_cmd_width>***  signal_dspin_false_clack_in =
-      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_clack_in", XMAX, YMAX, 4);
-   DspinSignals<dspin_cmd_width>***  signal_dspin_false_clack_out =
-      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_clack_out", XMAX, YMAX, 4);
+      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_false_rsp_out", XMAX, YMAX, 4, 2);
 
 
@@ -655 +640 @@
       for (size_t x = 0; x < (XMAX-1); x++){
          for (size_t y = 0; y < YMAX; y++){
+            for (size_t k = 0; k < 3; k++){
+               clusters[x][y]->p_cmd_out[EAST][k]      (signal_dspin_h_cmd_inc[x][y][k]);
+               clusters[x+1][y]->p_cmd_in[WEST][k]     (signal_dspin_h_cmd_inc[x][y][k]);
+               clusters[x][y]->p_cmd_in[EAST][k]       (signal_dspin_h_cmd_dec[x][y][k]);
+               clusters[x+1][y]->p_cmd_out[WEST][k]    (signal_dspin_h_cmd_dec[x][y][k]);
+            }
+
             for (size_t k = 0; k < 2; k++){
-               clusters[x][y]->p_cmd_out[k][EAST]      (signal_dspin_h_cmd_inc[x][y][k]);
-               clusters[x+1][y]->p_cmd_in[k][WEST]     (signal_dspin_h_cmd_inc[x][y][k]);
-               clusters[x][y]->p_cmd_in[k][EAST]       (signal_dspin_h_cmd_dec[x][y][k]);
-               clusters[x+1][y]->p_cmd_out[k][WEST]    (signal_dspin_h_cmd_dec[x][y][k]);
-               clusters[x][y]->p_rsp_out[k][EAST]      (signal_dspin_h_rsp_inc[x][y][k]);
-               clusters[x+1][y]->p_rsp_in[k][WEST]     (signal_dspin_h_rsp_inc[x][y][k]);
-               clusters[x][y]->p_rsp_in[k][EAST]       (signal_dspin_h_rsp_dec[x][y][k]);
-               clusters[x+1][y]->p_rsp_out[k][WEST]    (signal_dspin_h_rsp_dec[x][y][k]);
+               clusters[x][y]->p_rsp_out[EAST][k]      (signal_dspin_h_rsp_inc[x][y][k]);
+               clusters[x+1][y]->p_rsp_in[WEST][k]     (signal_dspin_h_rsp_inc[x][y][k]);
+               clusters[x][y]->p_rsp_in[EAST][k]       (signal_dspin_h_rsp_dec[x][y][k]);
+               clusters[x+1][y]->p_rsp_out[WEST][k]    (signal_dspin_h_rsp_dec[x][y][k]);
             }
-            clusters[x][y]->p_clack_out[EAST]      (signal_dspin_h_clack_inc[x][y]);
-            clusters[x+1][y]->p_clack_in[WEST]     (signal_dspin_h_clack_inc[x][y]);
-            clusters[x][y]->p_clack_in[EAST]       (signal_dspin_h_clack_dec[x][y]);
-            clusters[x+1][y]->p_clack_out[WEST]    (signal_dspin_h_clack_dec[x][y]);
          }
       }
@@ -678 +662 @@
       for (size_t y = 0; y < (YMAX-1); y++){
          for (size_t x = 0; x < XMAX; x++){
+            for (size_t k = 0; k < 3; k++){
+               clusters[x][y]->p_cmd_out[NORTH][k]     (signal_dspin_v_cmd_inc[x][y][k]);
+               clusters[x][y+1]->p_cmd_in[SOUTH][k]    (signal_dspin_v_cmd_inc[x][y][k]);
+               clusters[x][y]->p_cmd_in[NORTH][k]      (signal_dspin_v_cmd_dec[x][y][k]);
+               clusters[x][y+1]->p_cmd_out[SOUTH][k]   (signal_dspin_v_cmd_dec[x][y][k]);
+            }
+
             for (size_t k = 0; k < 2; k++){
-               clusters[x][y]->p_cmd_out[k][NORTH]     (signal_dspin_v_cmd_inc[x][y][k]);
-               clusters[x][y+1]->p_cmd_in[k][SOUTH]    (signal_dspin_v_cmd_inc[x][y][k]);
-               clusters[x][y]->p_cmd_in[k][NORTH]      (signal_dspin_v_cmd_dec[x][y][k]);
-               clusters[x][y+1]->p_cmd_out[k][SOUTH]   (signal_dspin_v_cmd_dec[x][y][k]);
-               clusters[x][y]->p_rsp_out[k][NORTH]     (signal_dspin_v_rsp_inc[x][y][k]);
-               clusters[x][y+1]->p_rsp_in[k][SOUTH]    (signal_dspin_v_rsp_inc[x][y][k]);
-               clusters[x][y]->p_rsp_in[k][NORTH]      (signal_dspin_v_rsp_dec[x][y][k]);
-               clusters[x][y+1]->p_rsp_out[k][SOUTH]   (signal_dspin_v_rsp_dec[x][y][k]);
+               clusters[x][y]->p_rsp_out[NORTH][k]     (signal_dspin_v_rsp_inc[x][y][k]);
+               clusters[x][y+1]->p_rsp_in[SOUTH][k]    (signal_dspin_v_rsp_inc[x][y][k]);
+               clusters[x][y]->p_rsp_in[NORTH][k]      (signal_dspin_v_rsp_dec[x][y][k]);
+               clusters[x][y+1]->p_rsp_out[SOUTH][k]   (signal_dspin_v_rsp_dec[x][y][k]);
             }
-            clusters[x][y]->p_clack_out[NORTH]     (signal_dspin_v_clack_inc[x][y]);
-            clusters[x][y+1]->p_clack_in[SOUTH]    (signal_dspin_v_clack_inc[x][y]);
-            clusters[x][y]->p_clack_in[NORTH]      (signal_dspin_v_clack_dec[x][y]);
-            clusters[x][y+1]->p_clack_out[SOUTH]   (signal_dspin_v_clack_dec[x][y]);
          }
       }
@@ -700 +683 @@
    for (size_t y = 0; y < YMAX; y++)
    {
+      for (size_t k = 0; k < 3; k++)
+      {
+         clusters[0][y]->p_cmd_in[WEST][k]        (signal_dspin_false_cmd_in[0][y][WEST][k]);
+         clusters[0][y]->p_cmd_out[WEST][k]       (signal_dspin_false_cmd_out[0][y][WEST][k]);
+         clusters[XMAX-1][y]->p_cmd_in[EAST][k]   (signal_dspin_false_cmd_in[XMAX-1][y][EAST][k]);
+         clusters[XMAX-1][y]->p_cmd_out[EAST][k]  (signal_dspin_false_cmd_out[XMAX-1][y][EAST][k]);
+      }
+
       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]);
-         clusters[0][y]->p_rsp_in[k][WEST]        (signal_dspin_false_rsp_in[0][y][k][WEST]);
-         clusters[0][y]->p_rsp_out[k][WEST]       (signal_dspin_false_rsp_out[0][y][k][WEST]);
-
-         clusters[XMAX-1][y]->p_cmd_in[k][EAST]   (signal_dspin_false_cmd_in[XMAX-1][y][k][EAST]);
-         clusters[XMAX-1][y]->p_cmd_out[k][EAST]  (signal_dspin_false_cmd_out[XMAX-1][y][k][EAST]);
-         clusters[XMAX-1][y]->p_rsp_in[k][EAST]   (signal_dspin_false_rsp_in[XMAX-1][y][k][EAST]);
-         clusters[XMAX-1][y]->p_rsp_out[k][EAST]  (signal_dspin_false_rsp_out[XMAX-1][y][k][EAST]);
-      }
-
-      clusters[0][y]->p_clack_in[WEST]       (signal_dspin_false_clack_in[0][y][WEST]);
-      clusters[0][y]->p_clack_out[WEST]      (signal_dspin_false_clack_out[0][y][WEST]);
-
-      clusters[XMAX-1][y]->p_clack_in[EAST]  (signal_dspin_false_clack_in[XMAX-1][y][EAST]);
-      clusters[XMAX-1][y]->p_clack_out[EAST] (signal_dspin_false_clack_out[XMAX-1][y][EAST]);
+         clusters[0][y]->p_rsp_in[WEST][k]        (signal_dspin_false_rsp_in[0][y][WEST][k]);
+         clusters[0][y]->p_rsp_out[WEST][k]       (signal_dspin_false_rsp_out[0][y][WEST][k]);
+         clusters[XMAX-1][y]->p_rsp_in[EAST][k]   (signal_dspin_false_rsp_in[XMAX-1][y][EAST][k]);
+         clusters[XMAX-1][y]->p_rsp_out[EAST][k]  (signal_dspin_false_rsp_out[XMAX-1][y][EAST][k]);
+      }
    }
 
@@ -723 +703 @@
    for (size_t x = 0; x < XMAX; x++)
    {
+      for (size_t k = 0; k < 3; k++)
+      {
+         clusters[x][0]->p_cmd_in[SOUTH][k]       (signal_dspin_false_cmd_in[x][0][SOUTH][k]);
+         clusters[x][0]->p_cmd_out[SOUTH][k]      (signal_dspin_false_cmd_out[x][0][SOUTH][k]);
+         clusters[x][YMAX-1]->p_cmd_in[NORTH][k]  (signal_dspin_false_cmd_in[x][YMAX-1][NORTH][k]);
+         clusters[x][YMAX-1]->p_cmd_out[NORTH][k] (signal_dspin_false_cmd_out[x][YMAX-1][NORTH][k]);
+      }
+
       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]);
-         clusters[x][0]->p_rsp_in[k][SOUTH]       (signal_dspin_false_rsp_in[x][0][k][SOUTH]);
-         clusters[x][0]->p_rsp_out[k][SOUTH]      (signal_dspin_false_rsp_out[x][0][k][SOUTH]);
-
-         clusters[x][YMAX-1]->p_cmd_in[k][NORTH]  (signal_dspin_false_cmd_in[x][YMAX-1][k][NORTH]);
-         clusters[x][YMAX-1]->p_cmd_out[k][NORTH] (signal_dspin_false_cmd_out[x][YMAX-1][k][NORTH]);
-         clusters[x][YMAX-1]->p_rsp_in[k][NORTH]  (signal_dspin_false_rsp_in[x][YMAX-1][k][NORTH]);
-         clusters[x][YMAX-1]->p_rsp_out[k][NORTH] (signal_dspin_false_rsp_out[x][YMAX-1][k][NORTH]);
-      }
-
-      clusters[x][0]->p_clack_in[SOUTH]       (signal_dspin_false_clack_in[x][0][SOUTH]);
-      clusters[x][0]->p_clack_out[SOUTH]      (signal_dspin_false_clack_out[x][0][SOUTH]);
-
-      clusters[x][YMAX-1]->p_clack_in[NORTH]  (signal_dspin_false_clack_in[x][YMAX-1][NORTH]);
-      clusters[x][YMAX-1]->p_clack_out[NORTH] (signal_dspin_false_clack_out[x][YMAX-1][NORTH]);
+         clusters[x][0]->p_rsp_in[SOUTH][k]       (signal_dspin_false_rsp_in[x][0][SOUTH][k]);
+         clusters[x][0]->p_rsp_out[SOUTH][k]      (signal_dspin_false_rsp_out[x][0][SOUTH][k]);
+         clusters[x][YMAX-1]->p_rsp_in[NORTH][k]  (signal_dspin_false_rsp_in[x][YMAX-1][NORTH][k]);
+         clusters[x][YMAX-1]->p_rsp_out[NORTH][k] (signal_dspin_false_rsp_out[x][YMAX-1][NORTH][k]);
+      }
    }
    std::cout << "North, South, West, East connections established" << std::endl;
@@ -756 +733 @@
    for (size_t x = 0; x < XMAX ; x++){
       for (size_t y = 0; y < YMAX ; y++){
-         for (size_t k = 0; k < 2; k++){
-            for (size_t a = 0; a < 4; a++){
-               signal_dspin_false_cmd_in [x][y][k][a].write = false;
-               signal_dspin_false_cmd_in [x][y][k][a].read  = true;
-               signal_dspin_false_cmd_out[x][y][k][a].write = false;
-               signal_dspin_false_cmd_out[x][y][k][a].read  = true;
-
-               signal_dspin_false_rsp_in [x][y][k][a].write = false;
-               signal_dspin_false_rsp_in [x][y][k][a].read  = true;
-               signal_dspin_false_rsp_out[x][y][k][a].write = false;
-               signal_dspin_false_rsp_out[x][y][k][a].read  = true;
+         for (size_t a = 0; a < 4; a++){
+            for (size_t k = 0; k < 3; k++){
+               signal_dspin_false_cmd_in [x][y][a][k].write = false;
+               signal_dspin_false_cmd_in [x][y][a][k].read  = true;
+               signal_dspin_false_cmd_out[x][y][a][k].write = false;
+               signal_dspin_false_cmd_out[x][y][a][k].read  = true;
             }
-         }
-      }
-   }
-   // clack network boundaries signals
-   for (size_t x = 0; x < XMAX ; x++){
-      for (size_t y = 0; y < YMAX ; y++){
-         for (size_t k = 0; k < 4; k++){
-            signal_dspin_false_clack_in [x][y][k].write = false;
-            signal_dspin_false_clack_in [x][y][k].read  = true;
-            signal_dspin_false_clack_out[x][y][k].write = false;
-            signal_dspin_false_clack_out[x][y][k].read  = true;
+
+            for (size_t k = 0; k < 2; k++){
+               signal_dspin_false_rsp_in [x][y][a][k].write = false;
+               signal_dspin_false_rsp_in [x][y][a][k].read  = true;
+               signal_dspin_false_rsp_out[x][y][a][k].write = false;
+               signal_dspin_false_rsp_out[x][y][a][k].read  = true;
+            }
          }
       }

branches/v5/platforms/tsar_generic_xbar/tsar_xbar_cluster/caba/source/include/tsar_xbar_cluster.h

@@ -55 +55 @@
     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_clack_out;
-    soclib::caba::DspinInput<dspin_cmd_width>       *p_clack_in;
 
     // interrupt signals
@@ -209 +207 @@
     VirtualDspinRouter<dspin_cmd_width>*          router_cmd;
     VirtualDspinRouter<dspin_rsp_width>*          router_rsp;
-    DspinRouter<dspin_cmd_width>*                 router_clack;
 
     TsarXbarCluster( sc_module_name                     insname,

branches/v5/platforms/tsar_generic_xbar/tsar_xbar_cluster/caba/source/src/tsar_xbar_cluster.cpp

@@ -85 +85 @@
 {
     // Vectors of ports definition
-    p_cmd_in        = alloc_elems<DspinInput<dspin_cmd_width> >("p_cmd_in", 2, 4);
-    p_cmd_out       = alloc_elems<DspinOutput<dspin_cmd_width> >("p_cmd_out", 2, 4);
-    p_rsp_in        = alloc_elems<DspinInput<dspin_rsp_width> >("p_rsp_in", 2, 4);
-    p_rsp_out       = alloc_elems<DspinOutput<dspin_rsp_width> >("p_rsp_out", 2, 4);
-    p_clack_in      = alloc_elems<DspinInput<dspin_cmd_width> >("p_clack_in", 4);
-    p_clack_out     = alloc_elems<DspinOutput<dspin_cmd_width> >("p_clack_out", 4);
+    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);
 
     /////////////////////////////////////////////////////////////////////////////
@@ -289 +287 @@
                      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
 
@@ -296 +295 @@
                      x_id,y_id,                    // coordinates in mesh
                      x_width, y_width,             // x & y fields width
-                     4,4);                         // input & output fifo depths
-
-    /////////////////////////////////////////////////////////////////////////////
-    router_clack = new DspinRouter<dspin_cmd_width>(
-                     "router_clack",
-                     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
 
@@ -403 +396 @@
     router_rsp->p_clk                        (this->p_clk);
     router_rsp->p_resetn                     (this->p_resetn);
-    router_clack->p_clk                      (this->p_clk);
-    router_clack->p_resetn                   (this->p_resetn);
-
-    for (int x = 0; x < 2; x++)
-    {
-        for(int y = 0; y < 4; y++)
+
+    for(int i = 0; i < 4; i++)
+    {
+        for (int k = 0; k < 3; k++)
         {
-            router_cmd->p_out[x][y]          (this->p_cmd_out[x][y]);
-            router_cmd->p_in[x][y]           (this->p_cmd_in[x][y]);
-            router_rsp->p_out[x][y]          (this->p_rsp_out[x][y]);
-            router_rsp->p_in[x][y]           (this->p_rsp_in[x][y]);
+            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 x = 0; x < 4; x++)
-    {
-       router_clack->p_out[x]                (this->p_clack_out[x]);
-       router_clack->p_in[x]                 (this->p_clack_in[x]);
-    }
-
-    router_cmd->p_out[0][4]                  (signal_dspin_cmd_g2l_d);
-    router_cmd->p_out[1][4]                  (signal_dspin_m2p_g2l_c);
-    router_cmd->p_in[0][4]                   (signal_dspin_cmd_l2g_d);
-    router_cmd->p_in[1][4]                   (signal_dspin_m2p_l2g_c);
-
-    router_rsp->p_out[0][4]                  (signal_dspin_rsp_g2l_d);
-    router_rsp->p_out[1][4]                  (signal_dspin_p2m_g2l_c);
-    router_rsp->p_in[0][4]                   (signal_dspin_rsp_l2g_d);
-    router_rsp->p_in[1][4]                   (signal_dspin_p2m_l2g_c);
-
-    router_clack->p_out[4]                   (signal_dspin_clack_g2l_c);
-    router_clack->p_in[4]                    (signal_dspin_clack_l2g_c);
+
+        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);