Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/Makefile
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/Makefile	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/Makefile	(revision 88)
@@ -24,4 +24,6 @@
 library_clean			: Execution_unit_to_Write_unit_library_clean
 
+local_clean			:
+
 include                         $(DIR_COMPONENT)/Makefile.deps
 include                         $(DIR_MORPHEO)/Behavioural/Makefile.flags
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_min.cfg
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_min.cfg	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_min.cfg	(revision 88)
@@ -1,4 +1,6 @@
 Execution_unit_to_Write_unit
 2	2 	*2	# nb_execute_unit        
+1	1 	+1	# nb_execute_unit_port [0] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [1] [nb_execute_unit]
 1	1 	*2	# nb_write_unit           
 1	1	*2	# nb_context             
@@ -11,5 +13,5 @@
 16	16	*2	# nb_special_register    
 0	1	+1	# priority
-1	1	+1	# table_routing        [0][0]
-1	1	+1	# table_routing        [1][0]
+1	1	+1	# table_routing        [0][0][0]
+1	1	+1	# table_routing        [1][0][0]
 1	1	+1	# table_execute_thread [0][0]
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_multi_execute-mono_thread.cfg
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_multi_execute-mono_thread.cfg	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_multi_execute-mono_thread.cfg	(revision 88)
@@ -1,4 +1,8 @@
 Execution_unit_to_Write_unit
 4	4 	*2	# nb_execute_unit        
+1	1 	+1	# nb_execute_unit_port [0] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [1] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [2] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [3] [nb_execute_unit]
 3	3 	*2	# nb_write_unit           
 1	1	*2	# nb_context             
@@ -11,16 +15,16 @@
 16	16	*2	# nb_special_register    
 0	1	+1	# priority
-1	1	+1	# table_routing [0][0]
-0 	0	+1	# table_routing [0][1]
-0	0	+1	# table_routing [0][2]
-0	0	+1	# table_routing [1][0]
-1	1	+1	# table_routing [1][1]
-1	1	+1	# table_routing [1][2]
-0	0	+1	# table_routing [2][0]
-0	0	+1	# table_routing [2][1]
-1	1	+1	# table_routing [2][2]
-1	1	+1	# table_routing [3][0]
-1	1	+1	# table_routing [3][1]
-1	1	+1	# table_routing [3][2]
+1	1	+1	# table_routing [0][0][0]
+0 	0	+1	# table_routing [0][1][0]
+0	0	+1	# table_routing [0][2][0]
+0	0	+1	# table_routing [1][0][0]
+1	1	+1	# table_routing [1][1][0]
+1	1	+1	# table_routing [1][2][0]
+0	0	+1	# table_routing [2][0][0]
+0	0	+1	# table_routing [2][1][0]
+1	1	+1	# table_routing [2][2][0]
+1	1	+1	# table_routing [3][0][0]
+1	1	+1	# table_routing [3][1][0]
+1	1	+1	# table_routing [3][2][0]
 1	1	+1	# table_thread  [0][0]
 1	1	+1	# table_thread  [1][0]
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_multi_execute-multi_thread-multi_port.cfg
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_multi_execute-multi_thread-multi_port.cfg	(revision 88)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_multi_execute-multi_thread-multi_port.cfg	(revision 88)
@@ -0,0 +1,52 @@
+Execution_unit_to_Write_unit
+4	4 	*2	# nb_execute_unit        
+2	2 	+1	# nb_execute_unit_port [0] [nb_execute_unit]
+3	3 	+1	# nb_execute_unit_port [1] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [2] [nb_execute_unit]
+2	2 	+1	# nb_execute_unit_port [3] [nb_execute_unit]
+3	3 	*2	# nb_write_unit           
+2	2	*2	# nb_context             
+2	2	*2	# nb_front_end           
+1	1	*2	# nb_ooo_engine          
+64	64	*2	# nb_packet              
+32	32	*2	# size_general_data      
+2	2	*2	# size_special_data      
+64	64	*2	# nb_general_register    
+16	16	*2	# nb_special_register    
+0	1	+1	# priority
+1	1	+1	# table_routing [0][0][0]
+1	1	+1	# table_routing [0][0][1]
+0 	0	+1	# table_routing [0][0][2]
+0 	0	+1	# table_routing [0][1][0]
+1	1	+1	# table_routing [0][1][1]
+0	0	+1	# table_routing [0][1][2]
+0	0	+1	# table_routing [1][0][0]
+1	1	+1	# table_routing [1][0][1]
+0	0	+1	# table_routing [1][0][2]
+1	1	+1	# table_routing [1][1][0]
+1	1	+1	# table_routing [1][1][1]
+1	1	+1	# table_routing [1][1][2]
+1	1	+1	# table_routing [1][2][0]
+1	1	+1	# table_routing [1][2][1]
+1	1	+1	# table_routing [1][2][2]
+0	0	+1	# table_routing [2][0][0]
+0	0	+1	# table_routing [2][0][1]
+1	1	+1	# table_routing [2][0][2]
+1	1	+1	# table_routing [3][0][0]
+1	1	+1	# table_routing [3][0][1]
+1	1	+1	# table_routing [3][0][2]
+1	1	+1	# table_routing [3][1][0]
+1	1	+1	# table_routing [3][1][1]
+1	1	+1	# table_routing [3][1][2]
+1	1	+1	# table_thread  [0][0]
+0	0	+1	# table_thread  [0][1]
+0	0	+1	# table_thread  [0][2]
+0	0	+1	# table_thread  [0][3]
+0	0	+1	# table_thread  [1][0]
+1	1	+1	# table_thread  [1][1]
+1	1	+1	# table_thread  [1][2]
+0	0	+1	# table_thread  [1][3]
+0	0	+1	# table_thread  [2][0]
+0	0	+1	# table_thread  [2][1]
+0	0	+1	# table_thread  [2][2]
+1	1	+1	# table_thread  [2][3]
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_multi_execute-multi_thread.cfg
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_multi_execute-multi_thread.cfg	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_multi_execute-multi_thread.cfg	(revision 88)
@@ -1,4 +1,8 @@
 Execution_unit_to_Write_unit
 4	4 	*2	# nb_execute_unit        
+1	1 	+1	# nb_execute_unit_port [0] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [1] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [2] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [3] [nb_execute_unit]
 3	3 	*2	# nb_write_unit           
 2	2	*2	# nb_context             
@@ -11,16 +15,16 @@
 16	16	*2	# nb_special_register    
 0	1	+1	# priority
-1	1	+1	# table_routing [0][0]
-0 	0	+1	# table_routing [0][1]
-0	0	+1	# table_routing [0][2]
-0	0	+1	# table_routing [1][0]
-1	1	+1	# table_routing [1][1]
-1	1	+1	# table_routing [1][2]
-0	0	+1	# table_routing [2][0]
-0	0	+1	# table_routing [2][1]
-1	1	+1	# table_routing [2][2]
-1	1	+1	# table_routing [3][0]
-1	1	+1	# table_routing [3][1]
-1	1	+1	# table_routing [3][2]
+1	1	+1	# table_routing [0][0][0]
+0 	0	+1	# table_routing [0][1][0]
+0	0	+1	# table_routing [0][2][0]
+0	0	+1	# table_routing [1][0][0]
+1	1	+1	# table_routing [1][1][0]
+1	1	+1	# table_routing [1][2][0]
+0	0	+1	# table_routing [2][0][0]
+0	0	+1	# table_routing [2][1][0]
+1	1	+1	# table_routing [2][2][0]
+1	1	+1	# table_routing [3][0][0]
+1	1	+1	# table_routing [3][1][0]
+1	1	+1	# table_routing [3][2][0]
 1	1	+1	# table_thread  [0][0]
 0	0	+1	# table_thread  [0][1]
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/include/test.h
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/include/test.h	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/include/test.h	(revision 88)
@@ -15,6 +15,10 @@
 #include <sys/time.h>
 
+#define NB_ITERATION  1
+#define CYCLE_MAX     (128*NB_ITERATION)
+
 #include "Common/include/Time.h"
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Execution_unit_to_Write_unit.h"
+#include "Common/include/Test.h"
 
 using namespace std;
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/src/main.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/src/main.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/src/main.cpp	(revision 88)
@@ -14,17 +14,18 @@
   err (_("<Usage> %s name_instance list_params.\n"),argv[0]);
   err (_("list_params is :\n"));
-  err (_("  * nb_execute_unit                                (uint32_t)\n"));
-  err (_("  * nb_write_unit                                  (uint32_t)\n"));
-  err (_("  * nb_context                                     (uint32_t)\n"));
-  err (_("  * nb_front_end                                   (uint32_t)\n"));
-  err (_("  * nb_ooo_engine                                  (uint32_t)\n"));
-  err (_("  * nb_packet                                      (uint32_t)\n"));
-  err (_("  * size_general_data                              (uint32_t)\n"));
-  err (_("  * size_special_data                              (uint32_t)\n"));
-  err (_("  * nb_general_register                            (uint32_t)\n"));
-  err (_("  * nb_special_register                            (uint32_t)\n"));
-  err (_("  * priority                                       (uint32_t)\n"));
-  err (_("  * table_routing [nb_execute_unit][nb_write_unit] (bool    )\n"));
-  err (_("  * table_thread  [nb_write_unit][nb_thread]       (bool    )\n"));
+  err (_("  * nb_execute_unit                                                      (uint32_t)\n"));
+  err (_("  * nb_execute_unit_port [nb_execute_unit]                               (uint32_t)\n"));
+  err (_("  * nb_write_unit                                                        (uint32_t)\n"));
+  err (_("  * nb_context                                                           (uint32_t)\n"));
+  err (_("  * nb_front_end                                                         (uint32_t)\n"));
+  err (_("  * nb_ooo_engine                                                        (uint32_t)\n"));
+  err (_("  * nb_packet                                                            (uint32_t)\n"));
+  err (_("  * size_general_data                                                    (uint32_t)\n"));
+  err (_("  * size_special_data                                                    (uint32_t)\n"));
+  err (_("  * nb_general_register                                                  (uint32_t)\n"));
+  err (_("  * nb_special_register                                                  (uint32_t)\n"));
+  err (_("  * priority                                                             (uint32_t)\n"));
+  err (_("  * table_routing [nb_execute_unit][nb_execute_unit_port][nb_write_unit] (bool    )\n"));
+  err (_("  * table_thread  [nb_write_unit][nb_thread]                             (bool    )\n"));
 
   exit (1);
@@ -43,30 +44,46 @@
 
   const string   name      =      argv[x++];
-  uint32_t    _nb_execute_unit      = atoi(argv[x++]);
-  uint32_t    _nb_write_unit        = atoi(argv[x++]);
-  uint32_t    _nb_context           = atoi(argv[x++]);
-  uint32_t    _nb_front_end         = atoi(argv[x++]);
-  uint32_t    _nb_ooo_engine        = atoi(argv[x++]);
-  uint32_t    _nb_packet            = atoi(argv[x++]);
-  uint32_t    _size_general_data    = atoi(argv[x++]);
-  uint32_t    _size_special_data    = atoi(argv[x++]);
-  uint32_t    _nb_general_register  = atoi(argv[x++]);
-  uint32_t    _nb_special_register  = atoi(argv[x++]);
+  uint32_t    _nb_execute_unit      = fromString<uint32_t>(argv[x++]);
+
+  if (static_cast<uint32_t>(argc) <= 2+NB_PARAMS+_nb_execute_unit)
+    usage (argc, argv);
+
+  uint32_t    _sum_execute_unit_port = 0;
+  uint32_t *  _nb_execute_unit_port = new uint32_t [_nb_execute_unit];
+  for (uint32_t i=0; i<_nb_execute_unit; i++)
+    {
+      _nb_execute_unit_port [i] = fromString<uint32_t>(argv[x++]);
+      _sum_execute_unit_port += _nb_execute_unit_port [i];
+    }
+
+  uint32_t    _nb_write_unit        = fromString<uint32_t>(argv[x++]);
+  uint32_t    _nb_context           = fromString<uint32_t>(argv[x++]);
+  uint32_t    _nb_front_end         = fromString<uint32_t>(argv[x++]);
+  uint32_t    _nb_ooo_engine        = fromString<uint32_t>(argv[x++]);
+  uint32_t    _nb_packet            = fromString<uint32_t>(argv[x++]);
+  uint32_t    _size_general_data    = fromString<uint32_t>(argv[x++]);
+  uint32_t    _size_special_data    = fromString<uint32_t>(argv[x++]);
+  uint32_t    _nb_general_register  = fromString<uint32_t>(argv[x++]);
+  uint32_t    _nb_special_register  = fromString<uint32_t>(argv[x++]);
   Tpriority_t _priority             = fromString<Tpriority_t>(argv[x++]);
 
   uint32_t    _nb_thread            = get_nb_thread(_nb_context, _nb_front_end, _nb_ooo_engine);
 
-  if (static_cast<uint32_t>(argc) != 2+NB_PARAMS+(_nb_write_unit*_nb_execute_unit)+(_nb_write_unit*_nb_thread))
+  if (static_cast<uint32_t>(argc) != 2+NB_PARAMS+_nb_execute_unit+(_nb_write_unit*_sum_execute_unit_port)+(_nb_write_unit*_nb_thread))
     usage (argc, argv);
   
-  bool ** _table_routing;
-  bool ** _table_thread ;
+  bool *** _table_routing;
+  bool  ** _table_thread ;
   
-  _table_routing = new bool * [_nb_execute_unit];
+  _table_routing = new bool ** [_nb_execute_unit];
   for (uint32_t i=0; i<_nb_execute_unit; i++)
     {
-      _table_routing [i] = new bool [_nb_write_unit];
-      for (uint32_t j=0; j<_nb_write_unit; j++)
-	_table_routing [i][j] = atoi(argv[x++]);
+      _table_routing [i] = new bool * [_nb_execute_unit_port [i]];
+      for (uint32_t j=0; j<_nb_execute_unit_port [i]; j++)
+	{
+	  _table_routing [i][j] = new bool [_nb_write_unit];
+	  for (uint32_t k=0; k<_nb_write_unit; k++)
+	    _table_routing [i][j][k] = fromString<bool>(argv[x++]);
+	}
     }
 
@@ -77,11 +94,13 @@
 
       for (uint32_t j=0; j<_nb_thread; j++)
-	_table_thread [i][j] = atoi(argv[x++]);
+	_table_thread [i][j] = fromString<bool>(argv[x++]);
     }
 
+  int _return = EXIT_SUCCESS;
   try 
     {
       morpheo::behavioural::core::multi_execute_loop::execute_loop::network::execution_unit_to_write_unit::Parameters * param = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::execution_unit_to_write_unit::Parameters
 	(_nb_execute_unit      ,
+	 _nb_execute_unit_port ,
 	 _nb_write_unit        ,
 	 _nb_context           ,
@@ -95,8 +114,9 @@
 	 _priority             ,
 	 _table_routing        ,
-	 _table_thread 
+	 _table_thread         ,
+         true //is_toplevel
 	 );
       
-      msg(_("%s"),param->print(1).c_str());
+      msg(_("%s"),param->print(0).c_str());
       
       test (name,param);
@@ -104,11 +124,19 @@
   catch (morpheo::ErrorMorpheo & error)
     {
-      msg (_("<%s> : %s.\n"),name.c_str(), error.what ());
-      exit (EXIT_FAILURE);
+      msg (_("<%s> :\n%s"),name.c_str(), error.what ());
+      _return = EXIT_FAILURE;
     }
-  catch (...)
+  
+  try 
     {
-      err (_("<%s> : This test must generate a error.\n"),name.c_str());
-      exit (EXIT_FAILURE);
+      if (_return == EXIT_SUCCESS)
+	TEST_OK("Execution_unit_to_Write_unit : no error");
+      else
+	TEST_KO("Execution_unit_to_Write_unit : a lot of error");
+    }
+  catch (morpheo::ErrorMorpheo & error)
+    {
+//       msg (_("<%s> :\n%s"),name.c_str(), error.what ());
+      _return = EXIT_FAILURE;
     }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/src/test.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/src/test.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/src/test.cpp	(revision 88)
@@ -7,9 +7,5 @@
  */
 
-#define NB_ITERATION  1
-#define CYCLE_MAX     (128*NB_ITERATION)
-
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/include/test.h"
-#include "Common/include/Test.h"
 #include "Common/include/BitManipulation.h"
 #include "Behavioural/include/Allocation.h"
@@ -78,4 +74,14 @@
 #endif
 
+  Tusage_t _usage = USE_ALL;
+
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
+
   Execution_unit_to_Write_unit * _Execution_unit_to_Write_unit = new Execution_unit_to_Write_unit 
     (name.c_str(),
@@ -84,5 +90,5 @@
 #endif
      _param,
-     USE_ALL);
+     _usage);
   
 #ifdef SYSTEMC
@@ -95,21 +101,22 @@
   sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
 
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_VAL          ," in_EXECUTE_UNIT_OUT_VAL          ",Tcontrol_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_OUT_ACK          ,"out_EXECUTE_UNIT_OUT_ACK          ",Tcontrol_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ," in_EXECUTE_UNIT_OUT_CONTEXT_ID   ",Tcontext_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_FRONT_END_ID ," in_EXECUTE_UNIT_OUT_FRONT_END_ID ",Tcontext_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID," in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID",Tcontext_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_PACKET_ID    ," in_EXECUTE_UNIT_OUT_PACKET_ID    ",Tpacket_t         ,_param->_nb_execute_unit);
-//ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OPERATION    ," in_EXECUTE_UNIT_OUT_OPERATION    ",Toperation_t      ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         ," in_EXECUTE_UNIT_OUT_TYPE         ",Ttype_t           ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RD     ," in_EXECUTE_UNIT_OUT_WRITE_RD     ",Tcontrol_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ," in_EXECUTE_UNIT_OUT_NUM_REG_RD   ",Tgeneral_address_t,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RD      ," in_EXECUTE_UNIT_OUT_DATA_RD      ",Tgeneral_data_t   ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RE     ," in_EXECUTE_UNIT_OUT_WRITE_RE     ",Tcontrol_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ," in_EXECUTE_UNIT_OUT_NUM_REG_RE   ",Tspecial_address_t,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RE      ," in_EXECUTE_UNIT_OUT_DATA_RE      ",Tspecial_data_t   ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_EXCEPTION    ," in_EXECUTE_UNIT_OUT_EXCEPTION    ",Texception_t      ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ," in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ",Tcontrol_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_ADDRESS      ," in_EXECUTE_UNIT_OUT_ADDRESS      ",Tgeneral_data_t   ,_param->_nb_execute_unit);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_VAL          ," in_EXECUTE_UNIT_OUT_VAL          ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_OUT_ACK          ,"out_EXECUTE_UNIT_OUT_ACK          ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ," in_EXECUTE_UNIT_OUT_CONTEXT_ID   ",Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_FRONT_END_ID ," in_EXECUTE_UNIT_OUT_FRONT_END_ID ",Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID," in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID",Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_PACKET_ID    ," in_EXECUTE_UNIT_OUT_PACKET_ID    ",Tpacket_t         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+//ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OPERATION    ," in_EXECUTE_UNIT_OUT_OPERATION    ",Toperation_t      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         ," in_EXECUTE_UNIT_OUT_TYPE         ",Ttype_t           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RD     ," in_EXECUTE_UNIT_OUT_WRITE_RD     ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ," in_EXECUTE_UNIT_OUT_NUM_REG_RD   ",Tgeneral_address_t,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RD      ," in_EXECUTE_UNIT_OUT_DATA_RD      ",Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RE     ," in_EXECUTE_UNIT_OUT_WRITE_RE     ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ," in_EXECUTE_UNIT_OUT_NUM_REG_RE   ",Tspecial_address_t,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RE      ," in_EXECUTE_UNIT_OUT_DATA_RE      ",Tspecial_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_EXCEPTION    ," in_EXECUTE_UNIT_OUT_EXCEPTION    ",Texception_t      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ," in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_ADDRESS      ," in_EXECUTE_UNIT_OUT_ADDRESS      ",Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+
   ALLOC1_SC_SIGNAL(out_WRITE_UNIT_IN_VAL             ,"out_WRITE_UNIT_IN_VAL             ",Tcontrol_t        ,_param->_nb_write_unit  );
   ALLOC1_SC_SIGNAL( in_WRITE_UNIT_IN_ACK             ," in_WRITE_UNIT_IN_ACK             ",Tcontrol_t        ,_param->_nb_write_unit  );
@@ -139,25 +146,25 @@
   (*(_Execution_unit_to_Write_unit->in_NRESET))       (*(in_NRESET));
 
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_VAL          ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_EXECUTE_UNIT_OUT_ACK          ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_VAL          ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit,out_EXECUTE_UNIT_OUT_ACK          ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_context_id)
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_front_end_id)
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_FRONT_END_ID ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_FRONT_END_ID ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_ooo_engine_id)
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,_param->_nb_execute_unit);
-  if (_param->_have_port_packet_id)
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_PACKET_ID    ,_param->_nb_execute_unit);
-//INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_OPERATION    ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_TYPE         ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_WRITE_RD     ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_DATA_RD      ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_WRITE_RE     ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_DATA_RE      ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_EXCEPTION    ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_ADDRESS      ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  if (_param->_have_port_rob_ptr  )
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_PACKET_ID    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+//INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_OPERATION    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_TYPE         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_WRITE_RD     ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_DATA_RD      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_WRITE_RE     ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_DATA_RE      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_EXCEPTION    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_ADDRESS      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
 
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_VAL             ,_param->_nb_write_unit  );
@@ -169,5 +176,5 @@
   if (_param->_have_port_ooo_engine_id)
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_OOO_ENGINE_ID   ,_param->_nb_write_unit  );
-  if (_param->_have_port_packet_id)
+  if (_param->_have_port_rob_ptr  )
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_PACKET_ID       ,_param->_nb_write_unit  );
 //INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_OPERATION       ,_param->_nb_write_unit  );
@@ -201,14 +208,16 @@
   const  int32_t percent_transaction_out = 75;
 
-  set<Tcontext_t> execute_unit_thread [_param->_nb_execute_unit];
+  set<Tcontext_t> execute_unit_thread [_param->_nb_execute_unit][_param->_max_nb_execute_unit_port];
  
   for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-    for (uint32_t j=0; j<_param->_nb_write_unit; j++)
-      if (_param->_table_routing[i][j])
-	for (uint32_t k=0; k<_param->_nb_thread; k++)
-	  if (_param->_table_thread[j][k])
-	    {
-	      execute_unit_thread [i].insert(k);
-	    }
+    for (uint32_t ii=0; ii<_param->_nb_execute_unit_port[i]; ii++)
+      for (uint32_t j=0; j<_param->_nb_write_unit; j++)
+	if (_param->_table_routing[i][ii][j])
+	  for (uint32_t k=0; k<_param->_nb_thread; k++)
+	    if (_param->_table_thread[j][k])
+	      {
+		execute_unit_thread [i][ii].insert(k);
+	      }
+
   SC_START(0);
   LABEL("Initialisation");
@@ -225,49 +234,50 @@
       LABEL("Iteration %d",iteration);
 
-      list<entry_t> request [_param->_nb_execute_unit];
+      list<entry_t> request [_param->_nb_execute_unit][_param->_max_nb_execute_unit_port];
 
       uint32_t nb_request_in;
       for (nb_request_in=0; nb_request_in < _param->_nb_packet; )
 	for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-	  {
-	    if (nb_request_in >= _param->_nb_packet)
-	      break;
-
-	    Tcontext_t context_id   ;
-	    Tcontext_t front_end_id ;
-	    Tcontext_t ooo_engine_id;
-	    Tcontext_t num_thread   ;
-
-	    // Find compatible thread
-	    do
-	      {
-		context_id    = range<Tcontext_t> (rand(), _param->_size_context_id   );
-		front_end_id  = range<Tcontext_t> (rand(), _param->_size_front_end_id );
-		ooo_engine_id = range<Tcontext_t> (rand(), _param->_size_ooo_engine_id);
-		num_thread    = get_num_thread (context_id   , _param->_size_context_id   ,
-						front_end_id , _param->_size_front_end_id ,
-						ooo_engine_id, _param->_size_ooo_engine_id);
-	      }
-	    while (execute_unit_thread[i].find(num_thread) == execute_unit_thread[i].end());
-
-	    request[i].push_back(entry_t (context_id   ,
-					  front_end_id ,
-					  ooo_engine_id,
-					  nb_request_in,
-					  //range<Toperation_t      > (rand(), _param->_size_operation       ),
-					  range<Ttype_t           > (rand(), _param->_size_type            ),
-					  range<Tcontrol_t        > (rand(), 2                             ),
-					  range<Tgeneral_address_t> (rand(), _param->_size_general_register),
-					  range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
-					  range<Tcontrol_t        > (rand(), 2                             ),
-					  range<Tspecial_address_t> (rand(), _param->_size_special_register),
-					  range<Tspecial_data_t   > (rand(), _param->_size_special_data    ),
-					  range<Texception_t      > (rand(), _param->_size_exception       ),
-					  range<Tcontrol_t        > (rand(), 2                             ),
-					  range<Tgeneral_data_t   > (rand(), _param->_size_general_data    )
-					  ));
-
-	    nb_request_in++;
-	  }
+	  for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+	    {
+	      if (nb_request_in >= _param->_nb_packet)
+		break;
+	      
+	      Tcontext_t context_id   ;
+	      Tcontext_t front_end_id ;
+	      Tcontext_t ooo_engine_id;
+	      Tcontext_t num_thread   ;
+	      
+	      // Find compatible thread
+	      do
+		{
+		  context_id    = range<Tcontext_t> (rand(), _param->_size_context_id   );
+		  front_end_id  = range<Tcontext_t> (rand(), _param->_size_front_end_id );
+		  ooo_engine_id = range<Tcontext_t> (rand(), _param->_size_ooo_engine_id);
+		  num_thread    = get_num_thread (context_id   , _param->_size_context_id   ,
+						  front_end_id , _param->_size_front_end_id ,
+						  ooo_engine_id, _param->_size_ooo_engine_id);
+		}
+	      while (execute_unit_thread[i][j].find(num_thread) == execute_unit_thread[i][j].end());
+	      
+	      request[i][j].push_back(entry_t (context_id   ,
+					       front_end_id ,
+					       ooo_engine_id,
+					       nb_request_in,
+					       //range<Toperation_t      > (rand(), _param->_size_operation       ),
+					       range<Ttype_t           > (rand(), _param->_size_type            ),
+					       range<Tcontrol_t        > (rand(), 2                             ),
+					       range<Tgeneral_address_t> (rand(), _param->_size_general_register),
+					       range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
+					       range<Tcontrol_t        > (rand(), 2                             ),
+					       range<Tspecial_address_t> (rand(), _param->_size_special_register),
+					       range<Tspecial_data_t   > (rand(), _param->_size_special_data    ),
+					       range<Texception_t      > (rand(), _param->_size_exception       ),
+					       range<Tcontrol_t        > (rand(), 2                             ),
+					       range<Tgeneral_data_t   > (rand(), _param->_size_general_data    )
+					       ));
+	      
+	      nb_request_in++;
+	    }
 
       uint32_t   nb_request_out = 0;
@@ -276,28 +286,29 @@
 	{
 	  for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-	    {
-	      bool val = not request[i].empty() and ((rand()%100) < percent_transaction_in);
+	    for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+	      {
+		bool val = not request[i][j].empty() and ((rand()%100) < percent_transaction_in);
 		
-	      in_EXECUTE_UNIT_OUT_VAL [i]->write(val);
-
-	      if (val)
-		{
-		  in_EXECUTE_UNIT_OUT_CONTEXT_ID           [i] ->write(request[i].front()._context_id           );
-		  in_EXECUTE_UNIT_OUT_FRONT_END_ID         [i] ->write(request[i].front()._front_end_id         );
-		  in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID        [i] ->write(request[i].front()._ooo_engine_id        );
-		  in_EXECUTE_UNIT_OUT_PACKET_ID            [i] ->write(request[i].front()._packet_id            );
-// 		  in_EXECUTE_UNIT_OUT_OPERATION            [i] ->write(request[i].front()._operation            );
-		  in_EXECUTE_UNIT_OUT_TYPE                 [i] ->write(request[i].front()._type                 );
-		  in_EXECUTE_UNIT_OUT_WRITE_RD             [i] ->write(request[i].front()._write_rd             );
-		  in_EXECUTE_UNIT_OUT_NUM_REG_RD           [i] ->write(request[i].front()._num_reg_rd           );
-		  in_EXECUTE_UNIT_OUT_DATA_RD              [i] ->write(request[i].front()._data_rd              );
-		  in_EXECUTE_UNIT_OUT_WRITE_RE             [i] ->write(request[i].front()._write_re             );
-		  in_EXECUTE_UNIT_OUT_NUM_REG_RE           [i] ->write(request[i].front()._num_reg_re           );
-		  in_EXECUTE_UNIT_OUT_DATA_RE              [i] ->write(request[i].front()._data_re              );
-		  in_EXECUTE_UNIT_OUT_EXCEPTION            [i] ->write(request[i].front()._exception            );
-		  in_EXECUTE_UNIT_OUT_NO_SEQUENCE          [i] ->write(request[i].front()._no_sequence          );
-		  in_EXECUTE_UNIT_OUT_ADDRESS              [i] ->write(request[i].front()._address              );
-		}
-	    }
+		in_EXECUTE_UNIT_OUT_VAL [i][j]->write(val);
+		
+		if (val)
+		  {
+		    in_EXECUTE_UNIT_OUT_CONTEXT_ID           [i][j] ->write(request[i][j].front()._context_id           );
+		    in_EXECUTE_UNIT_OUT_FRONT_END_ID         [i][j] ->write(request[i][j].front()._front_end_id         );
+		    in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID        [i][j] ->write(request[i][j].front()._ooo_engine_id        );
+		    in_EXECUTE_UNIT_OUT_PACKET_ID            [i][j] ->write(request[i][j].front()._packet_id            );
+// 		    in_EXECUTE_UNIT_OUT_OPERATION            [i][j] ->write(request[i][j].front()._operation            );
+		    in_EXECUTE_UNIT_OUT_TYPE                 [i][j] ->write(request[i][j].front()._type                 );
+		    in_EXECUTE_UNIT_OUT_WRITE_RD             [i][j] ->write(request[i][j].front()._write_rd             );
+		    in_EXECUTE_UNIT_OUT_NUM_REG_RD           [i][j] ->write(request[i][j].front()._num_reg_rd           );
+		    in_EXECUTE_UNIT_OUT_DATA_RD              [i][j] ->write(request[i][j].front()._data_rd              );
+		    in_EXECUTE_UNIT_OUT_WRITE_RE             [i][j] ->write(request[i][j].front()._write_re             );
+		    in_EXECUTE_UNIT_OUT_NUM_REG_RE           [i][j] ->write(request[i][j].front()._num_reg_re           );
+		    in_EXECUTE_UNIT_OUT_DATA_RE              [i][j] ->write(request[i][j].front()._data_re              );
+		    in_EXECUTE_UNIT_OUT_EXCEPTION            [i][j] ->write(request[i][j].front()._exception            );
+		    in_EXECUTE_UNIT_OUT_NO_SEQUENCE          [i][j] ->write(request[i][j].front()._no_sequence          );
+		    in_EXECUTE_UNIT_OUT_ADDRESS              [i][j] ->write(request[i][j].front()._address              );
+		  }
+	      }
 
 	  for (uint32_t i=0; i<_param->_nb_write_unit; i++)
@@ -307,9 +318,10 @@
 
 	  for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-	    if (in_EXECUTE_UNIT_OUT_VAL [i]->read() and out_EXECUTE_UNIT_OUT_ACK [i]->read())
-	      {
-		LABEL("EXECUTE_UNIT_OUT   [%d] - Transaction accepted",i);
-	      }
-
+	    for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+	      if (in_EXECUTE_UNIT_OUT_VAL [i][j]->read() and out_EXECUTE_UNIT_OUT_ACK [i][j]->read())
+		{
+		  LABEL("EXECUTE_UNIT_OUT   [%d][%d] - Transaction accepted",i,j);
+		}
+	  
 	  for (uint32_t i=0; i<_param->_nb_write_unit; i++)
 	    if (out_WRITE_UNIT_IN_VAL [i]->read() and in_WRITE_UNIT_IN_ACK [i]->read())
@@ -318,40 +330,53 @@
 		nb_request_out ++;
 		
-		Tpacket_t packet = (_param->_have_port_packet_id)?out_WRITE_UNIT_IN_PACKET_ID[i]->read():0;
-		LABEL("  * packet           : %d",packet);		
-		uint32_t execute_unit;
+		Tpacket_t packet = (_param->_have_port_rob_ptr  )?out_WRITE_UNIT_IN_PACKET_ID[i]->read():0;
+		LABEL("  * packet              : %d",packet);		
 
 		// find execute_unit
-		for (execute_unit=0; execute_unit<_param->_nb_execute_unit; execute_unit++)
-		  if (packet == ((_param->_have_port_packet_id)?request[execute_unit].front()._packet_id:0))
-		    break;
-
-		LABEL("  * execute_unit source : %d",execute_unit);
-
-		if (_param->_have_port_packet_id)
-		TEST(Tcontext_t        ,out_WRITE_UNIT_IN_PACKET_ID            [i]->read(), request[execute_unit].front()._packet_id            );
+		uint32_t x = 0;
+		uint32_t y = 0;
+		bool     find = false;
+		for (x=0; x<_param->_nb_execute_unit; x++)
+		  {
+		    for (y=0; y<_param->_nb_execute_unit_port[x]; y++)
+		      if (packet == ((_param->_have_port_rob_ptr  )?request[x][y].front()._packet_id:0))
+			{
+			  find = true;
+			  break;
+			}
+		    if (find)
+		      break;
+		  }
+
+		LABEL("  * execute_unit source : %d",x);
+		LABEL("  * execute_unit port   : %d",y);
+		TEST(bool,x<_param->_nb_execute_unit, true);
+		TEST(bool,y<_param->_nb_execute_unit_port[x],true);
+		
+		if (_param->_have_port_rob_ptr  )
+		TEST(Tpacket_t         ,packet                                            , request[x][y].front()._packet_id            );
 
 		// Authorised link ? execute_unit -> write_unit
-		TEST(bool, _param->_table_routing[execute_unit][i], true);
+		TEST(bool, _param->_table_routing[x][y][i], true);
 
 		if (_param->_have_port_context_id)
-		TEST(Tcontext_t        ,out_WRITE_UNIT_IN_CONTEXT_ID           [i]->read(), request[execute_unit].front()._context_id           );
+		TEST(Tcontext_t        ,out_WRITE_UNIT_IN_CONTEXT_ID           [i]->read(), request[x][y].front()._context_id           );
 		if (_param->_have_port_front_end_id)
-		TEST(Tcontext_t        ,out_WRITE_UNIT_IN_FRONT_END_ID         [i]->read(), request[execute_unit].front()._front_end_id         );
+		TEST(Tcontext_t        ,out_WRITE_UNIT_IN_FRONT_END_ID         [i]->read(), request[x][y].front()._front_end_id         );
 		if (_param->_have_port_ooo_engine_id)
-		TEST(Tcontext_t        ,out_WRITE_UNIT_IN_OOO_ENGINE_ID        [i]->read(), request[execute_unit].front()._ooo_engine_id        );
-// 		TEST(Toperation_t      ,out_WRITE_UNIT_IN_OPERATION            [i]->read(), request[execute_unit].front()._operation            );
-		TEST(Ttype_t           ,out_WRITE_UNIT_IN_TYPE                 [i]->read(), request[execute_unit].front()._type                 );
-		TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_WRITE_RD             [i]->read(), request[execute_unit].front()._write_rd             );
-		TEST(Tgeneral_address_t,out_WRITE_UNIT_IN_NUM_REG_RD           [i]->read(), request[execute_unit].front()._num_reg_rd           );
-		TEST(Tgeneral_data_t   ,out_WRITE_UNIT_IN_DATA_RD              [i]->read(), request[execute_unit].front()._data_rd              );
-		TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_WRITE_RE             [i]->read(), request[execute_unit].front()._write_re             );
-		TEST(Tspecial_address_t,out_WRITE_UNIT_IN_NUM_REG_RE           [i]->read(), request[execute_unit].front()._num_reg_re           );
-		TEST(Tspecial_data_t   ,out_WRITE_UNIT_IN_DATA_RE              [i]->read(), request[execute_unit].front()._data_re              );
-		TEST(Texception_t      ,out_WRITE_UNIT_IN_EXCEPTION            [i]->read(), request[execute_unit].front()._exception            );
-		TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_NO_SEQUENCE          [i]->read(), request[execute_unit].front()._no_sequence          );
-		TEST(Tgeneral_data_t   ,out_WRITE_UNIT_IN_ADDRESS              [i]->read(), request[execute_unit].front()._address              );
+		TEST(Tcontext_t        ,out_WRITE_UNIT_IN_OOO_ENGINE_ID        [i]->read(), request[x][y].front()._ooo_engine_id        );
+// 		TEST(Toperation_t      ,out_WRITE_UNIT_IN_OPERATION            [i]->read(), request[x][y].front()._operation            );
+		TEST(Ttype_t           ,out_WRITE_UNIT_IN_TYPE                 [i]->read(), request[x][y].front()._type                 );
+		TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_WRITE_RD             [i]->read(), request[x][y].front()._write_rd             );
+		TEST(Tgeneral_address_t,out_WRITE_UNIT_IN_NUM_REG_RD           [i]->read(), request[x][y].front()._num_reg_rd           );
+		TEST(Tgeneral_data_t   ,out_WRITE_UNIT_IN_DATA_RD              [i]->read(), request[x][y].front()._data_rd              );
+		TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_WRITE_RE             [i]->read(), request[x][y].front()._write_re             );
+		TEST(Tspecial_address_t,out_WRITE_UNIT_IN_NUM_REG_RE           [i]->read(), request[x][y].front()._num_reg_re           );
+		TEST(Tspecial_data_t   ,out_WRITE_UNIT_IN_DATA_RE              [i]->read(), request[x][y].front()._data_re              );
+		TEST(Texception_t      ,out_WRITE_UNIT_IN_EXCEPTION            [i]->read(), request[x][y].front()._exception            );
+		TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_NO_SEQUENCE          [i]->read(), request[x][y].front()._no_sequence          );
+		TEST(Tgeneral_data_t   ,out_WRITE_UNIT_IN_ADDRESS              [i]->read(), request[x][y].front()._address              );
 		
-		request[execute_unit].pop_front();
+		request[x][y].pop_front();
 	      }
 	  SC_START(1);
@@ -372,39 +397,39 @@
   delete in_NRESET;
 
-  delete []  in_EXECUTE_UNIT_OUT_VAL          ;
-  delete [] out_EXECUTE_UNIT_OUT_ACK          ;
-  delete []  in_EXECUTE_UNIT_OUT_CONTEXT_ID   ;
-  delete []  in_EXECUTE_UNIT_OUT_FRONT_END_ID ;
-  delete []  in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID;
-  delete []  in_EXECUTE_UNIT_OUT_PACKET_ID    ;
-//delete []  in_EXECUTE_UNIT_OUT_OPERATION    ;
-  delete []  in_EXECUTE_UNIT_OUT_TYPE         ;
-  delete []  in_EXECUTE_UNIT_OUT_WRITE_RD     ;
-  delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RD   ;
-  delete []  in_EXECUTE_UNIT_OUT_DATA_RD      ;
-  delete []  in_EXECUTE_UNIT_OUT_WRITE_RE     ;
-  delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RE   ;
-  delete []  in_EXECUTE_UNIT_OUT_DATA_RE      ;
-  delete []  in_EXECUTE_UNIT_OUT_EXCEPTION    ;
-  delete []  in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ;
-  delete []  in_EXECUTE_UNIT_OUT_ADDRESS      ;
-
-  delete [] out_WRITE_UNIT_IN_VAL             ;
-  delete []  in_WRITE_UNIT_IN_ACK             ;
-  delete [] out_WRITE_UNIT_IN_CONTEXT_ID      ;
-  delete [] out_WRITE_UNIT_IN_FRONT_END_ID    ;
-  delete [] out_WRITE_UNIT_IN_OOO_ENGINE_ID   ;
-  delete [] out_WRITE_UNIT_IN_PACKET_ID       ;
-//delete [] out_WRITE_UNIT_IN_OPERATION       ;
-  delete [] out_WRITE_UNIT_IN_TYPE            ;
-  delete [] out_WRITE_UNIT_IN_WRITE_RD        ;
-  delete [] out_WRITE_UNIT_IN_NUM_REG_RD      ;
-  delete [] out_WRITE_UNIT_IN_DATA_RD         ;
-  delete [] out_WRITE_UNIT_IN_WRITE_RE        ;
-  delete [] out_WRITE_UNIT_IN_NUM_REG_RE      ;
-  delete [] out_WRITE_UNIT_IN_DATA_RE         ;
-  delete [] out_WRITE_UNIT_IN_EXCEPTION       ;
-  delete [] out_WRITE_UNIT_IN_NO_SEQUENCE     ;
-  delete [] out_WRITE_UNIT_IN_ADDRESS         ;
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_VAL          ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_OUT_ACK          ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_FRONT_END_ID ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_PACKET_ID    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+//DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OPERATION    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RD     ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RD      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RE     ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RE      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_EXCEPTION    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_ADDRESS      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_VAL             ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL( in_WRITE_UNIT_IN_ACK             ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_CONTEXT_ID      ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_FRONT_END_ID    ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_OOO_ENGINE_ID   ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_PACKET_ID       ,_param->_nb_write_unit  );
+//DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_OPERATION       ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_TYPE            ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_WRITE_RD        ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_NUM_REG_RD      ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_DATA_RD         ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_WRITE_RE        ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_NUM_REG_RE      ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_DATA_RE         ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_EXCEPTION       ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_NO_SEQUENCE     ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_ADDRESS         ,_param->_nb_write_unit  );
 #endif
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Execution_unit_to_Write_unit.h
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Execution_unit_to_Write_unit.h	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Execution_unit_to_Write_unit.h	(revision 88)
@@ -65,21 +65,21 @@
 
     // ~~~~~[ Interface "execute_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-  public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_OUT_VAL            ;
-  public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_OUT_ACK            ;
-  public    : SC_IN (Tcontext_t        )   **  in_EXECUTE_UNIT_OUT_CONTEXT_ID     ;
-  public    : SC_IN (Tcontext_t        )   **  in_EXECUTE_UNIT_OUT_FRONT_END_ID   ;
-  public    : SC_IN (Tcontext_t        )   **  in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID  ;
-  public    : SC_IN (Tpacket_t         )   **  in_EXECUTE_UNIT_OUT_PACKET_ID      ;
-//public    : SC_IN (Toperation_t      )   **  in_EXECUTE_UNIT_OUT_OPERATION      ;
-  public    : SC_IN (Ttype_t           )   **  in_EXECUTE_UNIT_OUT_TYPE           ;
-  public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_OUT_WRITE_RD       ;
-  public    : SC_IN (Tgeneral_address_t)   **  in_EXECUTE_UNIT_OUT_NUM_REG_RD     ;
-  public    : SC_IN (Tgeneral_data_t   )   **  in_EXECUTE_UNIT_OUT_DATA_RD        ;
-  public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_OUT_WRITE_RE       ;
-  public    : SC_IN (Tspecial_address_t)   **  in_EXECUTE_UNIT_OUT_NUM_REG_RE     ;
-  public    : SC_IN (Tspecial_data_t   )   **  in_EXECUTE_UNIT_OUT_DATA_RE        ;
-  public    : SC_IN (Texception_t      )   **  in_EXECUTE_UNIT_OUT_EXCEPTION      ;
-  public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_OUT_NO_SEQUENCE    ;
-  public    : SC_IN (Tgeneral_data_t   )   **  in_EXECUTE_UNIT_OUT_ADDRESS        ;
+  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_OUT_VAL            ;
+  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_OUT_ACK            ;
+  public    : SC_IN (Tcontext_t        )  ***  in_EXECUTE_UNIT_OUT_CONTEXT_ID     ;
+  public    : SC_IN (Tcontext_t        )  ***  in_EXECUTE_UNIT_OUT_FRONT_END_ID   ;
+  public    : SC_IN (Tcontext_t        )  ***  in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID  ;
+  public    : SC_IN (Tpacket_t         )  ***  in_EXECUTE_UNIT_OUT_PACKET_ID      ;
+//public    : SC_IN (Toperation_t      )  ***  in_EXECUTE_UNIT_OUT_OPERATION      ;
+  public    : SC_IN (Ttype_t           )  ***  in_EXECUTE_UNIT_OUT_TYPE           ;
+  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_OUT_WRITE_RD       ;
+  public    : SC_IN (Tgeneral_address_t)  ***  in_EXECUTE_UNIT_OUT_NUM_REG_RD     ;
+  public    : SC_IN (Tgeneral_data_t   )  ***  in_EXECUTE_UNIT_OUT_DATA_RD        ;
+  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_OUT_WRITE_RE       ;
+  public    : SC_IN (Tspecial_address_t)  ***  in_EXECUTE_UNIT_OUT_NUM_REG_RE     ;
+  public    : SC_IN (Tspecial_data_t   )  ***  in_EXECUTE_UNIT_OUT_DATA_RE        ;
+  public    : SC_IN (Texception_t      )  ***  in_EXECUTE_UNIT_OUT_EXCEPTION      ;
+  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_OUT_NO_SEQUENCE    ;
+  public    : SC_IN (Tgeneral_data_t   )  ***  in_EXECUTE_UNIT_OUT_ADDRESS        ;
 
     // ~~~~~[ Interface "write_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -107,5 +107,5 @@
 
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-  private   : std::list<uint32_t> ** _destination; // [nb_execute_unit][nb_thread];
+  private   : std::list<uint32_t> *** _destination; //[nb_execute_unit][nb_execute_unit_port][nb_thread];
 #endif
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Parameters.h
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Parameters.h	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Parameters.h	(revision 88)
@@ -26,34 +26,37 @@
   {
     //-----[ fields ]------------------------------------------------------------
-  public : const uint32_t    _nb_execute_unit              ;
-  public : const uint32_t    _nb_write_unit                ;
-  public : const uint32_t    _nb_context                   ;
-  public : const uint32_t    _nb_front_end                 ;
-  public : const uint32_t    _nb_ooo_engine                ;
-  public : const uint32_t    _nb_packet                    ;
-  public : const uint32_t    _size_general_data            ;
-  public : const uint32_t    _size_special_data            ;
-  public : const uint32_t    _nb_general_register          ;
-  public : const uint32_t    _nb_special_register          ;
-  public : const Tpriority_t _priority                     ;
-  public :       bool     ** _table_routing                ; //array [nb_execute_unit][nb_write_unit]
-  public :       bool     ** _table_thread                 ; //array [nb_write_unit][nb_thread]
+  public : uint32_t    _nb_execute_unit              ;
+  public : uint32_t  * _nb_execute_unit_port         ;//[nb_execute_unit]
+  public : uint32_t    _nb_write_unit                ;
+  public : uint32_t    _nb_context                   ;
+  public : uint32_t    _nb_front_end                 ;
+  public : uint32_t    _nb_ooo_engine                ;
+  public : uint32_t    _nb_packet                    ;
+//public : uint32_t    _size_general_data            ;
+//public : uint32_t    _size_special_data            ;
+  public : uint32_t    _nb_general_register          ;
+  public : uint32_t    _nb_special_register          ;
+  public : Tpriority_t _priority                     ;
+  public : bool    *** _table_routing                ; //[nb_execute_unit][nb_execute_unit_port][nb_write_unit]
+  public : bool     ** _table_thread                 ; //[nb_write_unit][nb_thread]
 
-  public : const uint32_t    _size_context_id              ;
-  public : const uint32_t    _size_front_end_id            ;
-  public : const uint32_t    _size_ooo_engine_id           ;
-  public : const uint32_t    _size_packet_id               ;
-  public : const uint32_t    _size_general_register        ;
-  public : const uint32_t    _size_special_register        ;
+  public : uint32_t    _max_nb_execute_unit_port     ;
+//public : uint32_t    _size_context_id              ;
+//public : uint32_t    _size_front_end_id            ;
+//public : uint32_t    _size_ooo_engine_id           ;
+//public : uint32_t    _size_packet_id               ;
+//public : uint32_t    _size_general_register        ;
+//public : uint32_t    _size_special_register        ;
 
-  public : const bool        _have_port_context_id         ;
-  public : const bool        _have_port_front_end_id       ;
-  public : const bool        _have_port_ooo_engine_id      ;
-  public : const bool        _have_port_packet_id          ;
+//public : bool        _have_port_context_id         ;
+//public : bool        _have_port_front_end_id       ;
+//public : bool        _have_port_ooo_engine_id      ;
+//public : bool        _have_port_packet_id          ;
 
-  public : const uint32_t    _nb_thread                    ;
+  public : uint32_t    _nb_thread                    ;
 
     //-----[ methods ]-----------------------------------------------------------
   public : Parameters  (uint32_t    nb_execute_unit              ,
+			uint32_t  * nb_execute_unit_port         ,
 			uint32_t    nb_write_unit                ,
 			uint32_t    nb_context                   ,
@@ -66,8 +69,12 @@
 			uint32_t    nb_special_register          ,
 			Tpriority_t priority                     ,
-			bool     ** table_routing                ,
-			bool     ** table_thread                 );
-  public : Parameters  (Parameters & param) ;
+			bool    *** table_routing                ,
+			bool     ** table_thread                 ,
+                        bool        is_toplevel=false
+                        );
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters ();
+
+  public :        void            copy       (void);
 
   public :        Parameters_test msg_error  (void);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit.cpp	(revision 88)
@@ -38,4 +38,10 @@
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
 
+#if DEBUG_Execution_unit_to_Write_unit == true
+    log_printf(INFO,Execution_unit_to_Write_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+
+    std::cout << *param << std::endl;
+#endif    
+
     log_printf(INFO,Execution_unit_to_Write_unit,FUNCTION,"Allocation");
 
@@ -47,5 +53,5 @@
 
 #ifdef STATISTICS
-    if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
       {	
 	log_printf(INFO,Execution_unit_to_Write_unit,FUNCTION,"Allocation of statistics");
@@ -56,5 +62,5 @@
 
 #ifdef VHDL
-    if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
       {
 	// generate the vhdl
@@ -66,5 +72,5 @@
 
 #ifdef SYSTEMC
-    if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
       {
 	log_printf(INFO,Execution_unit_to_Write_unit,FUNCTION,"Method - transition");
@@ -84,27 +90,28 @@
 	sensitive << (*(in_CLOCK)).pos();
 	for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-	  {
-	    if (_param->_have_port_context_id)
-            sensitive << (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i]));
-            if (_param->_have_port_front_end_id)
-	    sensitive << (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i]));
-            if (_param->_have_port_ooo_engine_id)
-	    sensitive << (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i]));
-            if (_param->_have_port_packet_id)
-	    sensitive << (*(in_EXECUTE_UNIT_OUT_PACKET_ID     [i]));
-
- 	    sensitive << (*(in_EXECUTE_UNIT_OUT_VAL           [i]))
-	            //<< (*(in_EXECUTE_UNIT_OUT_OPERATION     [i]))
-	            //<< (*(in_EXECUTE_UNIT_OUT_TYPE          [i]))
-		      << (*(in_EXECUTE_UNIT_OUT_WRITE_RD      [i]))
-		      << (*(in_EXECUTE_UNIT_OUT_NUM_REG_RD    [i]))
-		      << (*(in_EXECUTE_UNIT_OUT_DATA_RD       [i]))
-		      << (*(in_EXECUTE_UNIT_OUT_WRITE_RE      [i]))
-		      << (*(in_EXECUTE_UNIT_OUT_NUM_REG_RE    [i]))
-		      << (*(in_EXECUTE_UNIT_OUT_DATA_RE       [i]))
-		      << (*(in_EXECUTE_UNIT_OUT_EXCEPTION     [i]))
-		      << (*(in_EXECUTE_UNIT_OUT_NO_SEQUENCE   [i]))
-		      << (*(in_EXECUTE_UNIT_OUT_ADDRESS       [i]));
-	  }
+	  for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+	    {
+	      if (_param->_have_port_context_id)
+              sensitive << (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i][j]));
+              if (_param->_have_port_front_end_id)
+	      sensitive << (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i][j]));
+              if (_param->_have_port_ooo_engine_id)
+	      sensitive << (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i][j]));
+              if (_param->_have_port_rob_ptr  )
+	      sensitive << (*(in_EXECUTE_UNIT_OUT_PACKET_ID     [i][j]));
+	      
+ 	      sensitive << (*(in_EXECUTE_UNIT_OUT_VAL           [i][j]))
+		      //<< (*(in_EXECUTE_UNIT_OUT_OPERATION     [i][j]))
+		      //<< (*(in_EXECUTE_UNIT_OUT_TYPE          [i][j]))
+			<< (*(in_EXECUTE_UNIT_OUT_WRITE_RD      [i][j]))
+			<< (*(in_EXECUTE_UNIT_OUT_NUM_REG_RD    [i][j]))
+			<< (*(in_EXECUTE_UNIT_OUT_DATA_RD       [i][j]))
+			<< (*(in_EXECUTE_UNIT_OUT_WRITE_RE      [i][j]))
+			<< (*(in_EXECUTE_UNIT_OUT_NUM_REG_RE    [i][j]))
+			<< (*(in_EXECUTE_UNIT_OUT_DATA_RE       [i][j]))
+			<< (*(in_EXECUTE_UNIT_OUT_EXCEPTION     [i][j]))
+			<< (*(in_EXECUTE_UNIT_OUT_NO_SEQUENCE   [i][j]))
+			<< (*(in_EXECUTE_UNIT_OUT_ADDRESS       [i][j]));
+	    }
 	for (uint32_t i=0; i<_param->_nb_write_unit; i++)
 	  sensitive << (*(in_WRITE_UNIT_IN_ACK [i]));
@@ -113,29 +120,31 @@
 	// List dependency information
 	for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-	  {
-	    (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [i]));
-	    if (_param->_have_port_context_id)
-	    (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i]));
-	    if (_param->_have_port_front_end_id)
-	    (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i]));
-	    if (_param->_have_port_ooo_engine_id)
-	    (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_write_unit; j++)
-	      (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_WRITE_UNIT_IN_ACK [j])); 
-	  }
+	  for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+	    {
+	      (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_OUT_VAL           [i][j]));
+	      if (_param->_have_port_context_id)
+	      (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i][j]));
+	      if (_param->_have_port_front_end_id)
+	      (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i][j]));
+	      if (_param->_have_port_ooo_engine_id)
+	      (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i][j]));
+
+	      for (uint32_t x=0; x<_param->_nb_write_unit; x++)
+		(*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_WRITE_UNIT_IN_ACK [x])); 
+	    }
 
 	for (uint32_t i=0; i<_param->_nb_write_unit; i++)
 	  {
 	    (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 
@@ -143,13 +152,14 @@
 	      {
 	    (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 	      }
@@ -157,13 +167,14 @@
 	      {
 	    (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 	      }
@@ -171,175 +182,187 @@
 	      {
 	    (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
-	      }
-	      }
-
-	    if (_param->_have_port_packet_id)
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+	      }
+	      }
+
+	    if (_param->_have_port_rob_ptr  )
 	      {
 	    (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_PACKET_ID [j]));
-		(*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_PACKET_ID [x][y]));
+		(*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 	      }
 
 // 	    (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-// 	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+// 	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+// 	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
 // 	      {
-// 		(*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_OPERATION [j]));
-// 		(*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+// 		(*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_OPERATION [x][y]));
+// 		(*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
 // 		if (_param->_have_port_context_id)
-// 		(*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+// 		(*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
 // 		if (_param->_have_port_front_end_id)
-// 		(*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+// 		(*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
 // 		if (_param->_have_port_ooo_engine_id)
-// 		(*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+// 		(*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 // 	      }
 
 // 	    (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-// 	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+// 	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+// 	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
 // 	      {
-// 		(*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_TYPE [j]));
-// 		(*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+// 		(*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_TYPE [x][y]));
+// 		(*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
 // 		if (_param->_have_port_context_id)
-// 		(*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+// 		(*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
 // 		if (_param->_have_port_front_end_id)
-// 		(*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+// 		(*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
 // 		if (_param->_have_port_ooo_engine_id)
-// 		(*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+// 		(*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 // 	      }
 
 	    (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_WRITE_RD [j]));
-		(*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_WRITE_RD [x][y]));
+		(*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 
 	    (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_NUM_REG_RD [j]));
-		(*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_NUM_REG_RD [x][y]));
+		(*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 
 	    (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_DATA_RD [j]));
-		(*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_DATA_RD [x][y]));
+		(*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 
 	    (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_WRITE_RE [j]));
-		(*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_WRITE_RE [x][y]));
+		(*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 
 	    (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_NUM_REG_RE [j]));
-		(*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_NUM_REG_RE [x][y]));
+		(*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 
 	    (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_DATA_RE [j]));
-		(*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_DATA_RE [x][y]));
+		(*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 
 	    (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_EXCEPTION [j]));
-		(*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_EXCEPTION [x][y]));
+		(*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 
 	    (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_NO_SEQUENCE [j]));
-		(*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_NO_SEQUENCE [x][y]));
+		(*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 
 	    (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_WRITE_UNIT_IN_ACK [i])); 
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      {
-		(*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_ADDRESS [j]));
-		(*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
-		if (_param->_have_port_context_id)
-		(*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
-	      }
-
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      {
+		(*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_ADDRESS [x][y]));
+		(*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+	      }
 	  }
 # endif    
@@ -357,5 +380,5 @@
 
 #ifdef STATISTICS
-    if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
       {
 	log_printf(INFO,Execution_unit_to_Write_unit,FUNCTION,"Generate Statistics file");
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_allocation.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_allocation.cpp	(revision 88)
@@ -58,24 +58,25 @@
     // ~~~~~[ Interface "execute_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC1_INTERFACE("execute_unit_out", IN, EAST, "Output of execution_unit", _param->_nb_execute_unit);
+       ALLOC2_INTERFACE("execute_unit_out", IN, EAST, "Output of execution_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
 
-       ALLOC1_VALACK_IN ( in_EXECUTE_UNIT_OUT_VAL,VAL);
-       ALLOC1_VALACK_OUT(out_EXECUTE_UNIT_OUT_ACK,ACK);
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id      );
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id    );
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_packet_id       );
-     //ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation       );
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type            );
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                             );
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register);
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data    );
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                             );
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register);
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data    );
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception       );
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                             );
-       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_general_data    );
+       _ALLOC2_VALACK_IN ( in_EXECUTE_UNIT_OUT_VAL,VAL, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_VALACK_OUT(out_EXECUTE_UNIT_OUT_ACK,ACK, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id      , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr         , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+     //_ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation       , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type            , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                             , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                             , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception       , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                             , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_general_data    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
      }
+
     // ~~~~~[ Interface "write_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
@@ -87,5 +88,5 @@
        ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id    );
        ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
-       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_packet_id       );
+       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr         );
      //ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation       );
        ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type            );
@@ -102,12 +103,20 @@
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
 
-     _destination = new std::list<uint32_t> * [_param->_nb_execute_unit];
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
+     _destination = new std::list<uint32_t> ** [_param->_nb_execute_unit];
      for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
        {
-	 _destination [i] = new std::list<uint32_t> [_param->_nb_thread];
+	 _destination [i] = new std::list<uint32_t> * [_param->_nb_execute_unit_port[i]];
+	 for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+	   {
+	     _destination [i][j] = new std::list<uint32_t> [_param->_nb_thread];
+	   }
        }
+      }
 
 #ifdef POSITION
-    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_deallocation.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_deallocation.cpp	(revision 88)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Execution_unit_to_Write_unit.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -23,56 +24,49 @@
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
 
-    if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
       {
 	delete     in_CLOCK ;
 	delete     in_NRESET;
 
- 	delete []  in_EXECUTE_UNIT_OUT_VAL;
-        delete [] out_EXECUTE_UNIT_OUT_ACK;
-	if (_param->_have_port_context_id)
-        delete []  in_EXECUTE_UNIT_OUT_CONTEXT_ID   ;
-        if (_param->_have_port_front_end_id)
-	delete []  in_EXECUTE_UNIT_OUT_FRONT_END_ID ;
-        if (_param->_have_port_ooo_engine_id)
-	delete []  in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID;
-        if (_param->_have_port_packet_id)
-	delete []  in_EXECUTE_UNIT_OUT_PACKET_ID    ;
-      //delete []  in_EXECUTE_UNIT_OUT_OPERATION    ;
-	delete []  in_EXECUTE_UNIT_OUT_TYPE         ;
-        delete []  in_EXECUTE_UNIT_OUT_WRITE_RD     ;
-        delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RD   ;
-        delete []  in_EXECUTE_UNIT_OUT_DATA_RD      ;
-        delete []  in_EXECUTE_UNIT_OUT_WRITE_RE     ;
-        delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RE   ;
-        delete []  in_EXECUTE_UNIT_OUT_DATA_RE      ;
-        delete []  in_EXECUTE_UNIT_OUT_EXCEPTION    ;
-        delete []  in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ;
-        delete []  in_EXECUTE_UNIT_OUT_ADDRESS      ;
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_VAL          , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1);
+        DELETE2_SIGNAL(out_EXECUTE_UNIT_OUT_ACK          , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1);
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_CONTEXT_ID   , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_context_id      );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_FRONT_END_ID , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_front_end_id    );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_ooo_engine_id   );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_PACKET_ID    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_rob_ptr         );
+     // DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_OPERATION    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_operation       );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_type            );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RD     , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1                             );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RD   , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_general_register);
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RD      , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_general_data    );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RE     , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1                             );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RE   , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_special_register);
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RE      , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_special_data    );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_EXCEPTION    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_exception       );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1                             );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_ADDRESS      , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_general_data    );
 
-        delete [] out_WRITE_UNIT_IN_VAL;
-        delete []  in_WRITE_UNIT_IN_ACK;
-        if (_param->_have_port_context_id)
-	delete [] out_WRITE_UNIT_IN_CONTEXT_ID   ;
-        if (_param->_have_port_front_end_id)
-	delete [] out_WRITE_UNIT_IN_FRONT_END_ID ;
-        if (_param->_have_port_ooo_engine_id)
-	delete [] out_WRITE_UNIT_IN_OOO_ENGINE_ID;
-        if (_param->_have_port_packet_id)
-	delete [] out_WRITE_UNIT_IN_PACKET_ID    ;
-      //delete [] out_WRITE_UNIT_IN_OPERATION    ;
-	delete [] out_WRITE_UNIT_IN_TYPE         ;
-        delete [] out_WRITE_UNIT_IN_WRITE_RD     ;
-        delete [] out_WRITE_UNIT_IN_NUM_REG_RD   ;
-        delete [] out_WRITE_UNIT_IN_DATA_RD      ;
-        delete [] out_WRITE_UNIT_IN_WRITE_RE     ;
-        delete [] out_WRITE_UNIT_IN_NUM_REG_RE   ;
-        delete [] out_WRITE_UNIT_IN_DATA_RE      ;
-        delete [] out_WRITE_UNIT_IN_EXCEPTION    ;
-        delete [] out_WRITE_UNIT_IN_NO_SEQUENCE  ;
-        delete [] out_WRITE_UNIT_IN_ADDRESS      ;
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_VAL          , _param->_nb_write_unit,1);
+        DELETE1_SIGNAL( in_WRITE_UNIT_IN_ACK          , _param->_nb_write_unit,1);
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_CONTEXT_ID   , _param->_nb_write_unit,_param->_size_context_id      );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_FRONT_END_ID , _param->_nb_write_unit,_param->_size_front_end_id    );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_OOO_ENGINE_ID, _param->_nb_write_unit,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_PACKET_ID    , _param->_nb_write_unit,_param->_size_rob_ptr         );
+     // DELETE1_SIGNAL(out_WRITE_UNIT_IN_OPERATION    , _param->_nb_write_unit,_param->_size_operation       );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_TYPE         , _param->_nb_write_unit,_param->_size_type            );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_WRITE_RD     , _param->_nb_write_unit,1                             );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_NUM_REG_RD   , _param->_nb_write_unit,_param->_size_general_register);
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_DATA_RD      , _param->_nb_write_unit,_param->_size_general_data    );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_WRITE_RE     , _param->_nb_write_unit,1                             );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_NUM_REG_RE   , _param->_nb_write_unit,_param->_size_special_register);
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_DATA_RE      , _param->_nb_write_unit,_param->_size_special_data    );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_EXCEPTION    , _param->_nb_write_unit,_param->_size_exception       );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_NO_SEQUENCE  , _param->_nb_write_unit,1                             );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_ADDRESS      , _param->_nb_write_unit,_param->_size_general_data    );
+      
+        delete [] _destination;
       }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
 
-    delete [] _destination;
     delete    _component;
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_end_cycle.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_end_cycle.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_end_cycle.cpp	(revision 88)
@@ -25,5 +25,6 @@
 
 #ifdef STATISTICS
-    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif    
 
@@ -31,5 +32,6 @@
     // Evaluation before read the ouput signal
 //  sc_start(0);
-    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_genMealy.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_genMealy.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_genMealy.cpp	(revision 88)
@@ -30,63 +30,64 @@
 
     for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-      {
-	bool       ack = false;
-
-	log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"Test execute_unit[%d]",i);
-
-	if (PORT_READ(in_EXECUTE_UNIT_OUT_VAL [i]) == true)
-	  {
-	    log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION," * have a valid entry.");
-	    
-	    Tcontext_t context_id    = (_param->_have_port_context_id   )?PORT_READ(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i]):0;
-	    Tcontext_t front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i]):0;
-	    Tcontext_t ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i]):0;
-	    Tcontext_t num_thread    = get_num_thread(context_id   , _param->_size_context_id   ,
-						      front_end_id , _param->_size_front_end_id ,
-						      ooo_engine_id, _param->_size_ooo_engine_id);
+      for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+	{
+	  bool       ack = false;
+	  
+	  log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"Test execute_unit[%d][%d]",i,j);
+	  
+	  if (PORT_READ(in_EXECUTE_UNIT_OUT_VAL [i][j]) == true)
+	    {
+	      log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION," * have a valid entry.");
+	      
+	      Tcontext_t context_id    = (_param->_have_port_context_id   )?PORT_READ(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i][j]):0;
+	      Tcontext_t front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i][j]):0;
+	      Tcontext_t ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i][j]):0;
+	      Tcontext_t num_thread    = get_num_thread(context_id   , _param->_size_context_id   ,
+							front_end_id , _param->_size_front_end_id ,
+							ooo_engine_id, _param->_size_ooo_engine_id);
 #ifdef DEBUG_TEST
-	    if (_destination[i][num_thread].empty())
-	      throw ERRORMORPHEO(FUNCTION,"Invalid Operation : They have no write_unit to receive a operation from the execute_unit ["+toString(i)+"], thread ["+toString(num_thread)+"].");
+	      if (_destination[i][j][num_thread].empty())
+		throw ERRORMORPHEO(FUNCTION,"Invalid Operation : They have no write_unit to receive a operation from the execute_unit ["+toString(i)+"]["+toString(j)+"], thread ["+toString(num_thread)+"].");
 #endif
-
-	    // find a free write_unit
-	    for (std::list<uint32_t>::iterator it=_destination[i][num_thread].begin();
-		 (it != _destination[i][num_thread].end()) and (ack == false);
-		 it++)
-	      {
-		uint32_t dest = *it;
-
-		log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"   * Test destination [%d].",dest);
-			    
-		if (write_unit_use [dest] == false)
-		  {
-		    log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"     * Is ok! Link.");
-		    // have find !!!
-		    ack                   = true;
-		    write_unit_use [dest] = true;
-
-		    if (_param->_have_port_context_id)
-		    PORT_WRITE(out_WRITE_UNIT_IN_CONTEXT_ID            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_CONTEXT_ID            [i]));
-		    if (_param->_have_port_front_end_id)
-		    PORT_WRITE(out_WRITE_UNIT_IN_FRONT_END_ID          [dest], PORT_READ(in_EXECUTE_UNIT_OUT_FRONT_END_ID          [i]));
-		    if (_param->_have_port_ooo_engine_id)
-		    PORT_WRITE(out_WRITE_UNIT_IN_OOO_ENGINE_ID         [dest], PORT_READ(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID         [i]));
-		    if (_param->_have_port_packet_id)
-		    PORT_WRITE(out_WRITE_UNIT_IN_PACKET_ID             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_PACKET_ID             [i]));
-		  //PORT_WRITE(out_WRITE_UNIT_IN_OPERATION             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_OPERATION             [i]));
-		    PORT_WRITE(out_WRITE_UNIT_IN_TYPE                  [dest], PORT_READ(in_EXECUTE_UNIT_OUT_TYPE                  [i]));
-		    PORT_WRITE(out_WRITE_UNIT_IN_WRITE_RD              [dest], PORT_READ(in_EXECUTE_UNIT_OUT_WRITE_RD              [i]));
-		    PORT_WRITE(out_WRITE_UNIT_IN_NUM_REG_RD            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NUM_REG_RD            [i]));
-		    PORT_WRITE(out_WRITE_UNIT_IN_DATA_RD               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_DATA_RD               [i]));
-		    PORT_WRITE(out_WRITE_UNIT_IN_WRITE_RE              [dest], PORT_READ(in_EXECUTE_UNIT_OUT_WRITE_RE              [i]));
-		    PORT_WRITE(out_WRITE_UNIT_IN_NUM_REG_RE            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NUM_REG_RE            [i]));
-		    PORT_WRITE(out_WRITE_UNIT_IN_DATA_RE               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_DATA_RE               [i]));
-		    PORT_WRITE(out_WRITE_UNIT_IN_EXCEPTION             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_EXCEPTION             [i]));
-		    PORT_WRITE(out_WRITE_UNIT_IN_NO_SEQUENCE           [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NO_SEQUENCE           [i]));
-		    PORT_WRITE(out_WRITE_UNIT_IN_ADDRESS               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_ADDRESS               [i]));
-		  }
-	      }
-	  }
-	PORT_WRITE(out_EXECUTE_UNIT_OUT_ACK [i], ack);
+	      
+	      // find a free write_unit
+	      for (std::list<uint32_t>::iterator it=_destination[i][j][num_thread].begin();
+		   (it != _destination[i][j][num_thread].end()) and (ack == false);
+		   it++)
+		{
+		  uint32_t dest = *it;
+		  
+		  log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"   * Test destination [%d].",dest);
+		  
+		  if (write_unit_use [dest] == false)
+		    {
+		      log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"     * Is ok! Link.");
+		      // have find !!!
+		      ack                   = true;
+		      write_unit_use [dest] = true;
+		      
+		      if (_param->_have_port_context_id)
+		      PORT_WRITE(out_WRITE_UNIT_IN_CONTEXT_ID            [dest], context_id);
+		      if (_param->_have_port_front_end_id)
+		      PORT_WRITE(out_WRITE_UNIT_IN_FRONT_END_ID          [dest], front_end_id);
+		      if (_param->_have_port_ooo_engine_id)
+		      PORT_WRITE(out_WRITE_UNIT_IN_OOO_ENGINE_ID         [dest], ooo_engine_id);
+		      if (_param->_have_port_rob_ptr  )
+		      PORT_WRITE(out_WRITE_UNIT_IN_PACKET_ID             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_PACKET_ID             [i][j]));
+		  //  PORT_WRITE(out_WRITE_UNIT_IN_OPERATION             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_OPERATION             [i][j]));
+		      PORT_WRITE(out_WRITE_UNIT_IN_TYPE                  [dest], PORT_READ(in_EXECUTE_UNIT_OUT_TYPE                  [i][j]));
+		      PORT_WRITE(out_WRITE_UNIT_IN_WRITE_RD              [dest], PORT_READ(in_EXECUTE_UNIT_OUT_WRITE_RD              [i][j]));
+		      PORT_WRITE(out_WRITE_UNIT_IN_NUM_REG_RD            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NUM_REG_RD            [i][j]));
+		      PORT_WRITE(out_WRITE_UNIT_IN_DATA_RD               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_DATA_RD               [i][j]));
+		      PORT_WRITE(out_WRITE_UNIT_IN_WRITE_RE              [dest], PORT_READ(in_EXECUTE_UNIT_OUT_WRITE_RE              [i][j]));
+		      PORT_WRITE(out_WRITE_UNIT_IN_NUM_REG_RE            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NUM_REG_RE            [i][j]));
+		      PORT_WRITE(out_WRITE_UNIT_IN_DATA_RE               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_DATA_RE               [i][j]));
+		      PORT_WRITE(out_WRITE_UNIT_IN_EXCEPTION             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_EXCEPTION             [i][j]));
+		      PORT_WRITE(out_WRITE_UNIT_IN_NO_SEQUENCE           [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NO_SEQUENCE           [i][j]));
+		      PORT_WRITE(out_WRITE_UNIT_IN_ADDRESS               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_ADDRESS               [i][j]));
+		    }
+		}
+	    }
+	  PORT_WRITE(out_EXECUTE_UNIT_OUT_ACK [i][j], ack);
       }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_transition.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_transition.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_transition.cpp	(revision 88)
@@ -27,42 +27,46 @@
       {
 	// Flush routing_table
-	for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-	  for (uint32_t j=0; j<_param->_nb_thread; j++)
-	      _destination [i][j].clear();
+	for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	  for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	    for (uint32_t j=0; j<_param->_nb_thread; j++)
+	      _destination [x][y][j].clear();
 	
 	// Fill routing table
-	for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-	  for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	    // Test if link between src and dest
-	    if (_param->_table_routing [i][j])
-	      // Test the thread accepted by the execute_unit
-	      for (uint32_t k=0; k<_param->_nb_thread; k++)
-		if (_param->_table_thread[j][k])
-		  // push_back == minor have a better priority
-		  _destination [i][k].push_back(j);
+	for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	  for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	    for (uint32_t j=0; j<_param->_nb_write_unit; j++)
+	      // Test if link between src and dest
+	      if (_param->_table_routing [x][y][j])
+		// Test the thread accepted by the execute_unit
+		for (uint32_t k=0; k<_param->_nb_thread; k++)
+		  if (_param->_table_thread[j][k])
+		    // push_back == minor have a better priority
+		    _destination [x][y][k].push_back(j);
       }
     else
       {
 	if (_param->_priority == PRIORITY_ROUND_ROBIN)
-	  for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-	    for (uint32_t j=0; j<_param->_nb_thread; j++)
-	      if (_destination [i][j].size() > 1)
-		{
-		  // Head queue became the Tail queue
-		  _destination [i][j].push_back(_destination [i][j].front());
-		  _destination [i][j].pop_front();
-		}
+	  for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	    for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      for (uint32_t j=0; j<_param->_nb_thread; j++)
+		if (_destination [x][y][j].size() > 1)
+		  {
+		    // Head queue became the Tail queue
+		    _destination [x][y][j].push_back(_destination [x][y][j].front());
+		    _destination [x][y][j].pop_front();
+		  }
       }
-
-
+    
+    
 #if (DEBUG >= DEBUG_TRACE)
     // Print
     log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"Routing Table");
-    for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-      for (uint32_t j=0; j<_param->_nb_thread; j++)
-	for (std::list<uint32_t>::iterator k=_destination[i][j].begin();
-	     k != _destination[i][j].end();
-	     k++)
-	  log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"  * Execute_unit [%d], send at the write_unit [%d], the operation of thread [%d].",i,*k,j);
+    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	for (uint32_t j=0; j<_param->_nb_thread; j++)
+	  for (std::list<uint32_t>::iterator k=_destination[x][y][j].begin();
+	       k != _destination[x][y][j].end();
+	       k++)
+	    log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"  * Execute_unit [%d][%d], send at the write_unit [%d], the operation of thread [%d].",x,y,*k,j);
 #endif
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Parameters.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Parameters.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Parameters.cpp	(revision 88)
@@ -7,5 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Parameters.h"
-
+#include "Common/include/Max.h"
 namespace morpheo {
 namespace behavioural {
@@ -20,4 +20,5 @@
 #define FUNCTION "Execution_unit_to_Write_unit::Parameters"
   Parameters::Parameters (uint32_t    nb_execute_unit              ,
+			  uint32_t  * nb_execute_unit_port         ,//[nb_execute_unit]
 			  uint32_t    nb_write_unit                ,
 			  uint32_t    nb_context                   ,
@@ -30,82 +31,72 @@
 			  uint32_t    nb_special_register          ,
 			  Tpriority_t priority                     ,
-			  bool     ** table_routing                ,
-			  bool     ** table_thread                 ):
-    _nb_execute_unit         (nb_execute_unit    ),
-    _nb_write_unit           (nb_write_unit      ),
-    _nb_context              (nb_context         ),
-    _nb_front_end            (nb_front_end       ),
-    _nb_ooo_engine           (nb_ooo_engine      ),
-    _nb_packet               (nb_packet          ),
-    _size_general_data       (size_general_data  ),
-    _size_special_data       (size_special_data  ),
-    _nb_general_register     (nb_general_register),
-    _nb_special_register     (nb_special_register),
-    _priority                (priority           ),
-    
-    _size_context_id         (log2(nb_context         )),
-    _size_front_end_id       (log2(nb_front_end       )),
-    _size_ooo_engine_id      (log2(nb_ooo_engine      )),
-    _size_packet_id          (log2(nb_packet          )),
-    _size_general_register   (log2(nb_general_register)),
-    _size_special_register   (log2(nb_special_register)),
-    
-    _have_port_context_id    (_size_context_id    > 0),
-    _have_port_front_end_id  (_size_front_end_id  > 0),
-    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
-    _have_port_packet_id     (_size_packet_id     > 0),
-
-    _nb_thread               (get_nb_thread (nb_context, nb_front_end, nb_ooo_engine))
+			  bool    *** table_routing                ,//[nb_execute_unit][nb_execute_unit_port][nb_write_unit]
+			  bool     ** table_thread                 ,//[nb_write_unit][nb_thread]                            
+                          bool        is_toplevel                  )
   {
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
 
-    _table_routing = table_routing ;
-    _table_thread  = table_thread  ;
+    _nb_execute_unit         = nb_execute_unit     ;
+    _nb_execute_unit_port    = nb_execute_unit_port;
+    _nb_write_unit           = nb_write_unit       ;
+    _nb_context              = nb_context          ;
+    _nb_front_end            = nb_front_end        ;
+    _nb_ooo_engine           = nb_ooo_engine       ;
+    _nb_packet               = nb_packet           ;
+    _nb_general_register     = nb_general_register ;
+    _nb_special_register     = nb_special_register ;
+    _priority                = priority            ;
+    _table_routing           = table_routing       ;
+    _table_thread            = table_thread        ;
+
+    _max_nb_execute_unit_port= max<uint32_t>(_nb_execute_unit_port, _nb_execute_unit);
+
+    _nb_thread               = get_nb_thread (nb_context, nb_front_end, nb_ooo_engine);
 
     test();
+
+    if (is_toplevel)
+      {
+        _size_context_id         = log2(nb_context         );
+        _size_front_end_id       = log2(nb_front_end       );
+        _size_ooo_engine_id      = log2(nb_ooo_engine      );
+        _size_rob_ptr            = log2(nb_packet          );
+        _size_general_register   = log2(nb_general_register);
+        _size_special_register   = log2(nb_special_register);
+        _size_general_data       = size_general_data  ;
+        _size_special_data       = size_special_data  ;
+        
+        _have_port_context_id    = _size_context_id    > 0;
+        _have_port_front_end_id  = _size_front_end_id  > 0;
+        _have_port_ooo_engine_id = _size_ooo_engine_id > 0;
+        _have_port_rob_ptr       = _size_rob_ptr       > 0;
+
+        copy();
+      }
+
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"End");
   };
   
+// #undef  FUNCTION
+// #define FUNCTION "Execution_unit_to_Write_unit::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param)  
+//   {
+//     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
+
+//     test();
+//     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"End");
+//   };
+
 #undef  FUNCTION
-#define FUNCTION "Execution_unit_to_Write_unit::Parameters (copy)"
-  Parameters::Parameters (Parameters & param):
-    _nb_execute_unit         (param._nb_execute_unit        ),
-    _nb_write_unit           (param._nb_write_unit          ),
-    _nb_context              (param._nb_context             ),
-    _nb_front_end            (param._nb_front_end           ),
-    _nb_ooo_engine           (param._nb_ooo_engine          ),
-    _nb_packet               (param._nb_packet              ),
-    _size_general_data       (param._size_general_data      ),
-    _size_special_data       (param._size_special_data      ),
-    _nb_general_register     (param._nb_general_register    ),
-    _nb_special_register     (param._nb_special_register    ),
-    _priority                (param._priority               ),
-
-    _size_context_id         (param._size_context_id        ),
-    _size_front_end_id       (param._size_front_end_id      ),
-    _size_ooo_engine_id      (param._size_ooo_engine_id     ),
-    _size_packet_id          (param._size_packet_id         ),
-    _size_general_register   (param._size_general_register  ),
-    _size_special_register   (param._size_special_register  ),
-
-    _have_port_context_id    (param._have_port_context_id   ),
-    _have_port_front_end_id  (param._have_port_front_end_id ),
-    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
-    _have_port_packet_id     (param._have_port_packet_id    ),
-
-    _nb_thread               (param._nb_thread              )
+#define FUNCTION "Execution_unit_to_Write_unit::~Parameters"
+  Parameters::~Parameters (void) 
   {
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
-
-    _table_routing = param._table_routing ;
-    _table_thread  = param._table_thread  ;
-
-    test();
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"End");
   };
 
 #undef  FUNCTION
-#define FUNCTION "Execution_unit_to_Write_unit::~Parameters"
-  Parameters::~Parameters () 
+#define FUNCTION "Execution_unit_to_Write_unit::copy"
+  void Parameters::copy (void) 
   {
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Parameters_msg_error.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Parameters_msg_error.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Parameters_msg_error.cpp	(revision 88)
@@ -24,18 +24,32 @@
   {
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
+    
+    Parameters_test test("Execution_unit_to_Write_unit");
+    
+    bool is_link [_nb_execute_unit][_max_nb_execute_unit_port];
+    for (uint32_t i=0; i<_nb_execute_unit; i++)
+      for (uint32_t j=0; j<_nb_execute_unit_port[i]; j++)
+	is_link[i][j] = false;
+	
+    for (uint32_t i=0; i<_nb_execute_unit; i++)
+      for (uint32_t j=0; j<_nb_execute_unit_port[i]; j++)
+	for (uint32_t k=0; k<_nb_write_unit; k++)
+          {
+            log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"[%d][%d][%d]",i,j,k);
+            
+            if (_table_routing [i][j][k] == true)
+              {
+                log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION," * is link");
 
-    Parameters_test test("Execution_unit_to_Write_unit");
+                is_link [i][j] = true;
+                break;
+              }
+          }
 
     for (uint32_t i=0; i<_nb_execute_unit; i++)
-      {
-	uint32_t j;
-	for (j=0; j<_nb_write_unit; j++)
-	  if (_table_routing [i][j] == true)
-	    break;
-
-	if (j == _nb_write_unit)
-	  test.error("The execute_unit ["+toString(i)+"] is link with none write_unit.");
-      }	  
-
+      for (uint32_t j=0; j<_nb_execute_unit_port[i]; j++)
+	if (not is_link[i][j])
+	  test.error(toString(_("The execute_unit [%d][%d] is link with none write_unit.\n"),i,j));
+    
     for (uint32_t i=0; i<_nb_write_unit; i++)
       {
@@ -44,12 +58,12 @@
 	  if (_table_thread [i][j] == true)
 	    break;
-
+	
 	if (j == _nb_thread)
-	  test.error("The write_unit ["+toString(i)+"] have none source's thread.");
+	  test.error(toString(_("The write_unit [%d] have none source's thread.\n"),i));
       }	  
 
     if ( (_priority != PRIORITY_STATIC     ) and
 	 (_priority != PRIORITY_ROUND_ROBIN))
-      test.error("Unsupported priority scheme. It must be Static or Round Robin.");
+      test.error(_("Unsupported priority scheme. It must be Static or Round Robin.\n"));
 
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"End");
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/Makefile
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/Makefile	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/Makefile	(revision 88)
@@ -24,4 +24,6 @@
 library_clean			: Read_unit_to_Execution_unit_library_clean
 
+local_clean			:
+
 include                         $(DIR_COMPONENT)/Makefile.deps
 include                         $(DIR_MORPHEO)/Behavioural/Makefile.flags
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_min.cfg
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_min.cfg	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_min.cfg	(revision 88)
@@ -1,5 +1,8 @@
 Read_unit_to_Execution_unit
 1	1 	*2	# nb_read_unit           
-2	2 	*2	# nb_execute_unit        
+1	1 	+1	# nb_read_unit_port    [0] [nb_read_unit]
+2	2 	*2	# nb_execute_unit
+1	1 	+1	# nb_execute_unit_port [0] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [1] [nb_execute_unit]
 1	1	*2	# nb_context             
 1	1	*2	# nb_front_end           
@@ -13,11 +16,12 @@
 4	4	*2	# size_load_queue        
 0	1	+1	# priority
-1	1	+1	# table_routing        [0][0]
-1	1	+1	# table_routing        [0][1]
+1	1	+1	# table_routing        [0][0][0]
+1	1	+1	# table_routing        [0][1][0]
 0	0	+1	# table_execute_type   [0][TYPE_ALU    ]
 0	0	+1	# table_execute_type   [0][TYPE_SHIFT  ]
 0	0	+1	# table_execute_type   [0][TYPE_MOVE   ]
 0	0	+1	# table_execute_type   [0][TYPE_TEST   ]
-0	0	+1	# table_execute_type   [0][TYPE_MUL_DIV]
+0	0	+1	# table_execute_type   [0][TYPE_MUL    ]
+0	0	+1	# table_execute_type   [0][TYPE_DIV    ]
 0	0	+1	# table_execute_type   [0][TYPE_EXTEND ]
 0	0	+1	# table_execute_type   [0][TYPE_FIND   ]
@@ -30,5 +34,6 @@
 1	1	+1	# table_execute_type   [1][TYPE_MOVE   ]
 1	1	+1	# table_execute_type   [1][TYPE_TEST   ]
-1	1	+1	# table_execute_type   [1][TYPE_MUL_DIV]
+1	1	+1	# table_execute_type   [1][TYPE_MUL    ]
+1	1	+1	# table_execute_type   [1][TYPE_DIV    ]
 1	1	+1	# table_execute_type   [1][TYPE_EXTEND ]
 1	1	+1	# table_execute_type   [1][TYPE_FIND   ]
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_multi_execute-mono_thread-multi_lsq.cfg
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_multi_execute-mono_thread-multi_lsq.cfg	(revision 88)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_multi_execute-mono_thread-multi_lsq.cfg	(revision 88)
@@ -0,0 +1,105 @@
+Read_unit_to_Execution_unit
+3	3 	*2	# nb_read_unit           
+2	2 	+1	# nb_read_unit_port    [0] [nb_read_unit]
+3	3 	+1	# nb_read_unit_port    [1] [nb_read_unit]
+1	1 	+1	# nb_read_unit_port    [2] [nb_read_unit]
+5	5 	*2	# nb_execute_unit
+2	2 	+1	# nb_execute_unit_port [0] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [1] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [2] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [3] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [4] [nb_execute_unit]
+1	1	*2	# nb_context             
+1	1	*2	# nb_front_end           
+1	1	*2	# nb_ooo_engine          
+64	64	*2	# nb_packet              
+32	32	*2	# size_general_data      
+2	2	*2	# size_special_data      
+64	64	*2	# nb_general_register    
+16	16	*2	# nb_special_register    
+4	4	*2	# size_store_queue       
+1	4	*4	# size_load_queue        
+0	1	+1	# priority
+1	1	+1	# table_routing        [0][0][0]
+1	1	+1	# table_routing        [0][0][0]
+0	0	+1	# table_routing        [0][1][0]
+0	0	+1	# table_routing        [0][2][0]
+0	0	+1	# table_routing        [0][3][0]
+0	0	+1	# table_routing        [0][4][0]
+0 	0	+1	# table_routing        [1][0][0]
+0 	0	+1	# table_routing        [1][0][1]
+1	1	+1	# table_routing        [1][1][0]
+1	1	+1	# table_routing        [1][2][0]
+0	0	+1	# table_routing        [1][3][0]
+0	0	+1	# table_routing        [1][4][0]
+0	0	+1	# table_routing        [2][0][0]
+1	1	+1	# table_routing        [2][0][1]
+0	0	+1	# table_routing        [2][1][0]
+1	1	+1	# table_routing        [2][2][0]
+1	1	+1	# table_routing        [2][3][0]
+1	1	+1	# table_routing        [2][4][0]
+0	0	+1	# table_execute_type   [0][TYPE_ALU    ]
+0	0	+1	# table_execute_type   [0][TYPE_SHIFT  ]
+0	0	+1	# table_execute_type   [0][TYPE_MOVE   ]
+0	0	+1	# table_execute_type   [0][TYPE_TEST   ]
+0	0	+1	# table_execute_type   [0][TYPE_MUL    ]
+0	0	+1	# table_execute_type   [0][TYPE_DIV    ]
+0	0	+1	# table_execute_type   [0][TYPE_EXTEND ]
+0	0	+1	# table_execute_type   [0][TYPE_FIND   ]
+0	0	+1	# table_execute_type   [0][TYPE_SPECIAL]
+0	0	+1	# table_execute_type   [0][TYPE_CUSTOM ]
+0	0	+1	# table_execute_type   [0][TYPE_BRANCH ]
+1	1	+1	# table_execute_type   [0][TYPE_MEMORY ]
+1	1	+1	# table_execute_type   [1][TYPE_ALU    ]
+1	1	+1	# table_execute_type   [1][TYPE_SHIFT  ]
+1	1	+1	# table_execute_type   [1][TYPE_MOVE   ]
+1	1	+1	# table_execute_type   [1][TYPE_TEST   ]
+1	1	+1	# table_execute_type   [1][TYPE_MUL    ]
+1	1	+1	# table_execute_type   [1][TYPE_DIV    ]
+1	1	+1	# table_execute_type   [1][TYPE_EXTEND ]
+1	1	+1	# table_execute_type   [1][TYPE_FIND   ]
+1	1	+1	# table_execute_type   [1][TYPE_SPECIAL]
+1	1	+1	# table_execute_type   [1][TYPE_CUSTOM ]
+1	1	+1	# table_execute_type   [1][TYPE_BRANCH ]
+0	0	+1	# table_execute_type   [1][TYPE_MEMORY ]
+1	1	+1	# table_execute_type   [2][TYPE_ALU    ]
+0	0	+1	# table_execute_type   [2][TYPE_SHIFT  ]
+0	0	+1	# table_execute_type   [2][TYPE_MOVE   ]
+0	0	+1	# table_execute_type   [2][TYPE_TEST   ]
+0	0	+1	# table_execute_type   [2][TYPE_MUL    ]
+0	0	+1	# table_execute_type   [2][TYPE_DIV    ]
+0	0	+1	# table_execute_type   [2][TYPE_EXTEND ]
+0	0	+1	# table_execute_type   [2][TYPE_FIND   ]
+0	0	+1	# table_execute_type   [2][TYPE_SPECIAL]
+0	0	+1	# table_execute_type   [2][TYPE_CUSTOM ]
+1	1	+1	# table_execute_type   [2][TYPE_BRANCH ]
+0	0	+1	# table_execute_type   [2][TYPE_MEMORY ]
+1	1	+1	# table_execute_type   [3][TYPE_ALU    ]
+1	1	+1	# table_execute_type   [3][TYPE_SHIFT  ]
+1	1	+1	# table_execute_type   [3][TYPE_MOVE   ]
+1	1	+1	# table_execute_type   [3][TYPE_TEST   ]
+0	0	+1	# table_execute_type   [3][TYPE_MUL    ]
+0	0	+1	# table_execute_type   [3][TYPE_DIV    ]
+1	1	+1	# table_execute_type   [3][TYPE_EXTEND ]
+1	1	+1	# table_execute_type   [3][TYPE_FIND   ]
+0	0	+1	# table_execute_type   [3][TYPE_SPECIAL]
+0	0	+1	# table_execute_type   [3][TYPE_CUSTOM ]
+1	1	+1	# table_execute_type   [3][TYPE_BRANCH ]
+0	0	+1	# table_execute_type   [3][TYPE_MEMORY ]
+0	0	+1	# table_execute_type   [4][TYPE_ALU    ]
+1	1	+1	# table_execute_type   [4][TYPE_SHIFT  ]
+1	1	+1	# table_execute_type   [4][TYPE_MOVE   ]
+0	0	+1	# table_execute_type   [4][TYPE_TEST   ]
+1	1	+1	# table_execute_type   [4][TYPE_MUL    ]
+1	1	+1	# table_execute_type   [4][TYPE_DIV    ]
+0	0	+1	# table_execute_type   [4][TYPE_EXTEND ]
+0	0	+1	# table_execute_type   [4][TYPE_FIND   ]
+0	0	+1	# table_execute_type   [4][TYPE_SPECIAL]
+0	0	+1	# table_execute_type   [4][TYPE_CUSTOM ]
+0	0	+1	# table_execute_type   [4][TYPE_BRANCH ]
+0	0	+1	# table_execute_type   [4][TYPE_MEMORY ]
+1	1	+1	# table_execute_thread [0][0]
+1	1	+1	# table_execute_thread [1][0]
+1	1	+1	# table_execute_thread [2][0]
+1	1	+1	# table_execute_thread [3][0]
+1	1	+1	# table_execute_thread [4][0]
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_multi_execute-mono_thread.cfg
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_multi_execute-mono_thread.cfg	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_multi_execute-mono_thread.cfg	(revision 88)
@@ -1,5 +1,12 @@
 Read_unit_to_Execution_unit
 3	3 	*2	# nb_read_unit           
+1	1 	+1	# nb_read_unit_port    [0] [nb_read_unit]
+2	2 	+1	# nb_read_unit_port    [1] [nb_read_unit]
+4	4 	+1	# nb_read_unit_port    [2] [nb_read_unit]
 4	4 	*2	# nb_execute_unit        
+1	1 	+1	# nb_execute_unit_port [0] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [1] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [2] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [3] [nb_execute_unit]
 1	1	*2	# nb_context             
 1	1	*2	# nb_front_end           
@@ -13,21 +20,22 @@
 1	4	*4	# size_load_queue        
 0	1	+1	# priority
-1	1	+1	# table_routing        [0][0]
-0	0	+1	# table_routing        [0][1]
-0	0	+1	# table_routing        [0][2]
-0	0	+1	# table_routing        [0][3]
-0 	0	+1	# table_routing        [1][0]
-1	1	+1	# table_routing        [1][1]
-1	1	+1	# table_routing        [1][2]
-0	0	+1	# table_routing        [1][3]
-0	0	+1	# table_routing        [2][0]
-0	0	+1	# table_routing        [2][1]
-1	1	+1	# table_routing        [2][2]
-1	1	+1	# table_routing        [2][3]
+1	1	+1	# table_routing        [0][0][0]
+0	0	+1	# table_routing        [0][1][0]
+0	0	+1	# table_routing        [0][2][0]
+0	0	+1	# table_routing        [0][3][0]
+0 	0	+1	# table_routing        [1][0][0]
+1	1	+1	# table_routing        [1][1][0]
+1	1	+1	# table_routing        [1][2][0]
+0	0	+1	# table_routing        [1][3][0]
+0	0	+1	# table_routing        [2][0][0]
+0	0	+1	# table_routing        [2][1][0]
+1	1	+1	# table_routing        [2][2][0]
+1	1	+1	# table_routing        [2][3][0]
 0	0	+1	# table_execute_type   [0][TYPE_ALU    ]
 0	0	+1	# table_execute_type   [0][TYPE_SHIFT  ]
 0	0	+1	# table_execute_type   [0][TYPE_MOVE   ]
 0	0	+1	# table_execute_type   [0][TYPE_TEST   ]
-0	0	+1	# table_execute_type   [0][TYPE_MUL_DIV]
+0	0	+1	# table_execute_type   [0][TYPE_MUL    ]
+0	0	+1	# table_execute_type   [0][TYPE_DIV    ]
 0	0	+1	# table_execute_type   [0][TYPE_EXTEND ]
 0	0	+1	# table_execute_type   [0][TYPE_FIND   ]
@@ -40,5 +48,6 @@
 1	1	+1	# table_execute_type   [1][TYPE_MOVE   ]
 1	1	+1	# table_execute_type   [1][TYPE_TEST   ]
-1	1	+1	# table_execute_type   [1][TYPE_MUL_DIV]
+1	1	+1	# table_execute_type   [1][TYPE_MUL    ]
+1	1	+1	# table_execute_type   [1][TYPE_DIV    ]
 1	1	+1	# table_execute_type   [1][TYPE_EXTEND ]
 1	1	+1	# table_execute_type   [1][TYPE_FIND   ]
@@ -51,5 +60,6 @@
 0	0	+1	# table_execute_type   [2][TYPE_MOVE   ]
 0	0	+1	# table_execute_type   [2][TYPE_TEST   ]
-0	0	+1	# table_execute_type   [2][TYPE_MUL_DIV]
+0	0	+1	# table_execute_type   [2][TYPE_MUL    ]
+0	0	+1	# table_execute_type   [2][TYPE_DIV    ]
 0	0	+1	# table_execute_type   [2][TYPE_EXTEND ]
 0	0	+1	# table_execute_type   [2][TYPE_FIND   ]
@@ -62,5 +72,6 @@
 1	1	+1	# table_execute_type   [3][TYPE_MOVE   ]
 1	1	+1	# table_execute_type   [3][TYPE_TEST   ]
-0	0	+1	# table_execute_type   [3][TYPE_MUL_DIV]
+0	0	+1	# table_execute_type   [3][TYPE_MUL    ]
+0	0	+1	# table_execute_type   [3][TYPE_DIV    ]
 1	1	+1	# table_execute_type   [3][TYPE_EXTEND ]
 1	1	+1	# table_execute_type   [3][TYPE_FIND   ]
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_multi_execute-multi_thread.cfg
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_multi_execute-multi_thread.cfg	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_multi_execute-multi_thread.cfg	(revision 88)
@@ -1,5 +1,12 @@
 Read_unit_to_Execution_unit
 3	3 	*2	# nb_read_unit           
+1	1 	+1	# nb_read_unit_port    [0] [nb_read_unit]
+1	1 	+1	# nb_read_unit_port    [1] [nb_read_unit]
+1	1 	+1	# nb_read_unit_port    [2] [nb_read_unit]
 4	4 	*2	# nb_execute_unit        
+1	1 	+1	# nb_execute_unit_port [0] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [1] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [2] [nb_execute_unit]
+1	1 	+1	# nb_execute_unit_port [3] [nb_execute_unit]
 4	4	*2	# nb_context             
 1	1	*2	# nb_front_end           
@@ -13,21 +20,22 @@
 4	4	*2	# size_load_queue        
 0	1	+1	# priority
-1	1	+1	# table_routing        [0][0]
-0	0	+1	# table_routing        [0][1]
-0	0	+1	# table_routing        [0][2]
-0	0	+1	# table_routing        [0][3]
-0 	0	+1	# table_routing        [1][0]
-1	1	+1	# table_routing        [1][1]
-1	1	+1	# table_routing        [1][2]
-0	0	+1	# table_routing        [1][3]
-0	0	+1	# table_routing        [2][0]
-0	0	+1	# table_routing        [2][1]
-1	1	+1	# table_routing        [2][2]
-1	1	+1	# table_routing        [2][3]
+1	1	+1	# table_routing        [0][0][0]
+0	0	+1	# table_routing        [0][1][0]
+0	0	+1	# table_routing        [0][2][0]
+0	0	+1	# table_routing        [0][3][0]
+0 	0	+1	# table_routing        [1][0][0]
+1	1	+1	# table_routing        [1][1][0]
+1	1	+1	# table_routing        [1][2][0]
+0	0	+1	# table_routing        [1][3][0]
+0	0	+1	# table_routing        [2][0][0]
+0	0	+1	# table_routing        [2][1][0]
+1	1	+1	# table_routing        [2][2][0]
+1	1	+1	# table_routing        [2][3][0]
 0	0	+1	# table_execute_type   [0][TYPE_ALU    ]
 0	0	+1	# table_execute_type   [0][TYPE_SHIFT  ]
 0	0	+1	# table_execute_type   [0][TYPE_MOVE   ]
 0	0	+1	# table_execute_type   [0][TYPE_TEST   ]
-0	0	+1	# table_execute_type   [0][TYPE_MUL_DIV]
+0	0	+1	# table_execute_type   [0][TYPE_MUL    ]
+0	0	+1	# table_execute_type   [0][TYPE_DIV    ]
 0	0	+1	# table_execute_type   [0][TYPE_EXTEND ]
 0	0	+1	# table_execute_type   [0][TYPE_FIND   ]
@@ -40,5 +48,6 @@
 1	1	+1	# table_execute_type   [1][TYPE_MOVE   ]
 1	1	+1	# table_execute_type   [1][TYPE_TEST   ]
-1	1	+1	# table_execute_type   [1][TYPE_MUL_DIV]
+1	1	+1	# table_execute_type   [1][TYPE_MUL    ]
+1	1	+1	# table_execute_type   [1][TYPE_DIV    ]
 1	1	+1	# table_execute_type   [1][TYPE_EXTEND ]
 1	1	+1	# table_execute_type   [1][TYPE_FIND   ]
@@ -51,5 +60,6 @@
 0	0	+1	# table_execute_type   [2][TYPE_MOVE   ]
 0	0	+1	# table_execute_type   [2][TYPE_TEST   ]
-0	0	+1	# table_execute_type   [2][TYPE_MUL_DIV]
+0	0	+1	# table_execute_type   [2][TYPE_MUL    ]
+0	0	+1	# table_execute_type   [2][TYPE_DIV    ]
 0	0	+1	# table_execute_type   [2][TYPE_EXTEND ]
 0	0	+1	# table_execute_type   [2][TYPE_FIND   ]
@@ -62,5 +72,6 @@
 1	1	+1	# table_execute_type   [3][TYPE_MOVE   ]
 1	1	+1	# table_execute_type   [3][TYPE_TEST   ]
-1	1	+1	# table_execute_type   [3][TYPE_MUL_DIV]
+1	1	+1	# table_execute_type   [3][TYPE_MUL    ]
+1	1	+1	# table_execute_type   [3][TYPE_DIV    ]
 0	0	+1	# table_execute_type   [3][TYPE_EXTEND ]
 0	0	+1	# table_execute_type   [3][TYPE_FIND   ]
@@ -84,3 +95,3 @@
 0	0	+1	# table_execute_thread [3][1]
 0	0	+1	# table_execute_thread [3][2]
-1	1	+1	# table_execute_thread [3][3]
+1	1	+1	# table_execute_thread [3][3]	
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/src/main.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/src/main.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/src/main.cpp	(revision 88)
@@ -15,5 +15,7 @@
   err (_("list_params is :\n"));
   err (_("  * nb_read_unit                                         (uint32_t)\n"));
+  err (_("  * nb_read_unit_port    [nb_read_unit]                  (uint32_t)\n"));
   err (_("  * nb_execute_unit                                      (uint32_t)\n"));
+  err (_("  * nb_execute_unit_port [nb_execute_unit]               (uint32_t)\n"));
   err (_("  * nb_context                                           (uint32_t)\n"));
   err (_("  * nb_front_end                                         (uint32_t)\n"));
@@ -33,5 +35,6 @@
   err (_("    * [TYPE_MOVE   ]\n"));
   err (_("    * [TYPE_TEST   ]\n"));
-  err (_("    * [TYPE_MUL_DIV]\n"));
+  err (_("    * [TYPE_MUL    ]\n"));
+  err (_("    * [TYPE_DIV    ]\n"));
   err (_("    * [TYPE_EXTEND ]\n"));
   err (_("    * [TYPE_FIND   ]\n"));
@@ -58,5 +61,25 @@
   string      name                  =      argv[x++];
   uint32_t    _nb_read_unit         = atoi(argv[x++]);
+
+  if (static_cast<uint32_t>(argc) < 2+NB_PARAMS+_nb_read_unit)
+    usage (argc, argv);
+
+  uint32_t *  _nb_read_unit_port = new uint32_t [_nb_read_unit];
+  for (uint32_t i=0; i<_nb_read_unit; i++)
+    _nb_read_unit_port [i] = atoi(argv[x++]);
+  
   uint32_t    _nb_execute_unit      = atoi(argv[x++]);
+
+  if (static_cast<uint32_t>(argc) < 2+NB_PARAMS+_nb_read_unit+_nb_execute_unit)
+    usage (argc, argv);
+
+  uint32_t    _sum_execute_unit_port = 0;
+  uint32_t *  _nb_execute_unit_port = new uint32_t [_nb_execute_unit];
+  for (uint32_t i=0; i<_nb_execute_unit; i++)
+    {
+      _nb_execute_unit_port [i] = atoi(argv[x++]);
+      _sum_execute_unit_port += _nb_execute_unit_port [i];
+    }
+
   uint32_t    _nb_context           = atoi(argv[x++]);
   uint32_t    _nb_front_end         = atoi(argv[x++]);
@@ -70,22 +93,30 @@
   uint32_t    _size_load_queue      = atoi(argv[x++]);
   Tpriority_t _priority             = fromString<Tpriority_t>(argv[x++]);
-
+  
   uint32_t    _nb_thread            = get_nb_thread(_nb_context, _nb_front_end, _nb_ooo_engine);
 
-  if (static_cast<uint32_t>(argc) != 2+NB_PARAMS+(_nb_read_unit*_nb_execute_unit)+(_nb_execute_unit*11)+(_nb_execute_unit*_nb_thread))
-    usage (argc, argv);
-  
-  bool ** _table_routing        ;
-  bool ** _table_execute_type   ;
-  bool ** _table_execute_thread ;
-  
-  _table_routing = new bool * [_nb_read_unit];
+  msg("%d\n",argc);
+  msg("%d\n",2+NB_PARAMS+(_nb_read_unit+_nb_execute_unit+(_nb_read_unit*_sum_execute_unit_port)+(_nb_execute_unit*12)+(_nb_execute_unit*_nb_thread)));
+  
+  if (static_cast<uint32_t>(argc) != 2+NB_PARAMS+(_nb_read_unit+_nb_execute_unit+(_nb_read_unit*_sum_execute_unit_port)+(_nb_execute_unit*12)+(_nb_execute_unit*_nb_thread)))
+      usage (argc, argv);
+  
+  bool *** _table_routing        ;
+  bool  ** _table_execute_type   ;
+  bool  ** _table_execute_thread ;
+  
+  _table_routing = new bool ** [_nb_read_unit];
   for (uint32_t i=0; i<_nb_read_unit; i++)
     {
-      _table_routing [i] = new bool [_nb_execute_unit];
+      _table_routing [i] = new bool * [_nb_execute_unit];
       for (uint32_t j=0; j<_nb_execute_unit; j++)
-	_table_routing [i][j] = atoi(argv[x++]);
-    }
-
+	{
+	  _table_routing [i][j] = new bool [_nb_execute_unit_port [j]];
+      
+	  for (uint32_t k=0; k<_nb_execute_unit_port [j]; k++)
+	    _table_routing [i][j][k] = atoi(argv[x++]);
+	}
+    }
+      
   _table_execute_type = new bool * [_nb_execute_unit];
   for (uint32_t i=0; i<_nb_execute_unit; i++)
@@ -97,5 +128,6 @@
       _table_execute_type [i][TYPE_MOVE   ] = atoi(argv[x++]);
       _table_execute_type [i][TYPE_TEST   ] = atoi(argv[x++]);
-      _table_execute_type [i][TYPE_MUL_DIV] = atoi(argv[x++]);
+      _table_execute_type [i][TYPE_MUL    ] = atoi(argv[x++]);
+      _table_execute_type [i][TYPE_DIV    ] = atoi(argv[x++]);
       _table_execute_type [i][TYPE_EXTEND ] = atoi(argv[x++]);
       _table_execute_type [i][TYPE_FIND   ] = atoi(argv[x++]);
@@ -119,5 +151,7 @@
       morpheo::behavioural::core::multi_execute_loop::execute_loop::network::read_unit_to_execution_unit::Parameters * param = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::read_unit_to_execution_unit::Parameters
 	(_nb_read_unit         ,
+	 _nb_read_unit_port    ,
 	 _nb_execute_unit      ,
+	 _nb_execute_unit_port ,
 	 _nb_context           ,
 	 _nb_front_end         ,
@@ -133,5 +167,6 @@
 	 _table_routing        ,
 	 _table_execute_type   ,
-	 _table_execute_thread 
+	 _table_execute_thread ,
+         true // is_toplevel
 	 );
       
@@ -151,7 +186,24 @@
     }
 
-  delete [] _table_routing        ;
+  delete [] _nb_read_unit_port;
+  delete [] _nb_execute_unit_port ;
+
+  for (uint32_t i=0; i<_nb_read_unit; i++)
+    {
+      for (uint32_t j=0; j<_nb_execute_unit; j++)
+	delete [] _table_routing [i][j];
+      delete [] _table_routing [i];
+    }
+  delete [] _table_routing;
+
+
+  for (uint32_t i=0; i<_nb_execute_unit; i++)
+    delete [] _table_execute_type [i];
   delete [] _table_execute_type   ;
+
+  for (uint32_t i=0; i<_nb_execute_unit; i++)
+    delete [] _table_execute_thread [i];
   delete [] _table_execute_thread ;
+
 
   return (EXIT_SUCCESS);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/src/test.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/src/test.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/src/test.cpp	(revision 88)
@@ -84,4 +84,14 @@
 #endif
 
+  Tusage_t _usage = USE_ALL;
+
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
+
   Read_unit_to_Execution_unit * _Read_unit_to_Execution_unit = new Read_unit_to_Execution_unit 
     (name.c_str(),
@@ -90,5 +100,5 @@
 #endif
      _param,
-     USE_ALL);
+     _usage);
   
 #ifdef SYSTEMC
@@ -101,42 +111,42 @@
   sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
 
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_VAL                  ," in_READ_UNIT_OUT_VAL"                  ,Tcontrol_t        ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL(out_READ_UNIT_OUT_ACK                  ,"out_READ_UNIT_OUT_ACK"                  ,Tcontrol_t        ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_CONTEXT_ID           ," in_READ_UNIT_OUT_CONTEXT_ID"           ,Tcontext_t        ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_FRONT_END_ID         ," in_READ_UNIT_OUT_FRONT_END_ID"         ,Tcontext_t        ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_OOO_ENGINE_ID        ," in_READ_UNIT_OUT_OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_PACKET_ID            ," in_READ_UNIT_OUT_PACKET_ID"            ,Tpacket_t         ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_OPERATION            ," in_READ_UNIT_OUT_OPERATION"            ,Toperation_t      ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_TYPE                 ," in_READ_UNIT_OUT_TYPE"                 ,Ttype_t           ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE," in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ," in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_HAS_IMMEDIAT         ," in_READ_UNIT_OUT_HAS_IMMEDIAT"         ,Tcontrol_t        ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_IMMEDIAT             ," in_READ_UNIT_OUT_IMMEDIAT"             ,Tgeneral_data_t   ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RA              ," in_READ_UNIT_OUT_DATA_RA"              ,Tgeneral_data_t   ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RB              ," in_READ_UNIT_OUT_DATA_RB"              ,Tgeneral_data_t   ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RC              ," in_READ_UNIT_OUT_DATA_RC"              ,Tspecial_data_t   ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RD             ," in_READ_UNIT_OUT_WRITE_RD"             ,Tcontrol_t        ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RD           ," in_READ_UNIT_OUT_NUM_REG_RD"           ,Tgeneral_address_t,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RE             ," in_READ_UNIT_OUT_WRITE_RE"             ,Tcontrol_t        ,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RE           ," in_READ_UNIT_OUT_NUM_REG_RE"           ,Tspecial_address_t,_param->_nb_read_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_VAL                  ,"out_EXECUTE_UNIT_IN_VAL"                  ,Tcontrol_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_IN_ACK                  ," in_EXECUTE_UNIT_IN_ACK"                  ,Tcontrol_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,"out_EXECUTE_UNIT_IN_CONTEXT_ID"           ,Tcontext_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,"out_EXECUTE_UNIT_IN_FRONT_END_ID"         ,Tcontext_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,"out_EXECUTE_UNIT_IN_OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_PACKET_ID            ,"out_EXECUTE_UNIT_IN_PACKET_ID"            ,Tpacket_t         ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_OPERATION            ,"out_EXECUTE_UNIT_IN_OPERATION"            ,Toperation_t      ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_TYPE                 ,"out_EXECUTE_UNIT_IN_TYPE"                 ,Ttype_t           ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,"out_EXECUTE_UNIT_IN_HAS_IMMEDIAT"         ,Tcontrol_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_IMMEDIAT             ,"out_EXECUTE_UNIT_IN_IMMEDIAT"             ,Tgeneral_data_t   ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RA              ,"out_EXECUTE_UNIT_IN_DATA_RA"              ,Tgeneral_data_t   ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RB              ,"out_EXECUTE_UNIT_IN_DATA_RB"              ,Tgeneral_data_t   ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RC              ,"out_EXECUTE_UNIT_IN_DATA_RC"              ,Tspecial_data_t   ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RD             ,"out_EXECUTE_UNIT_IN_WRITE_RD"             ,Tcontrol_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"out_EXECUTE_UNIT_IN_NUM_REG_RD"           ,Tgeneral_address_t,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RE             ,"out_EXECUTE_UNIT_IN_WRITE_RE"             ,Tcontrol_t        ,_param->_nb_execute_unit);
-  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"out_EXECUTE_UNIT_IN_NUM_REG_RE"           ,Tspecial_address_t,_param->_nb_execute_unit);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_VAL                  ," in_READ_UNIT_OUT_VAL"                  ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_READ_UNIT_OUT_ACK                  ,"out_READ_UNIT_OUT_ACK"                  ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_CONTEXT_ID           ," in_READ_UNIT_OUT_CONTEXT_ID"           ,Tcontext_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_FRONT_END_ID         ," in_READ_UNIT_OUT_FRONT_END_ID"         ,Tcontext_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_OOO_ENGINE_ID        ," in_READ_UNIT_OUT_OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_PACKET_ID            ," in_READ_UNIT_OUT_PACKET_ID"            ,Tpacket_t         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_OPERATION            ," in_READ_UNIT_OUT_OPERATION"            ,Toperation_t      ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_TYPE                 ," in_READ_UNIT_OUT_TYPE"                 ,Ttype_t           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE," in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ," in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_HAS_IMMEDIAT         ," in_READ_UNIT_OUT_HAS_IMMEDIAT"         ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_IMMEDIAT             ," in_READ_UNIT_OUT_IMMEDIAT"             ,Tgeneral_data_t   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RA              ," in_READ_UNIT_OUT_DATA_RA"              ,Tgeneral_data_t   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RB              ," in_READ_UNIT_OUT_DATA_RB"              ,Tgeneral_data_t   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RC              ," in_READ_UNIT_OUT_DATA_RC"              ,Tspecial_data_t   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RD             ," in_READ_UNIT_OUT_WRITE_RD"             ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RD           ," in_READ_UNIT_OUT_NUM_REG_RD"           ,Tgeneral_address_t,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RE             ," in_READ_UNIT_OUT_WRITE_RE"             ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RE           ," in_READ_UNIT_OUT_NUM_REG_RE"           ,Tspecial_address_t,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_VAL                  ,"out_EXECUTE_UNIT_IN_VAL"                  ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_IN_ACK                  ," in_EXECUTE_UNIT_IN_ACK"                  ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,"out_EXECUTE_UNIT_IN_CONTEXT_ID"           ,Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,"out_EXECUTE_UNIT_IN_FRONT_END_ID"         ,Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,"out_EXECUTE_UNIT_IN_OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_PACKET_ID            ,"out_EXECUTE_UNIT_IN_PACKET_ID"            ,Tpacket_t         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_OPERATION            ,"out_EXECUTE_UNIT_IN_OPERATION"            ,Toperation_t      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_TYPE                 ,"out_EXECUTE_UNIT_IN_TYPE"                 ,Ttype_t           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,"out_EXECUTE_UNIT_IN_HAS_IMMEDIAT"         ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_IMMEDIAT             ,"out_EXECUTE_UNIT_IN_IMMEDIAT"             ,Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RA              ,"out_EXECUTE_UNIT_IN_DATA_RA"              ,Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RB              ,"out_EXECUTE_UNIT_IN_DATA_RB"              ,Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RC              ,"out_EXECUTE_UNIT_IN_DATA_RC"              ,Tspecial_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RD             ,"out_EXECUTE_UNIT_IN_WRITE_RD"             ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"out_EXECUTE_UNIT_IN_NUM_REG_RD"           ,Tgeneral_address_t,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RE             ,"out_EXECUTE_UNIT_IN_WRITE_RE"             ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"out_EXECUTE_UNIT_IN_NUM_REG_RE"           ,Tspecial_address_t,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   
   
@@ -150,53 +160,53 @@
   (*(_Read_unit_to_Execution_unit->in_NRESET))       (*(in_NRESET));
 
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_VAL                  ,_param->_nb_read_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_READ_UNIT_OUT_ACK                  ,_param->_nb_read_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_VAL                  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_READ_UNIT_OUT_ACK                  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
   if (_param->_have_port_context_id)
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_CONTEXT_ID           ,_param->_nb_read_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_CONTEXT_ID           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
   if (_param->_have_port_front_end_id)
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_FRONT_END_ID         ,_param->_nb_read_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_FRONT_END_ID         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
   if (_param->_have_port_ooo_engine_id)
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_OOO_ENGINE_ID        ,_param->_nb_read_unit);
-  if (_param->_have_port_packet_id)
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_PACKET_ID            ,_param->_nb_read_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_OPERATION            ,_param->_nb_read_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_TYPE                 ,_param->_nb_read_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,_param->_nb_read_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_OOO_ENGINE_ID        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  if (_param->_have_port_rob_ptr  )
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_PACKET_ID            ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_OPERATION            ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_TYPE                 ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
   if (_param->_have_port_load_queue_ptr)
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,_param->_nb_read_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_HAS_IMMEDIAT         ,_param->_nb_read_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_IMMEDIAT             ,_param->_nb_read_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RA              ,_param->_nb_read_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RB              ,_param->_nb_read_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RC              ,_param->_nb_read_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_WRITE_RD             ,_param->_nb_read_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_NUM_REG_RD           ,_param->_nb_read_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_WRITE_RE             ,_param->_nb_read_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_NUM_REG_RE           ,_param->_nb_read_unit);
-
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_VAL                  ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_EXECUTE_UNIT_IN_ACK                  ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_HAS_IMMEDIAT         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_IMMEDIAT             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RA              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RB              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RC              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_WRITE_RD             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_NUM_REG_RD           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_WRITE_RE             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_NUM_REG_RE           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_VAL                  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_EXECUTE_UNIT_IN_ACK                  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_context_id)
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_CONTEXT_ID           ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_CONTEXT_ID           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_front_end_id)
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_FRONT_END_ID         ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_FRONT_END_ID         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_ooo_engine_id)
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,_param->_nb_execute_unit);
-  if (_param->_have_port_packet_id)
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_PACKET_ID            ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_OPERATION            ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_TYPE                 ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  if (_param->_have_port_rob_ptr  )
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_PACKET_ID            ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_OPERATION            ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_TYPE                 ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_load_queue_ptr)
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_IMMEDIAT             ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RA              ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RB              ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RC              ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_WRITE_RD             ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_NUM_REG_RD           ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_WRITE_RE             ,_param->_nb_execute_unit);
-  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_NUM_REG_RE           ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_IMMEDIAT             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RA              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RB              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RC              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_WRITE_RD             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_NUM_REG_RD           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_WRITE_RE             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_NUM_REG_RE           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
 
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
@@ -222,15 +232,16 @@
  
   for (uint32_t i=0; i<_param->_nb_read_unit; i++)
-    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-      if (_param->_table_routing[i][j])
-	for (uint32_t k=0; k<_param->_nb_thread; k++)
-	  if (_param->_table_execute_thread[j][k])
-	    {
-	      read_unit_thread [i].insert(k);
-	      
-	      for (uint32_t l=0; l<_param->_nb_type; l++)
-		if (_param->_table_execute_type[j][l])
-		  read_unit_type [i][k].insert(l);
-	    }
+    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	if (_param->_table_routing[i][x][y])
+	  for (uint32_t k=0; k<_param->_nb_thread; k++)
+	    if (_param->_table_execute_thread[x][k])
+	      {
+		read_unit_thread [i].insert(k);
+		
+		for (uint32_t l=0; l<_param->_nb_type; l++)
+		  if (_param->_table_execute_type[x][l])
+		    read_unit_type [i][k].insert(l);
+	      }
   //bool ** _table_routing       ; //array [nb_read_unit][nb_execute_unit]
   //bool ** _table_execute_type  ; //array [nb_execute_unit][nb_type]
@@ -251,60 +262,61 @@
       LABEL("Iteration %d",iteration);
 
-      list<entry_t> request [_param->_nb_read_unit];
+      list<entry_t> request [_param->_nb_read_unit][_param->_max_nb_read_unit_port];
 
       uint32_t nb_request_in;
       for (nb_request_in=0; nb_request_in < _param->_nb_packet; )
 	for (uint32_t i=0; i<_param->_nb_read_unit; i++)
-	  {
-	    if (nb_request_in >= _param->_nb_packet)
-	      break;
-
-	    Tcontext_t context_id   ;
-	    Tcontext_t front_end_id ;
-	    Tcontext_t ooo_engine_id;
-	    Tcontext_t num_thread   ;
-
-	    // Find compatible thread
-	    do
-	      {
-		context_id    = range<Tcontext_t> (rand(), _param->_size_context_id   );
-		front_end_id  = range<Tcontext_t> (rand(), _param->_size_front_end_id );
-		ooo_engine_id = range<Tcontext_t> (rand(), _param->_size_ooo_engine_id);
-		num_thread    = get_num_thread (context_id   , _param->_size_context_id   ,
-						front_end_id , _param->_size_front_end_id ,
-						ooo_engine_id, _param->_size_ooo_engine_id);
-	      }
-	    while (read_unit_thread[i].find(num_thread) == read_unit_thread[i].end());
-
-	    Ttype_t    type;
-	    
-	    // Find a compatible type
-	    do
-	      {
-		type = range<Ttype_t> (rand(), _param->_size_type);
-	      }
-	    while (read_unit_type[i][num_thread].find(type) == read_unit_type[i][num_thread].end());
-
-	    request[i].push_back(entry_t (context_id   ,
-					  front_end_id ,
-					  ooo_engine_id,
-					  nb_request_in,
-					  range<Toperation_t      > (rand(), _param->_size_operation       ),
-					  type,
-					  range<Tlsq_ptr_t        > (rand(), _param->_size_store_queue     ),
-					  range<Tlsq_ptr_t        > (rand(), _param->_size_load_queue      ),
-					  range<Tcontrol_t        > (rand(), 2                             ),
-					  range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
-					  range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
-					  range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
-					  range<Tspecial_data_t   > (rand(), _param->_size_special_data    ),
-					  range<Tcontrol_t        > (rand(), 2                             ),
-					  range<Tgeneral_address_t> (rand(), _param->_size_general_register),
-					  range<Tcontrol_t        > (rand(), 2                             ),
-					  range<Tspecial_address_t> (rand(), _param->_size_special_register)
-					  ));
-
-	    nb_request_in++;
-	  }
+	  for (uint32_t j=0; j<_param->_nb_read_unit_port [i]; j++)
+	    {
+	      if (nb_request_in >= _param->_nb_packet)
+		break;
+	      
+	      Tcontext_t context_id   ;
+	      Tcontext_t front_end_id ;
+	      Tcontext_t ooo_engine_id;
+	      Tcontext_t num_thread   ;
+	      
+	      // Find compatible thread
+	      do
+		{
+		  context_id    = range<Tcontext_t> (rand(), _param->_size_context_id   );
+		  front_end_id  = range<Tcontext_t> (rand(), _param->_size_front_end_id );
+		  ooo_engine_id = range<Tcontext_t> (rand(), _param->_size_ooo_engine_id);
+		  num_thread    = get_num_thread (context_id   , _param->_size_context_id   ,
+						  front_end_id , _param->_size_front_end_id ,
+						  ooo_engine_id, _param->_size_ooo_engine_id);
+		}
+	      while (read_unit_thread[i].find(num_thread) == read_unit_thread[i].end());
+	      
+	      Ttype_t    type;
+	      
+	      // Find a compatible type
+	      do
+		{
+		  type = range<Ttype_t> (rand(), _param->_size_type);
+		}
+	      while (read_unit_type[i][num_thread].find(type) == read_unit_type[i][num_thread].end());
+	      
+	      request[i][j].push_back(entry_t (context_id   ,
+					       front_end_id ,
+					       ooo_engine_id,
+					       nb_request_in,
+					       range<Toperation_t      > (rand(), _param->_size_operation       ),
+					       type,
+					       range<Tlsq_ptr_t        > (rand(), (1<<_param->_size_store_queue_ptr)),
+					       range<Tlsq_ptr_t        > (rand(), (1<<_param->_size_load_queue_ptr )),
+					       range<Tcontrol_t        > (rand(), 2                             ),
+					       range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
+					       range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
+					       range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
+					       range<Tspecial_data_t   > (rand(), _param->_size_special_data    ),
+					       range<Tcontrol_t        > (rand(), 2                             ),
+					       range<Tgeneral_address_t> (rand(), _param->_size_general_register),
+					       range<Tcontrol_t        > (rand(), 2                             ),
+					       range<Tspecial_address_t> (rand(), _param->_size_special_register)
+					       ));
+	      
+	      nb_request_in++;
+	    }
 
       uint32_t   nb_request_out = 0;
@@ -313,92 +325,105 @@
 	{
 	  for (uint32_t i=0; i<_param->_nb_read_unit; i++)
-	    {
-	      bool val = not request[i].empty() and ((rand()%100) < percent_transaction_in);
+	    for (uint32_t j=0; j<_param->_nb_read_unit_port [i]; j++)
+	      {
+		bool val = not request[i][j].empty() and ((rand()%100) < percent_transaction_in);
 		
-	      in_READ_UNIT_OUT_VAL [i]->write(val);
-
-	      if (val)
+		in_READ_UNIT_OUT_VAL [i][j]->write(val);
+		
+		if (val)
 		{
-		  in_READ_UNIT_OUT_CONTEXT_ID           [i] ->write(request[i].front()._context_id           );
-		  in_READ_UNIT_OUT_FRONT_END_ID         [i] ->write(request[i].front()._front_end_id         );
-		  in_READ_UNIT_OUT_OOO_ENGINE_ID        [i] ->write(request[i].front()._ooo_engine_id        );
-		  in_READ_UNIT_OUT_PACKET_ID            [i] ->write(request[i].front()._packet_id            );
-		  in_READ_UNIT_OUT_OPERATION            [i] ->write(request[i].front()._operation            );
-		  in_READ_UNIT_OUT_TYPE                 [i] ->write(request[i].front()._type                 );
-		  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE[i] ->write(request[i].front()._store_queue_ptr_write);
+		  in_READ_UNIT_OUT_CONTEXT_ID           [i][j] ->write(request[i][j].front()._context_id           );
+		  in_READ_UNIT_OUT_FRONT_END_ID         [i][j] ->write(request[i][j].front()._front_end_id         );
+		  in_READ_UNIT_OUT_OOO_ENGINE_ID        [i][j] ->write(request[i][j].front()._ooo_engine_id        );
+		  in_READ_UNIT_OUT_PACKET_ID            [i][j] ->write(request[i][j].front()._packet_id            );
+		  in_READ_UNIT_OUT_OPERATION            [i][j] ->write(request[i][j].front()._operation            );
+		  in_READ_UNIT_OUT_TYPE                 [i][j] ->write(request[i][j].front()._type                 );
+		  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE[i][j] ->write(request[i][j].front()._store_queue_ptr_write);
 		  if (_param->_have_port_load_queue_ptr)
-		  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE [i] ->write(request[i].front()._load_queue_ptr_write );
-		  in_READ_UNIT_OUT_HAS_IMMEDIAT         [i] ->write(request[i].front()._has_immediat         );
-		  in_READ_UNIT_OUT_IMMEDIAT             [i] ->write(request[i].front()._immediat             );
-		  in_READ_UNIT_OUT_DATA_RA              [i] ->write(request[i].front()._data_ra              );
-		  in_READ_UNIT_OUT_DATA_RB              [i] ->write(request[i].front()._data_rb              );
-		  in_READ_UNIT_OUT_DATA_RC              [i] ->write(request[i].front()._data_rc              );
-		  in_READ_UNIT_OUT_WRITE_RD             [i] ->write(request[i].front()._write_rd             );
-		  in_READ_UNIT_OUT_NUM_REG_RD           [i] ->write(request[i].front()._num_reg_rd           );
-		  in_READ_UNIT_OUT_WRITE_RE             [i] ->write(request[i].front()._write_re             );
-		  in_READ_UNIT_OUT_NUM_REG_RE           [i] ->write(request[i].front()._num_reg_re           );
+		  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE [i][j] ->write(request[i][j].front()._load_queue_ptr_write );
+		  in_READ_UNIT_OUT_HAS_IMMEDIAT         [i][j] ->write(request[i][j].front()._has_immediat         );
+		  in_READ_UNIT_OUT_IMMEDIAT             [i][j] ->write(request[i][j].front()._immediat             );
+		  in_READ_UNIT_OUT_DATA_RA              [i][j] ->write(request[i][j].front()._data_ra              );
+		  in_READ_UNIT_OUT_DATA_RB              [i][j] ->write(request[i][j].front()._data_rb              );
+		  in_READ_UNIT_OUT_DATA_RC              [i][j] ->write(request[i][j].front()._data_rc              );
+		  in_READ_UNIT_OUT_WRITE_RD             [i][j] ->write(request[i][j].front()._write_rd             );
+		  in_READ_UNIT_OUT_NUM_REG_RD           [i][j] ->write(request[i][j].front()._num_reg_rd           );
+		  in_READ_UNIT_OUT_WRITE_RE             [i][j] ->write(request[i][j].front()._write_re             );
+		  in_READ_UNIT_OUT_NUM_REG_RE           [i][j] ->write(request[i][j].front()._num_reg_re           );
 		}
-	    }
+	      }
 
 	  for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-	    in_EXECUTE_UNIT_IN_ACK [i]->write((rand()%100) < percent_transaction_out);
+	    for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+	      in_EXECUTE_UNIT_IN_ACK [i][j]->write((rand()%100) < percent_transaction_out);
 
 	  SC_START(0);
 
 	  for (uint32_t i=0; i<_param->_nb_read_unit; i++)
-	    if (in_READ_UNIT_OUT_VAL [i]->read() and out_READ_UNIT_OUT_ACK [i]->read())
-	      {
-		LABEL("READ_UNIT_OUT   [%d] - Transaction accepted",i);
-	      }
+	    for (uint32_t j=0; j<_param->_nb_read_unit_port [i]; j++)
+	      if (in_READ_UNIT_OUT_VAL [i][j]->read() and out_READ_UNIT_OUT_ACK [i][j]->read())
+		{
+		  LABEL("READ_UNIT_OUT   [%d][%d] - Transaction accepted",i,j);
+		}
 
 	  for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-	    if (out_EXECUTE_UNIT_IN_VAL [i]->read() and in_EXECUTE_UNIT_IN_ACK [i]->read())
-	      {
-		LABEL("EXECUTE_UNIT_IN [%d] - Transaction accepted (%d)",i,nb_request_out);
-		nb_request_out ++;
-		
-		Tpacket_t packet = (_param->_have_port_packet_id)?out_EXECUTE_UNIT_IN_PACKET_ID[i]->read():0;
-		LABEL("  * packet           : %d",packet);		
-		uint32_t read_unit;
-
-		// find read_unit
-		for (read_unit=0; read_unit<_param->_nb_read_unit; read_unit++)
-		  if (packet == ((_param->_have_port_packet_id)?request[read_unit].front()._packet_id:0))
-		    break;
-
-		LABEL("  * read_unit source : %d",read_unit);
-
-		if (_param->_have_port_packet_id)
-		TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_PACKET_ID            [i]->read(), request[read_unit].front()._packet_id            );
-
-		// Authorised link ? read_unit -> execute_unit
-		TEST(bool, _param->_table_routing[read_unit][i], true);
-
-		if (_param->_have_port_context_id)
-		TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_CONTEXT_ID           [i]->read(), request[read_unit].front()._context_id           );
-		if (_param->_have_port_front_end_id)
-		TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_FRONT_END_ID         [i]->read(), request[read_unit].front()._front_end_id         );
-		if (_param->_have_port_ooo_engine_id)
-		TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        [i]->read(), request[read_unit].front()._ooo_engine_id        );
-		TEST(Toperation_t      ,out_EXECUTE_UNIT_IN_OPERATION            [i]->read(), request[read_unit].front()._operation            );
-		TEST(Ttype_t           ,out_EXECUTE_UNIT_IN_TYPE                 [i]->read(), request[read_unit].front()._type                 );
-		TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE[i]->read(), request[read_unit].front()._store_queue_ptr_write);
-		if (_param->_have_port_load_queue_ptr)
-		TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i]->read(), request[read_unit].front()._load_queue_ptr_write );
-		TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         [i]->read(), request[read_unit].front()._has_immediat         );
-		TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_IMMEDIAT             [i]->read(), request[read_unit].front()._immediat             );
-		TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_DATA_RA              [i]->read(), request[read_unit].front()._data_ra              );
-		TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_DATA_RB              [i]->read(), request[read_unit].front()._data_rb              );
-		TEST(Tspecial_data_t   ,out_EXECUTE_UNIT_IN_DATA_RC              [i]->read(), request[read_unit].front()._data_rc              );
-		TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_WRITE_RD             [i]->read(), request[read_unit].front()._write_rd             );
-		TEST(Tgeneral_address_t,out_EXECUTE_UNIT_IN_NUM_REG_RD           [i]->read(), request[read_unit].front()._num_reg_rd           );
-		TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_WRITE_RE             [i]->read(), request[read_unit].front()._write_re             );
-		TEST(Tspecial_address_t,out_EXECUTE_UNIT_IN_NUM_REG_RE           [i]->read(), request[read_unit].front()._num_reg_re           );
-		
-		request[read_unit].pop_front();
-	      }
+	    for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+	      if (out_EXECUTE_UNIT_IN_VAL [i][j]->read() and in_EXECUTE_UNIT_IN_ACK [i][j]->read())
+		{
+		  LABEL("EXECUTE_UNIT_IN [%d][%d] - Transaction accepted (%d)",i,j,nb_request_out);
+		  nb_request_out ++;
+		  
+		  Tpacket_t packet = (_param->_have_port_rob_ptr  )?out_EXECUTE_UNIT_IN_PACKET_ID[i][j]->read():0;
+		  LABEL("  * packet           : %d",packet);		
+		  uint32_t x;
+		  uint32_t y;
+
+		  // find read_unit
+		  bool find = false;
+		  for (x=0; x<_param->_nb_read_unit; x++)
+		    {
+		      for (y=0; y<_param->_nb_read_unit_port[x]; y++)
+			if (packet == ((_param->_have_port_rob_ptr  )?request[x][y].front()._packet_id:0))
+			  {
+			    find = true;
+			    break;
+			  }
+		      if (find)
+			break;
+		    }
+		  
+		  LABEL("  * read_unit source : [%d][%d]",x,y);
+		  
+		  if (_param->_have_port_rob_ptr  )
+		  TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_PACKET_ID            [i][j]->read(), request[x][y].front()._packet_id            );
+
+		  // Authorised link ? read_unit -> execute_unit
+		  TEST(bool, _param->_table_routing[x][i][j], true);
+		  
+		  if (_param->_have_port_context_id)
+		  TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_CONTEXT_ID           [i][j]->read(), request[x][y].front()._context_id           );
+		  if (_param->_have_port_front_end_id)
+		  TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_FRONT_END_ID         [i][j]->read(), request[x][y].front()._front_end_id         );
+		  if (_param->_have_port_ooo_engine_id)
+		  TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        [i][j]->read(), request[x][y].front()._ooo_engine_id        );
+		  TEST(Toperation_t      ,out_EXECUTE_UNIT_IN_OPERATION            [i][j]->read(), request[x][y].front()._operation            );
+		  TEST(Ttype_t           ,out_EXECUTE_UNIT_IN_TYPE                 [i][j]->read(), request[x][y].front()._type                 );
+		  TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE[i][j]->read(), request[x][y].front()._store_queue_ptr_write);
+		  if (_param->_have_port_load_queue_ptr)
+		  TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j]->read(), request[x][y].front()._load_queue_ptr_write );
+		  TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         [i][j]->read(), request[x][y].front()._has_immediat         );
+		  TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_IMMEDIAT             [i][j]->read(), request[x][y].front()._immediat             );
+		  TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_DATA_RA              [i][j]->read(), request[x][y].front()._data_ra              );
+		  TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_DATA_RB              [i][j]->read(), request[x][y].front()._data_rb              );
+		  TEST(Tspecial_data_t   ,out_EXECUTE_UNIT_IN_DATA_RC              [i][j]->read(), request[x][y].front()._data_rc              );
+		  TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_WRITE_RD             [i][j]->read(), request[x][y].front()._write_rd             );
+		  TEST(Tgeneral_address_t,out_EXECUTE_UNIT_IN_NUM_REG_RD           [i][j]->read(), request[x][y].front()._num_reg_rd           );
+		  TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_WRITE_RE             [i][j]->read(), request[x][y].front()._write_re             );
+		  TEST(Tspecial_address_t,out_EXECUTE_UNIT_IN_NUM_REG_RE           [i][j]->read(), request[x][y].front()._num_reg_re           );
+		  
+		  request[x][y].pop_front();
+		}
 	  SC_START(1);
 	}
-
     }
 
@@ -414,44 +439,43 @@
   delete in_CLOCK;
   delete in_NRESET;
-  
-  delete []  in_READ_UNIT_OUT_VAL                  ;
-  delete [] out_READ_UNIT_OUT_ACK                  ;
-  delete []  in_READ_UNIT_OUT_CONTEXT_ID           ;
-  delete []  in_READ_UNIT_OUT_FRONT_END_ID         ;
-  delete []  in_READ_UNIT_OUT_OOO_ENGINE_ID        ;
-  delete []  in_READ_UNIT_OUT_PACKET_ID            ;
-  delete []  in_READ_UNIT_OUT_OPERATION            ;
-  delete []  in_READ_UNIT_OUT_TYPE                 ;
-  delete []  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE;
-  delete []  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ;
-  delete []  in_READ_UNIT_OUT_HAS_IMMEDIAT         ;
-  delete []  in_READ_UNIT_OUT_IMMEDIAT             ;
-  delete []  in_READ_UNIT_OUT_DATA_RA              ;
-  delete []  in_READ_UNIT_OUT_DATA_RB              ;
-  delete []  in_READ_UNIT_OUT_DATA_RC              ;
-  delete []  in_READ_UNIT_OUT_WRITE_RD             ;
-  delete []  in_READ_UNIT_OUT_NUM_REG_RD           ;
-  delete []  in_READ_UNIT_OUT_WRITE_RE             ;
-  delete []  in_READ_UNIT_OUT_NUM_REG_RE           ;
-
-  delete [] out_EXECUTE_UNIT_IN_VAL                  ;
-  delete []  in_EXECUTE_UNIT_IN_ACK                  ;
-  delete [] out_EXECUTE_UNIT_IN_CONTEXT_ID           ;
-  delete [] out_EXECUTE_UNIT_IN_FRONT_END_ID         ;
-  delete [] out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ;
-  delete [] out_EXECUTE_UNIT_IN_PACKET_ID            ;
-  delete [] out_EXECUTE_UNIT_IN_OPERATION            ;
-  delete [] out_EXECUTE_UNIT_IN_TYPE                 ;
-  delete [] out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE;
-  delete [] out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;
-  delete [] out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;
-  delete [] out_EXECUTE_UNIT_IN_IMMEDIAT             ;
-  delete [] out_EXECUTE_UNIT_IN_DATA_RA              ;
-  delete [] out_EXECUTE_UNIT_IN_DATA_RB              ;
-  delete [] out_EXECUTE_UNIT_IN_DATA_RC              ;
-  delete [] out_EXECUTE_UNIT_IN_WRITE_RD             ;
-  delete [] out_EXECUTE_UNIT_IN_NUM_REG_RD           ;
-  delete [] out_EXECUTE_UNIT_IN_WRITE_RE             ;
-  delete [] out_EXECUTE_UNIT_IN_NUM_REG_RE           ;
+
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_VAL                  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_READ_UNIT_OUT_ACK                  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_CONTEXT_ID           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_FRONT_END_ID         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_OOO_ENGINE_ID        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_PACKET_ID            ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_OPERATION            ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_TYPE                 ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_HAS_IMMEDIAT         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_IMMEDIAT             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RA              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RB              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RC              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RD             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RD           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RE             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RE           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_VAL                  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_IN_ACK                  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_PACKET_ID            ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_OPERATION            ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_TYPE                 ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_IMMEDIAT             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RA              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RB              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RC              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RD             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RE             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
 
 #endif
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Parameters.h
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Parameters.h	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Parameters.h	(revision 88)
@@ -26,41 +26,47 @@
   {
     //-----[ fields ]------------------------------------------------------------
-  public : const uint32_t    _nb_read_unit           ;
-  public : const uint32_t    _nb_execute_unit        ;
-  public : const uint32_t    _nb_context             ;
-  public : const uint32_t    _nb_front_end           ;
-  public : const uint32_t    _nb_ooo_engine          ;
-  public : const uint32_t    _nb_packet              ;
-  public : const uint32_t    _size_general_data      ;
-  public : const uint32_t    _size_special_data      ;
-  public : const uint32_t    _nb_general_register    ;
-  public : const uint32_t    _nb_special_register    ;
-  public : const uint32_t    _size_store_queue       ;
-  public : const uint32_t    _size_load_queue        ;
-  public : const Tpriority_t _priority               ;
-  public :       bool     ** _table_routing          ; //[nb_read_unit][nb_execute_unit]
-  public :       bool     ** _table_execute_type     ; //[nb_execute_unit][nb_type]
-  public :       bool     ** _table_execute_thread   ; //[nb_execute_unit][nb_thread]
+  public : uint32_t    _nb_read_unit           ;
+  public : uint32_t  * _nb_read_unit_port      ;//[nb_read_unit]
+  public : uint32_t    _nb_execute_unit        ;
+  public : uint32_t  * _nb_execute_unit_port   ;//[nb_execute_unit]
+  public : uint32_t    _nb_context             ;
+  public : uint32_t    _nb_front_end           ;
+  public : uint32_t    _nb_ooo_engine          ;
+  public : uint32_t    _nb_packet              ;
+//public : uint32_t    _size_general_data      ;
+//public : uint32_t    _size_special_data      ;
+  public : uint32_t    _nb_general_register    ;
+  public : uint32_t    _nb_special_register    ;
+//public : uint32_t    _size_store_queue       ;
+//public : uint32_t    _size_load_queue        ;
+  public : Tpriority_t _priority               ;
+  public : bool    *** _table_routing          ; //[nb_read_unit][nb_execute_unit][nb_execute_unit_port]
+  public : bool     ** _table_execute_type     ; //[nb_execute_unit][nb_type]
+  public : bool     ** _table_execute_thread   ; //[nb_execute_unit][nb_thread]
 
-  public : const uint32_t    _size_context_id        ;
-  public : const uint32_t    _size_front_end_id      ;
-  public : const uint32_t    _size_ooo_engine_id     ;
-  public : const uint32_t    _size_packet_id         ;
-  public : const uint32_t    _size_general_register  ;
-  public : const uint32_t    _size_special_register  ;
+  public : uint32_t    _max_nb_read_unit_port  ;
+  public : uint32_t    _max_nb_execute_unit_port;
+//public : uint32_t    _size_context_id        ;
+//public : uint32_t    _size_front_end_id      ;
+//public : uint32_t    _size_ooo_engine_id     ;
+//public : uint32_t    _size_packet_id         ;
+//public : uint32_t    _size_general_register  ;
+//public : uint32_t    _size_special_register  ;
 
-  public : const bool        _have_port_context_id   ;
-  public : const bool        _have_port_front_end_id ;
-  public : const bool        _have_port_ooo_engine_id;
-  public : const bool        _have_port_packet_id    ;
-  public : const bool        _have_port_load_queue_ptr;
+//public : bool        _have_port_context_id   ;
+//public : bool        _have_port_front_end_id ;
+//public : bool        _have_port_ooo_engine_id;
+//public : bool        _have_port_packet_id    ;
+//public : bool        _have_port_load_queue_ptr;
 
-  public : const uint32_t    _nb_thread              ;
-  public :       uint32_t    _nb_load_store_unit     ;
-  public :       uint32_t    _nb_functionnal_unit    ;
+  public : uint32_t    _nb_thread              ;
+  public : uint32_t    _nb_load_store_unit     ;
+  public : uint32_t    _nb_functionnal_unit    ;
 
     //-----[ methods ]-----------------------------------------------------------
   public : Parameters  (uint32_t    nb_read_unit           ,
+			uint32_t  * nb_read_unit_port      ,
 			uint32_t    nb_execute_unit        ,
+			uint32_t  * nb_execute_unit_port   ,
 			uint32_t    nb_context             ,
 			uint32_t    nb_front_end           ,
@@ -74,9 +80,12 @@
 			uint32_t    size_load_queue        ,
 			Tpriority_t priority               ,
-			bool     ** table_routing          ,
+			bool    *** table_routing          ,
 			bool     ** table_execute_type     ,
-			bool     ** table_execute_thread   );
-  public : Parameters  (Parameters & param) ;
+			bool     ** table_execute_thread   ,
+                        bool        is_toplevel=false      );
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+
+  public :        void            copy       (void);
 
   public :        Parameters_test msg_error  (void);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Read_unit_to_Execution_unit.h
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Read_unit_to_Execution_unit.h	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Read_unit_to_Execution_unit.h	(revision 88)
@@ -39,4 +39,15 @@
 namespace read_unit_to_execution_unit {
 
+  class destination_t
+  {
+  public : uint32_t grp;
+  public : uint32_t elt;
+    
+  public : destination_t (uint32_t grp, uint32_t elt)
+    {
+      this->grp = grp;
+      this->elt = elt;
+    }
+  };
 
   class Read_unit_to_Execution_unit 
@@ -65,44 +76,44 @@
 
     // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-  public    : SC_IN (Tcontrol_t        )   **  in_READ_UNIT_OUT_VAL                  ;
-  public    : SC_OUT(Tcontrol_t        )   ** out_READ_UNIT_OUT_ACK                  ;
-  public    : SC_IN (Tcontext_t        )   **  in_READ_UNIT_OUT_CONTEXT_ID           ;
-  public    : SC_IN (Tcontext_t        )   **  in_READ_UNIT_OUT_FRONT_END_ID         ;
-  public    : SC_IN (Tcontext_t        )   **  in_READ_UNIT_OUT_OOO_ENGINE_ID        ;
-  public    : SC_IN (Tpacket_t         )   **  in_READ_UNIT_OUT_PACKET_ID            ;
-  public    : SC_IN (Toperation_t      )   **  in_READ_UNIT_OUT_OPERATION            ;
-  public    : SC_IN (Ttype_t           )   **  in_READ_UNIT_OUT_TYPE                 ;
-  public    : SC_IN (Tlsq_ptr_t        )   **  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE;
-  public    : SC_IN (Tlsq_ptr_t        )   **  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ;
-  public    : SC_IN (Tcontrol_t        )   **  in_READ_UNIT_OUT_HAS_IMMEDIAT         ;
-  public    : SC_IN (Tgeneral_data_t   )   **  in_READ_UNIT_OUT_IMMEDIAT             ;
-  public    : SC_IN (Tgeneral_data_t   )   **  in_READ_UNIT_OUT_DATA_RA              ;
-  public    : SC_IN (Tgeneral_data_t   )   **  in_READ_UNIT_OUT_DATA_RB              ;
-  public    : SC_IN (Tspecial_data_t   )   **  in_READ_UNIT_OUT_DATA_RC              ;
-  public    : SC_IN (Tcontrol_t        )   **  in_READ_UNIT_OUT_WRITE_RD             ;
-  public    : SC_IN (Tgeneral_address_t)   **  in_READ_UNIT_OUT_NUM_REG_RD           ;
-  public    : SC_IN (Tcontrol_t        )   **  in_READ_UNIT_OUT_WRITE_RE             ;
-  public    : SC_IN (Tspecial_address_t)   **  in_READ_UNIT_OUT_NUM_REG_RE           ;
+  public    : SC_IN (Tcontrol_t        )  ***  in_READ_UNIT_OUT_VAL                    ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_OUT(Tcontrol_t        )  *** out_READ_UNIT_OUT_ACK                    ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tcontext_t        )  ***  in_READ_UNIT_OUT_CONTEXT_ID             ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tcontext_t        )  ***  in_READ_UNIT_OUT_FRONT_END_ID           ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tcontext_t        )  ***  in_READ_UNIT_OUT_OOO_ENGINE_ID          ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tpacket_t         )  ***  in_READ_UNIT_OUT_PACKET_ID              ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Toperation_t      )  ***  in_READ_UNIT_OUT_OPERATION              ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Ttype_t           )  ***  in_READ_UNIT_OUT_TYPE                   ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tlsq_ptr_t        )  ***  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE  ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tlsq_ptr_t        )  ***  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE   ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tcontrol_t        )  ***  in_READ_UNIT_OUT_HAS_IMMEDIAT           ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tgeneral_data_t   )  ***  in_READ_UNIT_OUT_IMMEDIAT               ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tgeneral_data_t   )  ***  in_READ_UNIT_OUT_DATA_RA                ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tgeneral_data_t   )  ***  in_READ_UNIT_OUT_DATA_RB                ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tspecial_data_t   )  ***  in_READ_UNIT_OUT_DATA_RC                ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tcontrol_t        )  ***  in_READ_UNIT_OUT_WRITE_RD               ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tgeneral_address_t)  ***  in_READ_UNIT_OUT_NUM_REG_RD             ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tcontrol_t        )  ***  in_READ_UNIT_OUT_WRITE_RE               ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tspecial_address_t)  ***  in_READ_UNIT_OUT_NUM_REG_RE             ;//[nb_read_unit][nb_read_unit_port]
 
     // ~~~~~[ Interface "execute_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-  public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_IN_VAL                  ;
-  public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_IN_ACK                  ;
-  public    : SC_OUT(Tcontext_t        )   ** out_EXECUTE_UNIT_IN_CONTEXT_ID           ;
-  public    : SC_OUT(Tcontext_t        )   ** out_EXECUTE_UNIT_IN_FRONT_END_ID         ;
-  public    : SC_OUT(Tcontext_t        )   ** out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ;
-  public    : SC_OUT(Tpacket_t         )   ** out_EXECUTE_UNIT_IN_PACKET_ID            ;
-  public    : SC_OUT(Toperation_t      )   ** out_EXECUTE_UNIT_IN_OPERATION            ;
-  public    : SC_OUT(Ttype_t           )   ** out_EXECUTE_UNIT_IN_TYPE                 ;
-  public    : SC_OUT(Tlsq_ptr_t        )   ** out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE;
-  public    : SC_OUT(Tlsq_ptr_t        )   ** out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;
-  public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;
-  public    : SC_OUT(Tgeneral_data_t   )   ** out_EXECUTE_UNIT_IN_IMMEDIAT             ;
-  public    : SC_OUT(Tgeneral_data_t   )   ** out_EXECUTE_UNIT_IN_DATA_RA              ;
-  public    : SC_OUT(Tgeneral_data_t   )   ** out_EXECUTE_UNIT_IN_DATA_RB              ;
-  public    : SC_OUT(Tspecial_data_t   )   ** out_EXECUTE_UNIT_IN_DATA_RC              ;
-  public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_IN_WRITE_RD             ;
-  public    : SC_OUT(Tgeneral_address_t)   ** out_EXECUTE_UNIT_IN_NUM_REG_RD           ;
-  public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_IN_WRITE_RE             ;
-  public    : SC_OUT(Tspecial_address_t)   ** out_EXECUTE_UNIT_IN_NUM_REG_RE           ;
+  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_IN_VAL                  ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_IN_ACK                  ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tcontext_t        )  *** out_EXECUTE_UNIT_IN_CONTEXT_ID           ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tcontext_t        )  *** out_EXECUTE_UNIT_IN_FRONT_END_ID         ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tcontext_t        )  *** out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tpacket_t         )  *** out_EXECUTE_UNIT_IN_PACKET_ID            ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Toperation_t      )  *** out_EXECUTE_UNIT_IN_OPERATION            ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Ttype_t           )  *** out_EXECUTE_UNIT_IN_TYPE                 ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tlsq_ptr_t        )  *** out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tlsq_ptr_t        )  *** out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tgeneral_data_t   )  *** out_EXECUTE_UNIT_IN_IMMEDIAT             ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tgeneral_data_t   )  *** out_EXECUTE_UNIT_IN_DATA_RA              ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tgeneral_data_t   )  *** out_EXECUTE_UNIT_IN_DATA_RB              ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tspecial_data_t   )  *** out_EXECUTE_UNIT_IN_DATA_RC              ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_IN_WRITE_RD             ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tgeneral_address_t)  *** out_EXECUTE_UNIT_IN_NUM_REG_RD           ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_IN_WRITE_RE             ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tspecial_address_t)  *** out_EXECUTE_UNIT_IN_NUM_REG_RE           ;//[nb_execute_unit][nb_execute_unit_port]
 
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
@@ -111,5 +122,5 @@
 
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-  private   : std::list<uint32_t> *** _destination; // [nb_read_unit][nb_thread][nb_type];
+  private   : std::list<destination_t> *** _destination; // [nb_read_unit][nb_thread][nb_type];
 #endif
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters.cpp	(revision 88)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Parameters.h"
+#include "Common/include/Max.h"
 
 namespace morpheo {
@@ -20,5 +21,7 @@
 #define FUNCTION "Read_unit_to_Execution_unit::Parameters"
   Parameters::Parameters (uint32_t    nb_read_unit           ,
+			  uint32_t  * nb_read_unit_port      ,
 			  uint32_t    nb_execute_unit        ,
+			  uint32_t  * nb_execute_unit_port   ,
 			  uint32_t    nb_context             ,
 			  uint32_t    nb_front_end           ,
@@ -32,43 +35,31 @@
 			  uint32_t    size_load_queue        ,
 			  Tpriority_t priority               ,
-			  bool     ** table_routing          ,
+			  bool    *** table_routing          ,
 			  bool     ** table_execute_type     ,
-			  bool     ** table_execute_thread   ):
-    _nb_read_unit            (nb_read_unit       ),
-    _nb_execute_unit         (nb_execute_unit    ),
-    _nb_context              (nb_context         ),
-    _nb_front_end            (nb_front_end       ),
-    _nb_ooo_engine           (nb_ooo_engine      ),
-    _nb_packet               (nb_packet          ),
-    _size_general_data       (size_general_data  ),
-    _size_special_data       (size_special_data  ),
-    _nb_general_register     (nb_general_register),
-    _nb_special_register     (nb_special_register),
-    _size_store_queue        (size_store_queue   ),
-    _size_load_queue         (size_load_queue    ),
-    _priority                (priority           ),
-
-    _size_context_id         (log2(nb_context         )),
-    _size_front_end_id       (log2(nb_front_end       )),
-    _size_ooo_engine_id      (log2(nb_ooo_engine      )),
-    _size_packet_id          (log2(nb_packet          )),
-    _size_general_register   (log2(nb_general_register)),
-    _size_special_register   (log2(nb_special_register)),
-    
-    _have_port_context_id    (_size_context_id    > 0),
-    _have_port_front_end_id  (_size_front_end_id  > 0),
-    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
-    _have_port_packet_id     (_size_packet_id     > 0),
-    _have_port_load_queue_ptr(_size_load_queue    > 1),
-
-    _nb_thread               (get_nb_thread (nb_context, nb_front_end, nb_ooo_engine))
+			  bool     ** table_execute_thread   ,
+                          bool        is_toplevel            )
   {
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
 
-    _table_routing        = table_routing       ;
-    _table_execute_type   = table_execute_type  ;
-    _table_execute_thread = table_execute_thread;
+    _nb_read_unit            = nb_read_unit        ;
+    _nb_read_unit_port       = nb_read_unit_port   ;    
+    _nb_execute_unit         = nb_execute_unit     ;
+    _nb_execute_unit_port    = nb_execute_unit_port;
+    _nb_context              = nb_context          ;
+    _nb_front_end            = nb_front_end        ;
+    _nb_ooo_engine           = nb_ooo_engine       ;
+    _nb_packet               = nb_packet           ;
+    _nb_general_register     = nb_general_register ;
+    _nb_special_register     = nb_special_register ;
+    _priority                = priority            ;
+    _table_routing           = table_routing       ;
+    _table_execute_type      = table_execute_type  ;
+    _table_execute_thread    = table_execute_thread;
 
-    _nb_load_store_unit   = 0;
+    _max_nb_read_unit_port   = max<uint32_t>(_nb_read_unit_port, _nb_read_unit);
+    _max_nb_execute_unit_port= max<uint32_t>(_nb_execute_unit_port, _nb_execute_unit);
+
+    _nb_thread               = get_nb_thread (nb_context, nb_front_end, nb_ooo_engine);
+    _nb_load_store_unit      = 0;
 
     for (uint32_t i=0; i<nb_execute_unit; i++)
@@ -82,54 +73,50 @@
     test();
 
+    if (is_toplevel)
+      {
+        _size_context_id         = log2(nb_context         );
+        _size_front_end_id       = log2(nb_front_end       );
+        _size_ooo_engine_id      = log2(nb_ooo_engine      );
+        _size_rob_ptr            = log2(nb_packet          );
+        _size_general_register   = log2(nb_general_register);
+        _size_special_register   = log2(nb_special_register);
+        _size_general_data       = size_general_data   ;
+        _size_special_data       = size_special_data   ;
+        _size_store_queue_ptr    = log2(size_store_queue   );
+        _size_load_queue_ptr     = log2(size_load_queue    );
+        
+        _have_port_context_id    = _size_context_id    > 0;
+        _have_port_front_end_id  = _size_front_end_id  > 0;
+        _have_port_ooo_engine_id = _size_ooo_engine_id > 0;
+        _have_port_rob_ptr       = _size_rob_ptr       > 0;
+        _have_port_load_queue_ptr= _size_load_queue_ptr> 0;
+        
+        copy();
+      }
+
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");
   };
   
+// #undef  FUNCTION
+// #define FUNCTION "Read_unit_to_Execution_unit::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param)
+//   {
+//     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
+
+//     test();
+//     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");
+//   };
+
 #undef  FUNCTION
-#define FUNCTION "Read_unit_to_Execution_unit::Parameters (copy)"
-  Parameters::Parameters (Parameters & param):
-    _nb_read_unit            (param._nb_read_unit           ),
-    _nb_execute_unit         (param._nb_execute_unit        ),
-    _nb_context              (param._nb_context             ),
-    _nb_front_end            (param._nb_front_end           ),
-    _nb_ooo_engine           (param._nb_ooo_engine          ),
-    _nb_packet               (param._nb_packet              ),
-    _size_general_data       (param._size_general_data      ),
-    _size_special_data       (param._size_special_data      ),
-    _nb_general_register     (param._nb_general_register    ),
-    _nb_special_register     (param._nb_special_register    ),
-    _size_store_queue        (param._size_store_queue       ),
-    _size_load_queue         (param._size_load_queue        ),
-    _priority                (param._priority               ),
-
-    _size_context_id         (param._size_context_id        ),
-    _size_front_end_id       (param._size_front_end_id      ),
-    _size_ooo_engine_id      (param._size_ooo_engine_id     ),
-    _size_packet_id          (param._size_packet_id         ),
-    _size_general_register   (param._size_general_register  ),
-    _size_special_register   (param._size_special_register  ),
-
-    _have_port_context_id    (param._have_port_context_id   ),
-    _have_port_front_end_id  (param._have_port_front_end_id ),
-    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
-    _have_port_packet_id     (param._have_port_packet_id    ),
-    _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
-
-    _nb_thread               (param._nb_thread              )
+#define FUNCTION "Read_unit_to_Execution_unit::~Parameters"
+  Parameters::~Parameters () 
   {
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
-
-    _table_routing        = param._table_routing       ;
-    _table_execute_type   = param._table_execute_type  ;
-    _table_execute_thread = param._table_execute_thread;
-    _nb_load_store_unit   = param._nb_load_store_unit  ;
-    _nb_functionnal_unit  = param._nb_functionnal_unit ;
-
-    test();
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");
   };
 
 #undef  FUNCTION
-#define FUNCTION "Read_unit_to_Execution_unit::~Parameters"
-  Parameters::~Parameters () 
+#define FUNCTION "Read_unit_to_Execution_unit::copy"
+  void Parameters::copy (void) 
   {
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters_msg_error.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters_msg_error.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters_msg_error.cpp	(revision 88)
@@ -33,5 +33,6 @@
     // TYPE_MOVE    |     X     |            |            | cmov is optionnal
     // TYPE_TEST    |     X     |            |            |
-    // TYPE_MUL_DIV |     X     |            |            | div is optionnal
+    // TYPE_MUL     |     X     |            |            |
+    // TYPE_DIV     |     X     |     X      |            |
     // TYPE_EXTEND  |     X     |     X      |            |
     // TYPE_FIND    |     X     |     X      |            |
@@ -58,5 +59,6 @@
     type_valid     [TYPE_MOVE   ] = true;
     type_valid     [TYPE_TEST   ] = true;
-    type_valid     [TYPE_MUL_DIV] = true;
+    type_valid     [TYPE_MUL    ] = true;
+    type_valid     [TYPE_DIV    ] = true;
     type_valid     [TYPE_EXTEND ] = true;
     type_valid     [TYPE_FIND   ] = true;
@@ -70,4 +72,5 @@
     type_uniq      [TYPE_MEMORY ] = true;
 
+    type_optionnal [TYPE_DIV    ] = true;
     type_optionnal [TYPE_EXTEND ] = true;
     type_optionnal [TYPE_FIND   ] = true;
@@ -85,13 +88,21 @@
 	if (_table_execute_thread [i][j] == true)
 	  // this execute_unit execute this thread !
-	  for (Ttype_t k=0; k<=_nb_type; k++)
-	    if (_table_execute_type[i][k] == true)
-	      {
-		// Test uniq type
-		if (type_present [j][k] and type_uniq[k])
-		  test.error("The execute_unit '"+toString(i)+"' can execute operation of type '"+toString_type(k)+"' at the thread '"+toString(j)+"'. But an another execute_unit can be execute the same type for the same thread. And the type must be uniq !.");
-		
-		type_present [j][k] = true;
-	      }
+	  for (Ttype_t k=0; k<_nb_type; k++)
+            if (_table_execute_type[i][k] == true)
+              {
+//                 test.information(toString(_("Execute_unit [%d], Thread [%d], Type [%d], type_valid %d, type_present %d, type_uniq %d\n"),i,j,k,type_valid[k],type_present[j][k],type_uniq[k]));
+                
+                // Test uniq type
+                if (type_present [j][k] and type_uniq[k])
+                  test.error(toString(_("The execute_unit '%d' can execute operation of type '%s' at the thread '%d'. But an another execute_unit can be execute the same type for the same thread. And the type must be single !.\n"),i,toString_type(k).c_str(),j));
+                
+                type_present [j][k] = true;
+              }
+
+    for (Ttype_t j=0; j<_nb_type; j++)
+      if (not type_valid [j])
+	for (uint32_t i=0; i<_nb_thread; i++)
+	  if (type_present [i][j])
+	    test.error(toString(_("The thread '%d' can execute the type's operation '%s' but this type is invalid.\n"),i,toString_type(j).c_str()));
 
     for (Ttype_t j=0; j<_nb_type; j++)
@@ -99,14 +110,14 @@
 	for (uint32_t i=0; i<_nb_thread; i++)
 	  if (not type_present [i][j])
-	    test.error("The thread '"+toString(i)+"' can't access at the execute_unit to execute the type's operation '"+toString_type(j)+"' (and this type is not optionnal !).");
+	    test.error(toString(_("The thread '%d' can't access at the execute_unit to execute the type's operation '%s' (and this type is not optional !).\n"),i,toString_type(j).c_str()));
 	    
     // Test all excluve type
     for (uint32_t i=0; i<_nb_execute_unit; i++)
-      for (Ttype_t j=0; j<=_nb_type; j++)
+      for (Ttype_t j=0; j<_nb_type; j++)
 	if (type_exclusive [j] and _table_execute_type[i][j])
-	  for (Ttype_t k=0; k<=_nb_type; k++)
+	  for (Ttype_t k=0; k<_nb_type; k++)
 	    if ((j != k) and (_table_execute_type[i][k] == true))
 	      {
-		test.error("The execute_unit ["+toString(i)+"] implement the type '"+toString_type(j)+"', and this type is exclusive with all others type.");
+		test.error(toString(_("The execute_unit [%d] implement the type '%s', and this type is exclusive with all others type.\n"),i,toString_type(j).c_str()));
 		break;
 	      }
@@ -120,10 +131,10 @@
 
 	if (j == _nb_thread)
-	  test.error("The execute_unit ["+toString(i)+"] have none source's thread.");
+	  test.error(toString(_("The execute_unit [%d] have none source's thread.\n"),i));
       }	  
 
     if ( (_priority != PRIORITY_STATIC     ) and
 	 (_priority != PRIORITY_ROUND_ROBIN))
-      test.error("Unsupported priority scheme. It must be Static or Round Robin.");
+      test.error(_("Unsupported priority scheme. It must be Static or Round Robin.\n"));
         
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters_print.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters_print.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters_print.cpp	(revision 88)
@@ -37,6 +37,6 @@
     xml.singleton_begin("nb_general_register"); xml.attribut("value",toString(_nb_general_register)); xml.singleton_end();
     xml.singleton_begin("nb_special_register"); xml.attribut("value",toString(_nb_special_register)); xml.singleton_end();
-    xml.singleton_begin("size_store_queue   "); xml.attribut("value",toString(_size_store_queue   )); xml.singleton_end();
-    xml.singleton_begin("size_load_queue    "); xml.attribut("value",toString(_size_load_queue    )); xml.singleton_end();
+//  xml.singleton_begin("size_store_queue   "); xml.attribut("value",toString(_size_store_queue   )); xml.singleton_end();
+//  xml.singleton_begin("size_load_queue    "); xml.attribut("value",toString(_size_load_queue    )); xml.singleton_end();
     xml.singleton_begin("priority           "); xml.attribut("value",toString(_priority           )); xml.singleton_end();
     xml.balise_close();
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit.cpp	(revision 88)
@@ -38,4 +38,10 @@
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
 
+#if DEBUG_Read_unit_to_Execution_unit == true
+    log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+
+    std::cout << *param << std::endl;
+#endif    
+
     log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,"Allocation");
 
@@ -47,5 +53,5 @@
 
 #ifdef STATISTICS
-    if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
       {	
 	log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,"Allocation of statistics");
@@ -56,5 +62,5 @@
 
 #ifdef VHDL
-    if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
       {
 	// generate the vhdl
@@ -66,5 +72,5 @@
 
 #ifdef SYSTEMC
-    if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
       {
 	log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,"Method - transition");
@@ -85,81 +91,88 @@
 
 	for (uint32_t i=0; i<_param->_nb_read_unit; i++)
-	  {
-	    sensitive << (*(in_READ_UNIT_OUT_VAL                   [i]))
-		      << (*(in_READ_UNIT_OUT_OPERATION             [i]))
-		      << (*(in_READ_UNIT_OUT_TYPE                  [i]))
-		      << (*(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i]))
-		      << (*(in_READ_UNIT_OUT_IMMEDIAT              [i]))
-		      << (*(in_READ_UNIT_OUT_DATA_RA               [i]))
-		      << (*(in_READ_UNIT_OUT_DATA_RB               [i]))
-		      << (*(in_READ_UNIT_OUT_DATA_RC               [i]))
-		      << (*(in_READ_UNIT_OUT_WRITE_RD              [i]))
-		      << (*(in_READ_UNIT_OUT_NUM_REG_RD            [i]))
-		      << (*(in_READ_UNIT_OUT_WRITE_RE              [i]))
-		      << (*(in_READ_UNIT_OUT_NUM_REG_RE            [i]))
-		      << (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i]));
-
-	    if (_param->_have_port_load_queue_ptr)
-	    sensitive  << (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i]));
-	    if (_param->_have_port_context_id)
-	    sensitive  << (*(in_READ_UNIT_OUT_CONTEXT_ID            [i]));
-	    if (_param->_have_port_front_end_id)
-	    sensitive  << (*(in_READ_UNIT_OUT_FRONT_END_ID          [i]));
-	    if (_param->_have_port_ooo_engine_id)
-	    sensitive  << (*(in_READ_UNIT_OUT_OOO_ENGINE_ID         [i]));
-	    if (_param->_have_port_packet_id)
-	    sensitive  << (*(in_READ_UNIT_OUT_PACKET_ID             [i]));
-	  }
+	  for (uint32_t j=0; j<_param->_nb_read_unit_port[i]; j++)
+	    {
+	      sensitive << (*(in_READ_UNIT_OUT_VAL                   [i][j]))
+			<< (*(in_READ_UNIT_OUT_OPERATION             [i][j]))
+			<< (*(in_READ_UNIT_OUT_TYPE                  [i][j]))
+			<< (*(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i][j]))
+			<< (*(in_READ_UNIT_OUT_IMMEDIAT              [i][j]))
+			<< (*(in_READ_UNIT_OUT_DATA_RA               [i][j]))
+			<< (*(in_READ_UNIT_OUT_DATA_RB               [i][j]))
+			<< (*(in_READ_UNIT_OUT_DATA_RC               [i][j]))
+			<< (*(in_READ_UNIT_OUT_WRITE_RD              [i][j]))
+			<< (*(in_READ_UNIT_OUT_NUM_REG_RD            [i][j]))
+			<< (*(in_READ_UNIT_OUT_WRITE_RE              [i][j]))
+			<< (*(in_READ_UNIT_OUT_NUM_REG_RE            [i][j]))
+			<< (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i][j]));
+
+	      if (_param->_have_port_load_queue_ptr)
+	      sensitive  << (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i][j]));
+	      if (_param->_have_port_context_id)
+	      sensitive  << (*(in_READ_UNIT_OUT_CONTEXT_ID            [i][j]));
+	      if (_param->_have_port_front_end_id)
+	      sensitive  << (*(in_READ_UNIT_OUT_FRONT_END_ID          [i][j]));
+	      if (_param->_have_port_ooo_engine_id)
+	      sensitive  << (*(in_READ_UNIT_OUT_OOO_ENGINE_ID         [i][j]));
+	      if (_param->_have_port_rob_ptr  )
+	      sensitive  << (*(in_READ_UNIT_OUT_PACKET_ID             [i][j]));
+	    }
 	
 	for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-	  sensitive << (*(in_EXECUTE_UNIT_IN_ACK                 [i]));
+	  for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+	    sensitive << (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
 	
 # ifdef SYSTEMCASS_SPECIFIC
 	// List dependency information
 	for (uint32_t i=0; i<_param->_nb_read_unit; i++)
+	  for (uint32_t j=0; j<_param->_nb_read_unit_port[i]; j++)
 	  {
-	    (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_VAL           [i]));
-	    (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_TYPE          [i]));
+	    (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_VAL           [i][j]));
+	    (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_TYPE          [i][j]));
 	    if (_param->_have_port_context_id)
-	    (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [i]));
+	    (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [i][j]));
 	    if (_param->_have_port_front_end_id)
-	    (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [i]));
+	    (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [i][j]));
 	    if (_param->_have_port_ooo_engine_id)
-	    (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	      (*(out_READ_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_IN_ACK [j]));
+	    (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [x][y]));
 	  }
 
 	for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+	  for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
 	  {
-	    (*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    (*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 
 	    if (_param->_have_port_context_id)
 	      {
-	    (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 	      }
@@ -167,16 +180,17 @@
 	    if (_param->_have_port_front_end_id)
 	      {
-	    (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 	      }
@@ -184,232 +198,247 @@
 	    if (_param->_have_port_ooo_engine_id)
 	      {
-	    (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
-	      }
-	      }
-
-	    if (_param->_have_port_packet_id)
-	      {
-	    (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_PACKET_ID     [j]));
-		(*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
-	      }
-	      }
-
-	    (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_OPERATION     [j]));
-		(*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
-	      }
-
-	    (*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
-	      }
-
-	    (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [j]));
-		(*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_VAL                   [j]));
-		(*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_TYPE                  [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID            [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID          [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+	      }
+	      }
+
+	    if (_param->_have_port_rob_ptr  )
+	      {
+	    (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_PACKET_ID     [x][y]));
+		(*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+	      }
+	      }
+
+	    (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_OPERATION     [x][y]));
+		(*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+	      }
+
+	    (*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+	      }
+
+	    (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [x][y]));
+		(*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_VAL                   [x][y]));
+		(*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_TYPE                  [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID            [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID          [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 
 	    if (_param->_have_port_load_queue_ptr)
 	      {
-	    (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE [j]));
-		(*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_VAL                  [j]));
-		(*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_TYPE                 [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID           [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID         [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID        [j]));
+	    (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE [x][y]));
+		(*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_VAL                  [x][y]));
+		(*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_TYPE                 [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID           [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID         [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID        [x][y]));
 	      }
 	      }
 	    
-	    (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_HAS_IMMEDIAT  [j]));
-		(*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
-	      }
-
-	    (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_IMMEDIAT      [j]));
-		(*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
-	      }
-
-	    (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_DATA_RA       [j]));
-		(*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
-	      }
-
-	    (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_DATA_RB       [j]));
-		(*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
-	      }
-
-	    (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_DATA_RC       [j]));
-		(*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
-	      }
-
-	    (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_WRITE_RD      [j]));
-		(*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_HAS_IMMEDIAT  [x][y]));
+		(*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+	      }
+
+	    (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_IMMEDIAT      [x][y]));
+		(*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+	      }
+
+	    (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_DATA_RA       [x][y]));
+		(*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+	      }
+
+	    (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_DATA_RB       [x][y]));
+		(*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+	      }
+
+	    (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_DATA_RC       [x][y]));
+		(*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+	      }
+
+	    (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_WRITE_RD      [x][y]));
+		(*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 	    
-	    (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_NUM_REG_RD    [j]));
-		(*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
-	      }
-
-	    (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_WRITE_RE      [j]));
-		(*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
-	      }
-
-	    (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
-
-	    for (uint32_t j=0; j<_param->_nb_read_unit; j++)
-	      {
-		(*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_NUM_REG_RE    [j]));
-		(*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
-		(*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
-		if (_param->_have_port_context_id)
-		(*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
-		if (_param->_have_port_front_end_id)
-		(*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
-		if (_param->_have_port_ooo_engine_id)
-		(*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+	    (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_NUM_REG_RD    [x][y]));
+		(*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+	      }
+
+	    (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_WRITE_RE      [x][y]));
+		(*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+	      }
+
+	    (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+
+	    for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+	      for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+	      {
+		(*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_NUM_REG_RE    [x][y]));
+		(*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+		(*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+		if (_param->_have_port_context_id)
+		(*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+		if (_param->_have_port_front_end_id)
+		(*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+		if (_param->_have_port_ooo_engine_id)
+		(*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 	      }
 	  }
@@ -428,5 +457,5 @@
 
 #ifdef STATISTICS
-    if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
       {
 	log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,"Generate Statistics file");
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_allocation.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_allocation.cpp	(revision 88)
@@ -57,65 +57,68 @@
     // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC1_INTERFACE("read_unit_out", IN, EAST, "Output of read_unit", _param->_nb_read_unit);
+       ALLOC2_INTERFACE("read_unit_out", IN, EAST, "Output of read_unit",_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
 
-       ALLOC1_VALACK_IN ( in_READ_UNIT_OUT_VAL,VAL);
-       ALLOC1_VALACK_OUT(out_READ_UNIT_OUT_ACK,ACK);
-
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_FRONT_END_ID         ,"FRONT_END_ID"         ,Tcontext_t        ,_param->_size_front_end_id);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_OOO_ENGINE_ID        ,"OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_size_ooo_engine_id);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_PACKET_ID            ,"PACKET_ID"            ,Tpacket_t         ,_param->_size_packet_id);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,log2(_param->_size_store_queue));
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,log2(_param->_size_load_queue));
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RA              ,"DATA_RA"              ,Tgeneral_data_t   ,_param->_size_general_data);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1);
-       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register);
+       _ALLOC2_VALACK_IN ( in_READ_UNIT_OUT_VAL,VAL,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_VALACK_OUT(out_READ_UNIT_OUT_ACK,ACK,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id       ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_FRONT_END_ID         ,"FRONT_END_ID"         ,Tcontext_t        ,_param->_size_front_end_id     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_OOO_ENGINE_ID        ,"OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_size_ooo_engine_id    ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_PACKET_ID            ,"PACKET_ID"            ,Tpacket_t         ,_param->_size_rob_ptr          ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_size_store_queue_ptr  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1                              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RA              ,"DATA_RA"              ,Tgeneral_data_t   ,_param->_size_general_data     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1                              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1                              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
      }
     // ~~~~~[ Interface "execute_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC1_INTERFACE("execute_unit_in", OUT, WEST, "Input of execute_unit", _param->_nb_execute_unit);
+       ALLOC2_INTERFACE("execute_unit_in", OUT, WEST, "Input of execute_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
        
-       ALLOC1_VALACK_OUT(out_EXECUTE_UNIT_IN_VAL,VAL);
-       ALLOC1_VALACK_IN ( in_EXECUTE_UNIT_IN_ACK,ACK);
+       _ALLOC2_VALACK_OUT(out_EXECUTE_UNIT_IN_VAL,VAL, _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_VALACK_IN ( in_EXECUTE_UNIT_IN_ACK,ACK, _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id       , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,"FRONT_END_ID"         ,Tcontext_t        ,_param->_size_front_end_id     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,"OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_size_ooo_engine_id    , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_PACKET_ID            ,"PACKET_ID"            ,Tpacket_t         ,_param->_size_rob_ptr          , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation        , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type             , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1                              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1                              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1                              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_size_store_queue_ptr  , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr   , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RA              ,"DATA_RA"              ,Tgeneral_data_t   ,_param->_size_general_data     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+     }
 
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,"FRONT_END_ID"         ,Tcontext_t        ,_param->_size_front_end_id);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,"OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_size_ooo_engine_id);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_PACKET_ID            ,"PACKET_ID"            ,Tpacket_t         ,_param->_size_packet_id);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,log2(_param->_size_store_queue));
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,log2(_param->_size_load_queue));
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RA              ,"DATA_RA"              ,Tgeneral_data_t   ,_param->_size_general_data);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register);
-     }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
-     _destination = new std::list<uint32_t> ** [_param->_nb_read_unit];
+     if (usage_is_set(_usage,USE_SYSTEMC))
+       {
+     _destination = new std::list<destination_t> ** [_param->_nb_read_unit];
      for (uint32_t i=0; i<_param->_nb_read_unit; i++)
        {
-	 _destination [i] = new std::list<uint32_t> * [_param->_nb_thread];
+	 _destination [i] = new std::list<destination_t> * [_param->_nb_thread];
 	 for (uint32_t j=0; j<_param->_nb_thread; j++)
 	   {
-	     _destination [i][j] = new std::list<uint32_t> [_param->_nb_type];
+	     _destination [i][j] = new std::list<destination_t> [_param->_nb_type];
 	   }
+       }
        }
 
 #ifdef POSITION
-    _component->generate_file();
+     if (usage_is_set(_usage,USE_POSITION))
+       _component->generate_file();
 #endif
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_deallocation.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_deallocation.cpp	(revision 88)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Read_unit_to_Execution_unit.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -23,64 +24,53 @@
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
 
-    if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
       {
 	delete    in_CLOCK ;
 	delete    in_NRESET;
 
-	// ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	delete [] in_READ_UNIT_OUT_VAL                  ;
-	delete []out_READ_UNIT_OUT_ACK                  ;
-	if (_param->_have_port_context_id)
-	delete [] in_READ_UNIT_OUT_CONTEXT_ID           ;
-	if (_param->_have_port_front_end_id)
-	delete [] in_READ_UNIT_OUT_FRONT_END_ID         ;
-	if (_param->_have_port_ooo_engine_id)
-	delete [] in_READ_UNIT_OUT_OOO_ENGINE_ID        ;
-	if (_param->_have_port_packet_id)
-	delete [] in_READ_UNIT_OUT_PACKET_ID            ;
-	delete [] in_READ_UNIT_OUT_OPERATION            ;
-	delete [] in_READ_UNIT_OUT_TYPE                 ;
-	delete [] in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE;
-	if (_param->_have_port_load_queue_ptr)
-	delete [] in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ;
-	delete [] in_READ_UNIT_OUT_HAS_IMMEDIAT         ;
-	delete [] in_READ_UNIT_OUT_IMMEDIAT             ;
-	delete [] in_READ_UNIT_OUT_DATA_RA              ;
-	delete [] in_READ_UNIT_OUT_DATA_RB              ;
-	delete [] in_READ_UNIT_OUT_DATA_RC              ;
-	delete [] in_READ_UNIT_OUT_WRITE_RD             ;
-	delete [] in_READ_UNIT_OUT_NUM_REG_RD           ;
-	delete [] in_READ_UNIT_OUT_WRITE_RE             ;
-	delete [] in_READ_UNIT_OUT_NUM_REG_RE           ;
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_VAL                    , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
+         DELETE2_SIGNAL(out_READ_UNIT_OUT_ACK                    , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_CONTEXT_ID             , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_context_id       );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_FRONT_END_ID           , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_front_end_id     );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_OOO_ENGINE_ID          , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_ooo_engine_id    );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_PACKET_ID              , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_rob_ptr          );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_OPERATION              , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_operation        );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_TYPE                   , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_type             );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE  , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_store_queue_ptr  );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE   , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_load_queue_ptr   );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_HAS_IMMEDIAT           , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_IMMEDIAT               , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_general_data     );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_DATA_RA                , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_general_data     );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_DATA_RB                , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_general_data     );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_DATA_RC                , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_special_data     );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_WRITE_RD               , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RD             , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_general_register );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_WRITE_RE               , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RE             , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_special_register );
+       
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_VAL                  , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
+         DELETE2_SIGNAL( in_EXECUTE_UNIT_IN_ACK                  , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_CONTEXT_ID           , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_context_id       );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_FRONT_END_ID         , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_front_end_id     );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_ooo_engine_id    );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_PACKET_ID            , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_rob_ptr          );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_OPERATION            , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_operation        );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_TYPE                 , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_type             );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RC              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_special_data     );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RD             , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RE             , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RE           , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_special_register );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE, _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_store_queue_ptr  );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_load_queue_ptr   );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_IMMEDIAT             , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_data     );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RA              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_data     );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RB              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_data     );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_register );
 
-	// ~~~~~[ Interface "execute_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	delete [] out_EXECUTE_UNIT_IN_VAL                  ;
-	delete []  in_EXECUTE_UNIT_IN_ACK                  ;
-	if (_param->_have_port_context_id)
-	delete [] out_EXECUTE_UNIT_IN_CONTEXT_ID           ;
-	if (_param->_have_port_front_end_id)
-	delete [] out_EXECUTE_UNIT_IN_FRONT_END_ID         ;
-	if (_param->_have_port_ooo_engine_id)
-	delete [] out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ;
-	if (_param->_have_port_packet_id)
-	delete [] out_EXECUTE_UNIT_IN_PACKET_ID            ;
-	delete [] out_EXECUTE_UNIT_IN_OPERATION            ;
-	delete [] out_EXECUTE_UNIT_IN_TYPE                 ;
-	delete [] out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;
-	delete [] out_EXECUTE_UNIT_IN_DATA_RC              ;
-	delete [] out_EXECUTE_UNIT_IN_WRITE_RD             ;
-	delete [] out_EXECUTE_UNIT_IN_WRITE_RE             ;
-	delete [] out_EXECUTE_UNIT_IN_NUM_REG_RE           ;
-	delete [] out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE;
-	if (_param->_have_port_load_queue_ptr)
-	delete [] out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;
-	delete [] out_EXECUTE_UNIT_IN_IMMEDIAT             ;
-	delete [] out_EXECUTE_UNIT_IN_DATA_RA              ;
-	delete [] out_EXECUTE_UNIT_IN_DATA_RB              ;
-	delete [] out_EXECUTE_UNIT_IN_NUM_REG_RD           ;
+         delete [] _destination;
       }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
 
-    delete [] _destination;
     delete    _component;
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_end_cycle.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_end_cycle.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_end_cycle.cpp	(revision 88)
@@ -25,5 +25,6 @@
 
 #ifdef STATISTICS
-    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif    
 
@@ -31,5 +32,6 @@
     // Evaluation before read the ouput signal
 //  sc_start(0);
-    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_genMealy.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_genMealy.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_genMealy.cpp	(revision 88)
@@ -24,80 +24,83 @@
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
 
-    bool execute_unit_use [_param->_nb_execute_unit];
+    bool execute_unit_use [_param->_nb_execute_unit][_param->_max_nb_execute_unit_port];
 
     for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-      execute_unit_use[i] = (PORT_READ(in_EXECUTE_UNIT_IN_ACK [i]) == 0);
+      for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+	execute_unit_use[i][j] = false;
 
     for (uint32_t i=0; i<_param->_nb_read_unit; i++)
-      {
-	bool       ack = false;
+      for (uint32_t j=0; j<_param->_nb_read_unit_port[i]; j++)
+	{
+	  bool       ack = false;
+	  
+	  log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"Test Read_unit[%d][%d]",i,j);
+	  
+	  if (PORT_READ(in_READ_UNIT_OUT_VAL [i][j]) == true)
+	    {
+	      log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION," * have a valid entry.");
+	      
+	      Tcontext_t context_id    = (_param->_have_port_context_id   )?PORT_READ(in_READ_UNIT_OUT_CONTEXT_ID    [i][j]):0;
+	      Tcontext_t front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_READ_UNIT_OUT_FRONT_END_ID  [i][j]):0;
+	      Tcontext_t ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_READ_UNIT_OUT_OOO_ENGINE_ID [i][j]):0;
+	      Tcontext_t num_thread    = get_num_thread(context_id   , _param->_size_context_id   ,
+							front_end_id , _param->_size_front_end_id ,
+							ooo_engine_id, _param->_size_ooo_engine_id);
+	      Ttype_t    type          = PORT_READ(in_READ_UNIT_OUT_TYPE [i][j]);
+	      
+#ifdef DEBUG_TEST
+	      if (_destination[i][num_thread][type].empty())
+		throw ERRORMORPHEO(FUNCTION,"Invalid Operation : They have no execute_unit to receive a operation from the read_unit ["+toString(i)+"], thread ["+toString(num_thread)+"] and a operation's type ["+toString_type(type)+"].");
+#endif
+	      
+	      // find a free execute_unit
+	      for (std::list<destination_t>::iterator it=_destination[i][num_thread][type].begin();
+		   (it != _destination[i][num_thread][type].end()) and (ack == false);
+		   it++)
+		{
+		  uint32_t dest = (*it).grp;
+		  uint32_t port = (*it).elt;
+		  
+		  log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"   * Test destination [%d][%d].",dest,port);
+		  
+		  if (execute_unit_use [dest][port] == false)
+		    {
+		      log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"     * Is ok! Link.");
+		      
+		      // have find !!!
+		      ack                           = PORT_READ(in_EXECUTE_UNIT_IN_ACK [dest][port]);
+		      execute_unit_use [dest][port] = true;
 
-	log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"Test Read_unit[%d]",i);
-
-	if (PORT_READ(in_READ_UNIT_OUT_VAL [i]) == true)
-	  {
-	    log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION," * have a valid entry.");
-	    
-	    Tcontext_t context_id    = (_param->_have_port_context_id   )?PORT_READ(in_READ_UNIT_OUT_CONTEXT_ID    [i]):0;
-	    Tcontext_t front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_READ_UNIT_OUT_FRONT_END_ID  [i]):0;
-	    Tcontext_t ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_READ_UNIT_OUT_OOO_ENGINE_ID [i]):0;
-	    Tcontext_t num_thread    = get_num_thread(context_id   , _param->_size_context_id   ,
-						      front_end_id , _param->_size_front_end_id ,
-						      ooo_engine_id, _param->_size_ooo_engine_id);
-	    Ttype_t    type          = PORT_READ(in_READ_UNIT_OUT_TYPE [i]);
-	    
-#ifdef DEBUG_TEST
-	    if (_destination[i][num_thread][type].empty())
-	      throw ERRORMORPHEO(FUNCTION,"Invalid Operation : They have no execute_unit to receive a operation from the read_unit ["+toString(i)+"], thread ["+toString(num_thread)+"] and a operation's type ["+toString_type(type)+"].");
-#endif
-
-	    // find a free execute_unit
-	    for (std::list<uint32_t>::iterator it=_destination[i][num_thread][type].begin();
-		 (it != _destination[i][num_thread][type].end()) and (ack == false);
-		 it++)
-	      {
-		uint32_t dest = *it;
-
-		log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"   * Test destination [%d].",dest);
-			    
-		if (execute_unit_use [dest] == false)
-		  {
-		    log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"     * Is ok! Link.");
-		    // have find !!!
-		    ack                     = true;
-		    execute_unit_use [dest] = true;
-
-		    if (_param->_have_port_context_id)
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_CONTEXT_ID            [dest], PORT_READ(in_READ_UNIT_OUT_CONTEXT_ID            [i]));
-		    if (_param->_have_port_front_end_id)
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_FRONT_END_ID          [dest], PORT_READ(in_READ_UNIT_OUT_FRONT_END_ID          [i]));
-		    if (_param->_have_port_ooo_engine_id)
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID         [dest], PORT_READ(in_READ_UNIT_OUT_OOO_ENGINE_ID         [i]));
-		    if (_param->_have_port_packet_id)
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_PACKET_ID             [dest], PORT_READ(in_READ_UNIT_OUT_PACKET_ID             [i]));
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_OPERATION             [dest], PORT_READ(in_READ_UNIT_OUT_OPERATION             [i]));
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_TYPE                  [dest], PORT_READ(in_READ_UNIT_OUT_TYPE                  [i]));
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT          [dest], PORT_READ(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i]));
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RC               [dest], PORT_READ(in_READ_UNIT_OUT_DATA_RC               [i]));
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RD              [dest], PORT_READ(in_READ_UNIT_OUT_WRITE_RD              [i]));
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RE              [dest], PORT_READ(in_READ_UNIT_OUT_WRITE_RE              [i]));
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RE            [dest], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RE            [i]));
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [dest], PORT_READ(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i]));
-		    if (_param->_have_port_load_queue_ptr)
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE  [dest], PORT_READ(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i]));
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_IMMEDIAT              [dest], PORT_READ(in_READ_UNIT_OUT_IMMEDIAT              [i]));
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RA               [dest], PORT_READ(in_READ_UNIT_OUT_DATA_RA               [i]));
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RB               [dest], PORT_READ(in_READ_UNIT_OUT_DATA_RB               [i]));
-		    PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RD            [dest], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RD            [i]));
-		  }
-	      }
-	  }
-	PORT_WRITE(out_READ_UNIT_OUT_ACK [i], ack);
-      }
+		      if (_param->_have_port_context_id)
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_CONTEXT_ID            [dest][port], PORT_READ(in_READ_UNIT_OUT_CONTEXT_ID            [i][j]));
+		      if (_param->_have_port_front_end_id)
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_FRONT_END_ID          [dest][port], PORT_READ(in_READ_UNIT_OUT_FRONT_END_ID          [i][j]));
+		      if (_param->_have_port_ooo_engine_id)
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID         [dest][port], PORT_READ(in_READ_UNIT_OUT_OOO_ENGINE_ID         [i][j]));
+		      if (_param->_have_port_rob_ptr  )
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_PACKET_ID             [dest][port], PORT_READ(in_READ_UNIT_OUT_PACKET_ID             [i][j]));
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_OPERATION             [dest][port], PORT_READ(in_READ_UNIT_OUT_OPERATION             [i][j]));
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_TYPE                  [dest][port], PORT_READ(in_READ_UNIT_OUT_TYPE                  [i][j]));
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT          [dest][port], PORT_READ(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i][j]));
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RC               [dest][port], PORT_READ(in_READ_UNIT_OUT_DATA_RC               [i][j]));
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RD              [dest][port], PORT_READ(in_READ_UNIT_OUT_WRITE_RD              [i][j]));
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RE              [dest][port], PORT_READ(in_READ_UNIT_OUT_WRITE_RE              [i][j]));
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RE            [dest][port], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RE            [i][j]));
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [dest][port], PORT_READ(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i][j]));
+		      if (_param->_have_port_load_queue_ptr)
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE  [dest][port], PORT_READ(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i][j]));
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_IMMEDIAT              [dest][port], PORT_READ(in_READ_UNIT_OUT_IMMEDIAT              [i][j]));
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RA               [dest][port], PORT_READ(in_READ_UNIT_OUT_DATA_RA               [i][j]));
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RB               [dest][port], PORT_READ(in_READ_UNIT_OUT_DATA_RB               [i][j]));
+		      PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RD            [dest][port], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RD            [i][j]));
+		    }
+		}
+	    }
+	  PORT_WRITE(out_READ_UNIT_OUT_ACK [i][j], ack);
+	}
 
     for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-      {
-	PORT_WRITE(out_EXECUTE_UNIT_IN_VAL[i], execute_unit_use[i]);  
-      }
+      for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+	PORT_WRITE(out_EXECUTE_UNIT_IN_VAL[i][j], execute_unit_use[i][j]);
 
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_transition.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_transition.cpp	(revision 82)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_transition.cpp	(revision 88)
@@ -34,15 +34,16 @@
 	// Fill routing table
 	for (uint32_t i=0; i<_param->_nb_read_unit; i++)
-	  for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
-	    // Test if link between src and dest
-	    if (_param->_table_routing [i][j])
-	      // Test the thread accepted by the execute_unit
-	      for (uint32_t k=0; k<_param->_nb_thread; k++)
-		if (_param->_table_execute_thread[j][k])
-		  // Test the type accepted by the execute_unit
-		  for (uint32_t l=0; l<_param->_nb_type; l++)
-		    if (_param->_table_execute_type [j][l])
-		      // push_back == minor have a better priority
-		      _destination [i][k][l].push_back(j);
+	  for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+	    for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+	      // Test if link between src and dest
+	      if (_param->_table_routing [i][x][y])
+		// Test the thread accepted by the execute_unit
+		for (uint32_t k=0; k<_param->_nb_thread; k++)
+		  if (_param->_table_execute_thread[x][k])
+		    // Test the type accepted by the execute_unit
+		    for (uint32_t l=0; l<_param->_nb_type; l++)
+		      if (_param->_table_execute_type [x][l])
+			// push_back == minor have a better priority
+			_destination [i][k][l].push_back(destination_t(x,y));
       }
     else
