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
