Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_allocation.cpp	(revision 112)
@@ -8,4 +8,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/include/Read_queue.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -50,194 +51,119 @@
     // ~~~~~[ Interface : "read_queue_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     {
-      Interface_fifo * interface = _interfaces->set_interface("read_queue_in"
-#ifdef POSITION
-							      ,IN
-							      ,EAST
-							      ,"Input of read_queue"
-#endif
-							      );
+      ALLOC0_INTERFACE_BEGIN("read_queue_in",IN,EAST,"Input of read_queue");
 
-       in_READ_QUEUE_IN_VAL            = interface->set_signal_valack_in        ("val"    , VAL);
-      out_READ_QUEUE_IN_ACK            = interface->set_signal_valack_out       ("ack"    , ACK);
-      if(_param->_have_port_context_id  )
-       in_READ_QUEUE_IN_CONTEXT_ID     = interface->set_signal_in  <Tcontext_t        > ("context_id"   ,_param->_size_context_id       );
-      if(_param->_have_port_front_end_id)
-       in_READ_QUEUE_IN_FRONT_END_ID   = interface->set_signal_in  <Tcontext_t        > ("front_end_id" ,_param->_size_front_end_id     );
-       if(_param->_have_port_ooo_engine_id)
-	 in_READ_QUEUE_IN_OOO_ENGINE_ID  = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id    );
-      if(_param->_have_port_rob_ptr      )
-       in_READ_QUEUE_IN_ROB_ID         = interface->set_signal_in  <Tpacket_t         > ("rob_id"      ,_param->_size_rob_ptr           );
-       in_READ_QUEUE_IN_OPERATION      = interface->set_signal_in  <Toperation_t      > ("operation"   ,_param->_size_operation        );
-       in_READ_QUEUE_IN_TYPE           = interface->set_signal_in  <Ttype_t           > ("type"        ,_param->_size_type             );
-       in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE = interface->set_signal_in  <Tlsq_ptr_t> ("store_queue_ptr_write", _param->_size_store_queue_ptr);
-       if (_param->_have_port_load_queue_ptr)
-       in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE  = interface->set_signal_in  <Tlsq_ptr_t> ("load_queue_ptr_write" , _param->_size_load_queue_ptr);
-       in_READ_QUEUE_IN_HAS_IMMEDIAT   = interface->set_signal_in  <Tcontrol_t        > ("has_immediat",1                             );
-       in_READ_QUEUE_IN_IMMEDIAT       = interface->set_signal_in  <Tgeneral_data_t   > ("immediat"    ,_param->_size_general_data     );
-       in_READ_QUEUE_IN_READ_RA        = interface->set_signal_in  <Tcontrol_t        > ("read_ra"     ,1                             );
-       in_READ_QUEUE_IN_NUM_REG_RA     = interface->set_signal_in  <Tgeneral_address_t> ("num_reg_ra"  ,_param->_size_general_register );
-       in_READ_QUEUE_IN_READ_RB        = interface->set_signal_in  <Tcontrol_t        > ("read_rb"     ,1                             );
-       in_READ_QUEUE_IN_NUM_REG_RB     = interface->set_signal_in  <Tgeneral_address_t> ("num_reg_rb"  ,_param->_size_general_register );
-       in_READ_QUEUE_IN_READ_RC        = interface->set_signal_in  <Tcontrol_t        > ("read_rc"     ,1                             );
-       in_READ_QUEUE_IN_NUM_REG_RC     = interface->set_signal_in  <Tspecial_address_t> ("num_reg_rc"  ,_param->_size_special_register );
-       in_READ_QUEUE_IN_WRITE_RD       = interface->set_signal_in  <Tcontrol_t        > ("write_rd"    ,1                             );
-       in_READ_QUEUE_IN_NUM_REG_RD     = interface->set_signal_in  <Tgeneral_address_t> ("num_reg_rd"  ,_param->_size_general_register );
-       in_READ_QUEUE_IN_WRITE_RE       = interface->set_signal_in  <Tcontrol_t        > ("write_re"    ,1                             );
-       in_READ_QUEUE_IN_NUM_REG_RE     = interface->set_signal_in  <Tspecial_address_t> ("num_reg_re"  ,_param->_size_special_register );      
-     }
+      ALLOC0_VALACK_IN ( in_READ_QUEUE_IN_VAL                  ,VAL);
+      ALLOC0_VALACK_OUT(out_READ_QUEUE_IN_ACK                  ,ACK);
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_CONTEXT_ID           ,"context_id"           ,Tcontext_t        ,_param->_size_context_id      );
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id    );
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_OOO_ENGINE_ID        ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id   );
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_ROB_ID               ,"rob_id"               ,Tpacket_t         ,_param->_size_rob_ptr         );
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation       );
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type            );
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr);
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr);
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1                             );
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data    );
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_READ_RA              ,"read_ra"              ,Tcontrol_t        ,1                             );
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_NUM_REG_RA           ,"num_reg_ra"           ,Tgeneral_address_t,_param->_size_general_register);
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_READ_RB              ,"read_rb"              ,Tcontrol_t        ,1                             );
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_NUM_REG_RB           ,"num_reg_rb"           ,Tgeneral_address_t,_param->_size_general_register);
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_READ_RC              ,"read_rc"              ,Tcontrol_t        ,1                             );
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_NUM_REG_RC           ,"num_reg_rc"           ,Tspecial_address_t,_param->_size_special_register);
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_WRITE_RD             ,"write_rd"             ,Tcontrol_t        ,1                             );
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_NUM_REG_RD           ,"num_reg_rd"           ,Tgeneral_address_t,_param->_size_general_register);
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1                             );
+      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);      
+     
+      ALLOC0_INTERFACE_END();
+    }
 
     // ~~~~~[ Interface : "read_queue_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     {
-      Interface_fifo * interface = _interfaces->set_interface("read_queue_out"
-#ifdef POSITION
-							       ,OUT
-							       ,EAST
-							       ,"Input of read_queue"
-#endif
-							       );
+      ALLOC0_INTERFACE_BEGIN("read_queue_out",OUT,EAST,"Input of read_queue");
       
-      out_READ_QUEUE_OUT_VAL            = interface->set_signal_valack_out       ("val"    , VAL);
-       in_READ_QUEUE_OUT_ACK            = interface->set_signal_valack_in        ("ack"    , ACK);
-
-      if(_param->_have_port_context_id  )
-	out_READ_QUEUE_OUT_CONTEXT_ID     = interface->set_signal_out <Tcontext_t        > ("context_id"   ,_param->_size_context_id       );
-      if(_param->_have_port_front_end_id)
-	out_READ_QUEUE_OUT_FRONT_END_ID   = interface->set_signal_out <Tcontext_t        > ("front_end_id" ,_param->_size_front_end_id     );
-      if(_param->_have_port_ooo_engine_id)
-	out_READ_QUEUE_OUT_OOO_ENGINE_ID  = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id    );
-      if(_param->_have_port_rob_ptr      )
-	out_READ_QUEUE_OUT_ROB_ID         = interface->set_signal_out <Tpacket_t         > ("rob_id"      ,_param->_size_rob_ptr           );
-      out_READ_QUEUE_OUT_OPERATION      = interface->set_signal_out <Toperation_t      > ("operation"   ,_param->_size_operation        );
-      out_READ_QUEUE_OUT_TYPE           = interface->set_signal_out <Ttype_t           > ("type"        ,_param->_size_type             );
-      out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE = interface->set_signal_out <Tlsq_ptr_t> ("store_queue_ptr_write", _param->_size_store_queue_ptr);
-      if (_param->_have_port_load_queue_ptr)
-      out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE  = interface->set_signal_out <Tlsq_ptr_t> ("load_queue_ptr_write" , _param->_size_load_queue_ptr);
-      out_READ_QUEUE_OUT_HAS_IMMEDIAT   = interface->set_signal_out <Tcontrol_t        > ("has_immediat",1                             );
-      out_READ_QUEUE_OUT_IMMEDIAT       = interface->set_signal_out <Tgeneral_data_t   > ("immediat"    ,_param->_size_general_data     );
-//       out_READ_QUEUE_OUT_READ_RA        = interface->set_signal_out <Tcontrol_t        > ("read_ra"     ,1                             );
-      out_READ_QUEUE_OUT_NUM_REG_RA     = interface->set_signal_out <Tgeneral_address_t> ("num_reg_ra"  ,_param->_size_general_register );
-      out_READ_QUEUE_OUT_DATA_RA_VAL    = interface->set_signal_out <Tcontrol_t        > ("data_ra_val" ,1                             );
-      out_READ_QUEUE_OUT_DATA_RA        = interface->set_signal_out <Tgeneral_data_t   > ("data_ra"     ,_param->_size_general_data     );
-//       out_READ_QUEUE_OUT_READ_RB        = interface->set_signal_out <Tcontrol_t        > ("read_rb"     ,1                             );
-      out_READ_QUEUE_OUT_NUM_REG_RB     = interface->set_signal_out <Tgeneral_address_t> ("num_reg_rb"  ,_param->_size_general_register );
-      out_READ_QUEUE_OUT_DATA_RB_VAL    = interface->set_signal_out <Tcontrol_t        > ("data_rb_val" ,1                             );
-      out_READ_QUEUE_OUT_DATA_RB        = interface->set_signal_out <Tgeneral_data_t   > ("data_rb"     ,_param->_size_general_data     );
-//       out_READ_QUEUE_OUT_READ_RC        = interface->set_signal_out <Tcontrol_t        > ("read_rc"     ,1                             );
-      out_READ_QUEUE_OUT_NUM_REG_RC     = interface->set_signal_out <Tspecial_address_t> ("num_reg_rc"  ,_param->_size_special_register );
-      out_READ_QUEUE_OUT_DATA_RC_VAL    = interface->set_signal_out <Tcontrol_t        > ("data_rc_val" ,1                             );
-      out_READ_QUEUE_OUT_DATA_RC        = interface->set_signal_out <Tspecial_data_t   > ("data_rc"     ,_param->_size_special_data     );
-      out_READ_QUEUE_OUT_WRITE_RD       = interface->set_signal_out <Tcontrol_t        > ("write_rd"    ,1                             );
-      out_READ_QUEUE_OUT_NUM_REG_RD     = interface->set_signal_out <Tgeneral_address_t> ("num_reg_rd"  ,_param->_size_general_register );
-      out_READ_QUEUE_OUT_WRITE_RE       = interface->set_signal_out <Tcontrol_t        > ("write_re"    ,1                             );
-      out_READ_QUEUE_OUT_NUM_REG_RE     = interface->set_signal_out <Tspecial_address_t> ("num_reg_re"  ,_param->_size_special_register );      
-     }
+      ALLOC0_VALACK_OUT(out_READ_QUEUE_OUT_VAL                   ,VAL);
+      ALLOC0_VALACK_IN ( in_READ_QUEUE_OUT_ACK                   ,ACK);
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_CONTEXT_ID            ,"context_id"           ,Tcontext_t        ,_param->_size_context_id       );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_FRONT_END_ID          ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id     );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_OOO_ENGINE_ID         ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id    );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_ROB_ID                ,"rob_id"               ,Tpacket_t         ,_param->_size_rob_ptr          );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_OPERATION             ,"operation"            ,Toperation_t      ,_param->_size_operation        );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_TYPE                  ,"type"                 ,Ttype_t           ,_param->_size_type             );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE ,"store_queue_ptr_write",Tlsq_ptr_t        , _param->_size_store_queue_ptr );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE  ,"load_queue_ptr_write" ,Tlsq_ptr_t        , _param->_size_load_queue_ptr  );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_HAS_IMMEDIAT          ,"has_immediat"         ,Tcontrol_t        ,1                              );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_IMMEDIAT              ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data     );
+//    ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_READ_RA               ,"read_ra"              ,Tcontrol_t        ,1                              );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_NUM_REG_RA            ,"num_reg_ra"           ,Tgeneral_address_t,_param->_size_general_register );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_DATA_RA_VAL           ,"data_ra_val"          ,Tcontrol_t        ,1                              );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_DATA_RA               ,"data_ra"              ,Tgeneral_data_t   ,_param->_size_general_data     );
+//    ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_READ_RB               ,"read_rb"              ,Tcontrol_t        ,1                              );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_NUM_REG_RB            ,"num_reg_rb"           ,Tgeneral_address_t,_param->_size_general_register );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_DATA_RB_VAL           ,"data_rb_val"          ,Tcontrol_t        ,1                              );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_DATA_RB               ,"data_rb"              ,Tgeneral_data_t   ,_param->_size_general_data     );
+//    ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_READ_RC               ,"read_rc"              ,Tcontrol_t        ,1                              );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_NUM_REG_RC            ,"num_reg_rc"           ,Tspecial_address_t,_param->_size_special_register );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_DATA_RC_VAL           ,"data_rc_val"          ,Tcontrol_t        ,1                              );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_DATA_RC               ,"data_rc"              ,Tspecial_data_t   ,_param->_size_special_data     );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_WRITE_RD              ,"write_rd"             ,Tcontrol_t        ,1                              );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_NUM_REG_RD            ,"num_reg_rd"           ,Tgeneral_address_t,_param->_size_general_register );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_WRITE_RE              ,"write_re"             ,Tcontrol_t        ,1                              );
+      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_NUM_REG_RE            ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register );      
+     
+      ALLOC0_INTERFACE_END();
+    }
 
     // ~~~~~[ Interface : "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE_BEGIN("gpr_read",IN,SOUTH,_("Interface with the General RegisterFile"),_param->_nb_gpr_read);
+
+      ALLOC1_VALACK_OUT(out_GPR_READ_VAL           ,VAL);
+      ALLOC1_VALACK_IN ( in_GPR_READ_ACK           ,ACK);
+      ALLOC1_SIGNAL_OUT(out_GPR_READ_OOO_ENGINE_ID ,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
+      ALLOC1_SIGNAL_OUT(out_GPR_READ_NUM_REG       ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
+      ALLOC1_SIGNAL_IN ( in_GPR_READ_DATA          ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
+      ALLOC1_SIGNAL_IN ( in_GPR_READ_DATA_VAL      ,"data_val"     ,Tcontrol_t        ,1);
+
+      ALLOC1_INTERFACE_END(_param->_nb_gpr_read);
+    }
     
-    out_GPR_READ_VAL          = new SC_OUT(Tcontrol_t        ) * [_param->_nb_gpr_read];
-     in_GPR_READ_ACK          = new SC_IN (Tcontrol_t        ) * [_param->_nb_gpr_read];
-    if(_param->_have_port_ooo_engine_id)
-      out_GPR_READ_OOO_ENGINE_ID= new SC_OUT(Tcontext_t        ) * [_param->_nb_gpr_read];
-    out_GPR_READ_NUM_REG      = new SC_OUT(Tgeneral_address_t) * [_param->_nb_gpr_read];
-     in_GPR_READ_DATA         = new SC_IN (Tgeneral_data_t   ) * [_param->_nb_gpr_read];
-     in_GPR_READ_DATA_VAL     = new SC_IN (Tcontrol_t        ) * [_param->_nb_gpr_read];
+    // ~~~~~[ Interface : "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE_BEGIN("spr_read",IN,SOUTH,_("Interface with the General RegisterFile"),_param->_nb_spr_read);
 
-    for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
-      {
-        Interface_fifo * interface = _interfaces->set_interface("gpr_read_"+toString(i)
-#ifdef POSITION
-                                                                , IN  
-                                                                ,SOUTH
-                                                                , "Interface with the General RegisterFile."
-#endif
-                                                                );
+      ALLOC1_VALACK_OUT(out_SPR_READ_VAL           ,VAL);
+      ALLOC1_VALACK_IN ( in_SPR_READ_ACK           ,ACK);
+      ALLOC1_SIGNAL_OUT(out_SPR_READ_OOO_ENGINE_ID ,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
+      ALLOC1_SIGNAL_OUT(out_SPR_READ_NUM_REG       ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
+      ALLOC1_SIGNAL_IN ( in_SPR_READ_DATA          ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
+      ALLOC1_SIGNAL_IN ( in_SPR_READ_DATA_VAL      ,"data_val"     ,Tcontrol_t        ,1);
 
-	out_GPR_READ_VAL           [i] = interface->set_signal_valack_out       ("val"    , VAL);
-	 in_GPR_READ_ACK           [i] = interface->set_signal_valack_in        ("ack"    , ACK);
-	if(_param->_have_port_ooo_engine_id)
-	  out_GPR_READ_OOO_ENGINE_ID [i] = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
-	out_GPR_READ_NUM_REG       [i] = interface->set_signal_out <Tgeneral_address_t> ("num_reg"  ,_param->_size_general_register);
-	 in_GPR_READ_DATA          [i] = interface->set_signal_in  <Tgeneral_data_t   > ("data"     ,_param->_size_general_data);
-	 in_GPR_READ_DATA_VAL      [i] = interface->set_signal_in  <Tcontrol_t        > ("data_val" ,1);
-      }
-     
-    // ~~~~~[ Interface : "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    
-    out_SPR_READ_VAL          = new SC_OUT(Tcontrol_t        ) * [_param->_nb_spr_read];
-     in_SPR_READ_ACK          = new SC_IN (Tcontrol_t        ) * [_param->_nb_spr_read];
-    if(_param->_have_port_ooo_engine_id) 
-      out_SPR_READ_OOO_ENGINE_ID= new SC_OUT(Tcontext_t        ) * [_param->_nb_spr_read];
-    out_SPR_READ_NUM_REG      = new SC_OUT(Tspecial_address_t) * [_param->_nb_spr_read];
-     in_SPR_READ_DATA         = new SC_IN (Tspecial_data_t   ) * [_param->_nb_spr_read];
-     in_SPR_READ_DATA_VAL     = new SC_IN (Tcontrol_t        ) * [_param->_nb_spr_read];
-
-    for (uint32_t i=0; i<_param->_nb_spr_read; i++)
-      {
-        Interface_fifo * interface = _interfaces->set_interface("spr_read_"+toString(i)
-#ifdef POSITION
-                                                                , IN  
-                                                                ,SOUTH
-                                                                , "Interface with the Special RegisterFile."
-#endif
-                                                                );
-
-	out_SPR_READ_VAL           [i] = interface->set_signal_valack_out       ("val"    , VAL);
-	 in_SPR_READ_ACK           [i] = interface->set_signal_valack_in        ("ack"    , ACK);
-	if(_param->_have_port_ooo_engine_id)
-	  out_SPR_READ_OOO_ENGINE_ID [i] = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
-	out_SPR_READ_NUM_REG       [i] = interface->set_signal_out <Tspecial_address_t> ("num_reg"   ,_param->_size_special_register);
-	 in_SPR_READ_DATA          [i] = interface->set_signal_in  <Tspecial_data_t   > ("data"      ,_param->_size_special_data);
-	 in_SPR_READ_DATA_VAL      [i] = interface->set_signal_in  <Tcontrol_t        > ("data_val"  ,1);
-      }
+      ALLOC1_INTERFACE_END(_param->_nb_spr_read);
+    }
 
     // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    
-     in_GPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_gpr_write];
-     if(_param->_have_port_ooo_engine_id)
-       in_GPR_WRITE_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_gpr_write];
-     in_GPR_WRITE_NUM_REG      = new SC_IN (Tgeneral_address_t) * [_param->_nb_gpr_write];
-     in_GPR_WRITE_DATA         = new SC_IN (Tgeneral_data_t   ) * [_param->_nb_gpr_write];
+    {
+      ALLOC1_INTERFACE_BEGIN("gpr_write",IN,SOUTH,_("Interface with write queue to bypass the write in the RegisterFile"),_param->_nb_gpr_write);
 
-    for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
-      {
-        Interface_fifo * interface = _interfaces->set_interface("gpr_write_"+toString(i)
-#ifdef POSITION
-                                                                , IN  
-                                                                ,SOUTH
-                                                                , "Interface with write queue to bypass the write in the RegisterFile."
-#endif
-                                                                );
-
-	 in_GPR_WRITE_VAL           [i] = interface->set_signal_valack_in        ("val"    , VAL);
-	 if(_param->_have_port_ooo_engine_id)
-	   in_GPR_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
-	 in_GPR_WRITE_NUM_REG       [i] = interface->set_signal_in  <Tgeneral_address_t> ("num_reg"   ,_param->_size_general_register);
-	 in_GPR_WRITE_DATA          [i] = interface->set_signal_in  <Tgeneral_data_t   > ("data"      ,_param->_size_general_data);
-      }
+      ALLOC1_VALACK_IN (in_GPR_WRITE_VAL           ,VAL);
+      ALLOC1_SIGNAL_IN (in_GPR_WRITE_OOO_ENGINE_ID ,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
+      ALLOC1_SIGNAL_IN (in_GPR_WRITE_NUM_REG       ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
+      ALLOC1_SIGNAL_IN (in_GPR_WRITE_DATA          ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
+      
+      ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
+    }
 
     // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    
-     in_SPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_spr_write];
-     if(_param->_have_port_ooo_engine_id)
-       in_SPR_WRITE_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_spr_write];
-     in_SPR_WRITE_NUM_REG      = new SC_IN (Tspecial_address_t) * [_param->_nb_spr_write];
-     in_SPR_WRITE_DATA         = new SC_IN (Tspecial_data_t   ) * [_param->_nb_spr_write];
+    {
+      ALLOC1_INTERFACE_BEGIN("spr_write",IN,SOUTH,_("Interface with write queue to bypass the write in the RegisterFile"),_param->_nb_spr_write);
 
-    for (uint32_t i=0; i<_param->_nb_spr_write; i++)
-      {
-        Interface_fifo * interface = _interfaces->set_interface("spr_write_"+toString(i)
-#ifdef POSITION
-                                                                , IN  
-                                                                ,SOUTH
-                                                                , "Interface with write queue to bypass the write in the RegisterFile."
-#endif
-                                                                );
-
-	 in_SPR_WRITE_VAL           [i] = interface->set_signal_valack_in ("val"    , VAL);
-	 if(_param->_have_port_ooo_engine_id)
-	   in_SPR_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
-	 in_SPR_WRITE_NUM_REG       [i] = interface->set_signal_in  <Tspecial_address_t> ("num_reg"   ,_param->_size_special_register);
-	 in_SPR_WRITE_DATA          [i] = interface->set_signal_in  <Tspecial_data_t   > ("data"      ,_param->_size_special_data);
-      }
+      ALLOC1_VALACK_IN (in_SPR_WRITE_VAL           ,VAL);
+      ALLOC1_SIGNAL_IN (in_SPR_WRITE_OOO_ENGINE_ID ,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
+      ALLOC1_SIGNAL_IN (in_SPR_WRITE_NUM_REG       ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
+      ALLOC1_SIGNAL_IN (in_SPR_WRITE_DATA          ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
+      
+      ALLOC1_INTERFACE_END(_param->_nb_spr_write);
+    }
 
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_deallocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_deallocation.cpp	(revision 112)
@@ -8,4 +8,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/include/Read_queue.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -25,109 +26,82 @@
     if (usage_is_set(_usage,USE_SYSTEMC))
       {
-    // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete     in_CLOCK ;
-    delete     in_NRESET;
+        delete     in_CLOCK ;
+        delete     in_NRESET;
 
-    // ~~~~~[ Interface : "read_queue_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete     in_READ_QUEUE_IN_VAL            ;
-    delete    out_READ_QUEUE_IN_ACK            ;
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_VAL                   ,1                             );
+        DELETE0_SIGNAL(out_READ_QUEUE_IN_ACK                   ,1                             );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_CONTEXT_ID            ,_param->_size_context_id      );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_FRONT_END_ID          ,_param->_size_front_end_id    );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_OOO_ENGINE_ID         ,_param->_size_ooo_engine_id   );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_ROB_ID                ,_param->_size_rob_ptr         );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_OPERATION             ,_param->_size_operation       );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_TYPE                  ,_param->_size_type            );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE ,_param->_size_store_queue_ptr );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE  ,_param->_size_load_queue_ptr  );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_HAS_IMMEDIAT          ,1                             );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_IMMEDIAT              ,_param->_size_general_data    );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_READ_RA               ,1                             );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_NUM_REG_RA            ,_param->_size_general_register);
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_READ_RB               ,1                             );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_NUM_REG_RB            ,_param->_size_general_register);
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_READ_RC               ,1                             );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_NUM_REG_RC            ,_param->_size_special_register);
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_WRITE_RD              ,1                             );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_NUM_REG_RD            ,_param->_size_general_register);
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_WRITE_RE              ,1                             );
+        DELETE0_SIGNAL( in_READ_QUEUE_IN_NUM_REG_RE            ,_param->_size_special_register);
+      
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_VAL                  ,1                              );
+        DELETE0_SIGNAL( in_READ_QUEUE_OUT_ACK                  ,1                              );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_CONTEXT_ID           ,_param->_size_context_id       );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_FRONT_END_ID         ,_param->_size_front_end_id     );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_OOO_ENGINE_ID        ,_param->_size_ooo_engine_id    );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_ROB_ID               ,_param->_size_rob_ptr          );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_OPERATION            ,_param->_size_operation        );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_TYPE                 ,_param->_size_type             );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE, _param->_size_store_queue_ptr );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE , _param->_size_load_queue_ptr  );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_HAS_IMMEDIAT         ,1                              );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_IMMEDIAT             ,_param->_size_general_data     );
+//      DELETE0_SIGNAL(out_READ_QUEUE_OUT_READ_RA              ,1                              );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_NUM_REG_RA           ,_param->_size_general_register );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_DATA_RA_VAL          ,1                              );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_DATA_RA              ,_param->_size_general_data     );
+//      DELETE0_SIGNAL(out_READ_QUEUE_OUT_READ_RB              ,1                              );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_NUM_REG_RB           ,_param->_size_general_register );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_DATA_RB_VAL          ,1                              );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_DATA_RB              ,_param->_size_general_data     );
+//      DELETE0_SIGNAL(out_READ_QUEUE_OUT_READ_RC              ,1                              );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_NUM_REG_RC           ,_param->_size_special_register );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_DATA_RC_VAL          ,1                              );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_DATA_RC              ,_param->_size_special_data     );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_WRITE_RD             ,1                              );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_NUM_REG_RD           ,_param->_size_general_register );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_WRITE_RE             ,1                              );
+        DELETE0_SIGNAL(out_READ_QUEUE_OUT_NUM_REG_RE           ,_param->_size_special_register );      
 
-    if(_param->_have_port_context_id   )
-      delete     in_READ_QUEUE_IN_CONTEXT_ID     ;
-    if(_param->_have_port_front_end_id )
-      delete     in_READ_QUEUE_IN_FRONT_END_ID   ;
-    if(_param->_have_port_ooo_engine_id)
-      delete     in_READ_QUEUE_IN_OOO_ENGINE_ID  ;
-    if(_param->_have_port_rob_ptr       )
-      delete     in_READ_QUEUE_IN_ROB_ID         ;
-    delete     in_READ_QUEUE_IN_OPERATION      ;
-    delete     in_READ_QUEUE_IN_TYPE           ;
-    delete     in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE;
-    if (_param->_have_port_load_queue_ptr)
-    delete     in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ;
-    delete     in_READ_QUEUE_IN_HAS_IMMEDIAT   ;
-    delete     in_READ_QUEUE_IN_IMMEDIAT       ;
-    delete     in_READ_QUEUE_IN_READ_RA        ;
-    delete     in_READ_QUEUE_IN_NUM_REG_RA     ;
-    delete     in_READ_QUEUE_IN_READ_RB        ;
-    delete     in_READ_QUEUE_IN_NUM_REG_RB     ;
-    delete     in_READ_QUEUE_IN_READ_RC        ;
-    delete     in_READ_QUEUE_IN_NUM_REG_RC     ;
-    delete     in_READ_QUEUE_IN_WRITE_RD       ;
-    delete     in_READ_QUEUE_IN_NUM_REG_RD     ;
-    delete     in_READ_QUEUE_IN_WRITE_RE       ;
-    delete     in_READ_QUEUE_IN_NUM_REG_RE     ;
+        DELETE1_SIGNAL(out_GPR_READ_VAL           ,_param->_nb_gpr_read,1);
+        DELETE1_SIGNAL( in_GPR_READ_ACK           ,_param->_nb_gpr_read,1);
+        DELETE1_SIGNAL(out_GPR_READ_OOO_ENGINE_ID ,_param->_nb_gpr_read,_param->_size_ooo_engine_id);
+        DELETE1_SIGNAL(out_GPR_READ_NUM_REG       ,_param->_nb_gpr_read,_param->_size_general_register);
+        DELETE1_SIGNAL( in_GPR_READ_DATA          ,_param->_nb_gpr_read,_param->_size_general_data);
+        DELETE1_SIGNAL( in_GPR_READ_DATA_VAL      ,_param->_nb_gpr_read,1);
 
-    // ~~~~~[ Interface : "read_queue_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete    out_READ_QUEUE_OUT_VAL            ;
-    delete     in_READ_QUEUE_OUT_ACK            ;
+        DELETE1_SIGNAL(out_SPR_READ_VAL           ,_param->_nb_spr_read,1);
+        DELETE1_SIGNAL( in_SPR_READ_ACK           ,_param->_nb_spr_read,1);
+        DELETE1_SIGNAL(out_SPR_READ_OOO_ENGINE_ID ,_param->_nb_spr_read,_param->_size_ooo_engine_id);
+        DELETE1_SIGNAL(out_SPR_READ_NUM_REG       ,_param->_nb_spr_read,_param->_size_general_register);
+        DELETE1_SIGNAL( in_SPR_READ_DATA          ,_param->_nb_spr_read,_param->_size_general_data);
+        DELETE1_SIGNAL( in_SPR_READ_DATA_VAL      ,_param->_nb_spr_read,1);
+        
+        DELETE1_SIGNAL(in_GPR_WRITE_VAL           ,_param->_nb_gpr_write,1);
+        DELETE1_SIGNAL(in_GPR_WRITE_OOO_ENGINE_ID ,_param->_nb_gpr_write,_param->_size_ooo_engine_id);
+        DELETE1_SIGNAL(in_GPR_WRITE_NUM_REG       ,_param->_nb_gpr_write,_param->_size_general_register);
+        DELETE1_SIGNAL(in_GPR_WRITE_DATA          ,_param->_nb_gpr_write,_param->_size_general_data);
 
-    if(_param->_have_port_context_id   )
-      delete    out_READ_QUEUE_OUT_CONTEXT_ID     ;
-    if(_param->_have_port_front_end_id )
-      delete    out_READ_QUEUE_OUT_FRONT_END_ID   ;
-    if(_param->_have_port_ooo_engine_id)
-      delete    out_READ_QUEUE_OUT_OOO_ENGINE_ID  ;
-    if(_param->_have_port_rob_ptr       )
-      delete    out_READ_QUEUE_OUT_ROB_ID         ;
-    delete    out_READ_QUEUE_OUT_OPERATION      ;
-    delete    out_READ_QUEUE_OUT_TYPE           ;
-    delete    out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE;
-    if (_param->_have_port_load_queue_ptr)
-    delete    out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE ;
-    delete    out_READ_QUEUE_OUT_HAS_IMMEDIAT   ;
-    delete    out_READ_QUEUE_OUT_IMMEDIAT       ;
-//     delete    out_READ_QUEUE_OUT_READ_RA        ;
-    delete    out_READ_QUEUE_OUT_NUM_REG_RA     ;
-    delete    out_READ_QUEUE_OUT_DATA_RA_VAL    ;
-    delete    out_READ_QUEUE_OUT_DATA_RA        ;
-//     delete    out_READ_QUEUE_OUT_READ_RB        ;
-    delete    out_READ_QUEUE_OUT_NUM_REG_RB     ;
-    delete    out_READ_QUEUE_OUT_DATA_RB_VAL    ;
-    delete    out_READ_QUEUE_OUT_DATA_RB        ;
-//     delete    out_READ_QUEUE_OUT_READ_RC        ;
-    delete    out_READ_QUEUE_OUT_NUM_REG_RC     ;
-    delete    out_READ_QUEUE_OUT_DATA_RC_VAL    ;
-    delete    out_READ_QUEUE_OUT_DATA_RC        ;
-    delete    out_READ_QUEUE_OUT_WRITE_RD       ;
-    delete    out_READ_QUEUE_OUT_NUM_REG_RD     ;
-    delete    out_READ_QUEUE_OUT_WRITE_RE       ;
-    delete    out_READ_QUEUE_OUT_NUM_REG_RE     ;
-
-    // ~~~~~[ Interface : "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    
-    delete [] out_GPR_READ_VAL       ;
-    delete []  in_GPR_READ_ACK       ;
-    if(_param->_have_port_ooo_engine_id)
-      delete [] out_GPR_READ_OOO_ENGINE_ID;
-    delete [] out_GPR_READ_NUM_REG   ;
-    delete []  in_GPR_READ_DATA      ;
-    delete []  in_GPR_READ_DATA_VAL  ;
-
-    // ~~~~~[ Interface : "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    
-    delete [] out_SPR_READ_VAL       ;
-    delete []  in_SPR_READ_ACK       ;
-    if(_param->_have_port_ooo_engine_id)
-      delete [] out_SPR_READ_OOO_ENGINE_ID;
-    delete [] out_SPR_READ_NUM_REG   ;
-    delete []  in_SPR_READ_DATA      ;
-    delete []  in_SPR_READ_DATA_VAL  ;
-
-    // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    
-    delete []  in_GPR_WRITE_VAL       ;
-    if(_param->_have_port_ooo_engine_id)
-      delete []  in_GPR_WRITE_OOO_ENGINE_ID;
-    delete []  in_GPR_WRITE_NUM_REG   ;
-    delete []  in_GPR_WRITE_DATA      ;
-
-    // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    
-    delete []  in_SPR_WRITE_VAL       ;
-    if(_param->_have_port_ooo_engine_id)
-      delete []  in_SPR_WRITE_OOO_ENGINE_ID;
-    delete []  in_SPR_WRITE_NUM_REG   ;
-    delete []  in_SPR_WRITE_DATA      ;
+        DELETE1_SIGNAL(in_SPR_WRITE_VAL           ,_param->_nb_spr_write,1);
+        DELETE1_SIGNAL(in_SPR_WRITE_OOO_ENGINE_ID ,_param->_nb_spr_write,_param->_size_ooo_engine_id);
+        DELETE1_SIGNAL(in_SPR_WRITE_NUM_REG       ,_param->_nb_spr_write,_param->_size_general_register);
+        DELETE1_SIGNAL(in_SPR_WRITE_DATA          ,_param->_nb_spr_write,_param->_size_general_data);
       }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_transition.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_transition.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_transition.cpp	(revision 112)
@@ -34,5 +34,10 @@
 	// > 2) flush all slot in one cycle
 
-        _queue->clear();
+        while (_queue->empty() == false)
+          {
+            delete _queue->front();
+            _queue->pop_front();
+          }
+        // _queue->clear();
 
 	// Init, else error in registerfile
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/SelfTest/src/test.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/SelfTest/src/test.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/SelfTest/src/test.cpp	(revision 112)
@@ -7,5 +7,5 @@
  */
 #define NB_ITERATION  1
-#define CYCLE_MAX     (2048*NB_ITERATION)
+#define CYCLE_MAX     (10000*NB_ITERATION)
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/SelfTest/include/test.h"
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_allocation.cpp	(revision 112)
@@ -8,4 +8,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/include/Reservation_station.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -43,5 +44,5 @@
 							 ,IN
 							 ,SOUTH,
-							 "Generalist interface"
+							 _("Generalist interface")
 #endif
 							 );
@@ -50,219 +51,123 @@
      in_NRESET       = interface->set_signal_in  <Tcontrol_t> ("nreset",1, RESET_VHDL_YES);
 
-    // ~~~~~[ Interface : "insert" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    {
-      Interface_fifo * interface = _interfaces->set_interface("insert"
-#ifdef POSITION
-							       ,IN
-							       ,EAST
-							       ,"Input of reservation_station"
-#endif
-							       );
-      
-       in_INSERT_VAL            = interface->set_signal_valack_in  (VAL);
-      out_INSERT_ACK            = interface->set_signal_valack_out (ACK);
-      if (_param->_have_port_context_id)
-       in_INSERT_CONTEXT_ID     = interface->set_signal_in <Tcontext_t        > ("context_id"     ,_param->_size_context_id       );
-      if (_param->_have_port_front_end_id)
-       in_INSERT_FRONT_END_ID   = interface->set_signal_in <Tcontext_t        > ("front_end_id"   ,_param->_size_front_end_id     );
-      if (_param->_have_port_ooo_engine_id)
-       in_INSERT_OOO_ENGINE_ID  = interface->set_signal_in <Tcontext_t        > ("ooo_engine_id"  ,_param->_size_ooo_engine_id    );
-      if (_param->_have_port_rob_ptr)
-       in_INSERT_ROB_ID         = interface->set_signal_in <Tpacket_t         > ("rob_id"         ,_param->_size_rob_ptr        );
-       in_INSERT_OPERATION      = interface->set_signal_in <Toperation_t      > ("operation"      ,_param->_size_operation        );
-       in_INSERT_TYPE           = interface->set_signal_in <Ttype_t           > ("type"           ,_param->_size_type             );
-       in_INSERT_STORE_QUEUE_PTR_WRITE = interface->set_signal_in <Tlsq_ptr_t> ("store_queue_ptr_write" ,_param->_size_store_queue_ptr);
-       if (_param->_have_port_load_queue_ptr)
-       in_INSERT_LOAD_QUEUE_PTR_WRITE  = interface->set_signal_in <Tlsq_ptr_t> ("load_queue_ptr_write"  ,_param->_size_load_queue_ptr );
-       in_INSERT_HAS_IMMEDIAT   = interface->set_signal_in <Tcontrol_t        > ("has_immediat"   ,1                             );
-       in_INSERT_IMMEDIAT       = interface->set_signal_in <Tgeneral_data_t   > ("immediat"       ,_param->_size_general_data     );
-//     in_INSERT_READ_RA        = interface->set_signal_in <Tcontrol_t        > ("read_ra"        ,1                             );
-       in_INSERT_NUM_REG_RA     = interface->set_signal_in <Tgeneral_address_t> ("num_reg_ra"     ,_param->_size_general_register );
-       in_INSERT_DATA_RA_VAL    = interface->set_signal_in <Tcontrol_t        > ("data_ra_val"    ,1                             );
-       in_INSERT_DATA_RA        = interface->set_signal_in <Tgeneral_data_t   > ("data_ra"        ,_param->_size_general_data     );
-//     in_INSERT_READ_RB        = interface->set_signal_in <Tcontrol_t        > ("read_rb"        ,1                             );
-       in_INSERT_NUM_REG_RB     = interface->set_signal_in <Tgeneral_address_t> ("num_reg_rb"     ,_param->_size_general_register );
-       in_INSERT_DATA_RB_VAL    = interface->set_signal_in <Tcontrol_t        > ("data_rb_val"    ,1                             );
-       in_INSERT_DATA_RB        = interface->set_signal_in <Tgeneral_data_t   > ("data_rb"        ,_param->_size_general_data     );
-//     in_INSERT_READ_RC        = interface->set_signal_in <Tcontrol_t        > ("read_rc"        ,1                             );
-       in_INSERT_NUM_REG_RC     = interface->set_signal_in <Tspecial_address_t> ("num_reg_rc"     ,_param->_size_special_register );
-       in_INSERT_DATA_RC_VAL    = interface->set_signal_in <Tcontrol_t        > ("data_rc_val"    ,1                             );
-       in_INSERT_DATA_RC        = interface->set_signal_in <Tspecial_data_t   > ("data_rc"        ,_param->_size_special_data     );
-       in_INSERT_WRITE_RD       = interface->set_signal_in <Tcontrol_t        > ("write_rd"       ,1                             );
-       in_INSERT_NUM_REG_RD     = interface->set_signal_in <Tgeneral_address_t> ("num_reg_rd"     ,_param->_size_general_register );
-       in_INSERT_WRITE_RE       = interface->set_signal_in <Tcontrol_t        > ("write_re"       ,1                             );
-       in_INSERT_NUM_REG_RE     = interface->set_signal_in <Tspecial_address_t> ("num_reg_re"     ,_param->_size_special_register );      
+     // ~~~~~[ Interface : "insert" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
+       ALLOC0_INTERFACE_BEGIN("insert",IN,EAST,_("Input of reservation_station"));
+       
+       ALLOC0_VALACK_IN ( in_INSERT_VAL                  ,VAL);
+       ALLOC0_VALACK_OUT(out_INSERT_ACK                  ,ACK);
+       ALLOC0_SIGNAL_IN ( in_INSERT_CONTEXT_ID           ,"context_id"           ,Tcontext_t        ,_param->_size_context_id      );
+       ALLOC0_SIGNAL_IN ( in_INSERT_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id    );
+       ALLOC0_SIGNAL_IN ( in_INSERT_OOO_ENGINE_ID        ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id   );
+       ALLOC0_SIGNAL_IN ( in_INSERT_ROB_ID               ,"rob_id"               ,Tpacket_t         ,_param->_size_rob_ptr         );
+       ALLOC0_SIGNAL_IN ( in_INSERT_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation       );
+       ALLOC0_SIGNAL_IN ( in_INSERT_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type            );
+       ALLOC0_SIGNAL_IN ( in_INSERT_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr );
+       ALLOC0_SIGNAL_IN ( in_INSERT_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr  );
+       ALLOC0_SIGNAL_IN ( in_INSERT_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1                             );
+       ALLOC0_SIGNAL_IN ( in_INSERT_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data    );
+//     ALLOC0_SIGNAL_IN ( in_INSERT_READ_RA              ,"read_ra"              ,Tcontrol_t        ,1                             );
+       ALLOC0_SIGNAL_IN ( in_INSERT_NUM_REG_RA           ,"num_reg_ra"           ,Tgeneral_address_t,_param->_size_general_register);
+       ALLOC0_SIGNAL_IN ( in_INSERT_DATA_RA_VAL          ,"data_ra_val"          ,Tcontrol_t        ,1                             );
+       ALLOC0_SIGNAL_IN ( in_INSERT_DATA_RA              ,"data_ra"              ,Tgeneral_data_t   ,_param->_size_general_data    );
+//     ALLOC0_SIGNAL_IN ( in_INSERT_READ_RB              ,"read_rb"              ,Tcontrol_t        ,1                             );
+       ALLOC0_SIGNAL_IN ( in_INSERT_NUM_REG_RB           ,"num_reg_rb"           ,Tgeneral_address_t,_param->_size_general_register);
+       ALLOC0_SIGNAL_IN ( in_INSERT_DATA_RB_VAL          ,"data_rb_val"          ,Tcontrol_t        ,1                             );
+       ALLOC0_SIGNAL_IN ( in_INSERT_DATA_RB              ,"data_rb"              ,Tgeneral_data_t   ,_param->_size_general_data    );
+//     ALLOC0_SIGNAL_IN ( in_INSERT_READ_RC              ,"read_rc"              ,Tcontrol_t        ,1                             );
+       ALLOC0_SIGNAL_IN ( in_INSERT_NUM_REG_RC           ,"num_reg_rc"           ,Tspecial_address_t,_param->_size_special_register);
+       ALLOC0_SIGNAL_IN ( in_INSERT_DATA_RC_VAL          ,"data_rc_val"          ,Tcontrol_t        ,1                             );
+       ALLOC0_SIGNAL_IN ( in_INSERT_DATA_RC              ,"data_rc"              ,Tspecial_data_t   ,_param->_size_special_data    );
+       ALLOC0_SIGNAL_IN ( in_INSERT_WRITE_RD             ,"write_rd"             ,Tcontrol_t        ,1                             );
+       ALLOC0_SIGNAL_IN ( in_INSERT_NUM_REG_RD           ,"num_reg_rd"           ,Tgeneral_address_t,_param->_size_general_register);
+       ALLOC0_SIGNAL_IN ( in_INSERT_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1                             );
+       ALLOC0_SIGNAL_IN ( in_INSERT_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);
+
+       ALLOC0_INTERFACE_END();
+     }
+     
+     // ~~~~~[ Interface : "retire" ]~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
+       ALLOC1_INTERFACE_BEGIN("retire",OUT,WEST,_("Output of reservation_station"),_param->_nb_inst_retire);
+       
+       ALLOC1_VALACK_OUT(out_RETIRE_VAL                  ,VAL);
+       ALLOC1_VALACK_IN ( in_RETIRE_ACK                  ,ACK);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_CONTEXT_ID           ,"context_id"           ,Tcontext_t        ,_param->_size_context_id);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_OOO_ENGINE_ID        ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_ROB_ID               ,"rob_id"               ,Tpacket_t         ,_param->_size_rob_ptr);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr );
+       ALLOC1_SIGNAL_OUT(out_RETIRE_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_DATA_RA              ,"data_ra"              ,Tgeneral_data_t   ,_param->_size_general_data);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_DATA_RB              ,"data_rb"              ,Tgeneral_data_t   ,_param->_size_general_data);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_DATA_RC              ,"data_rc"              ,Tspecial_data_t   ,_param->_size_special_data);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_WRITE_RD             ,"write_rd"             ,Tcontrol_t        ,1);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_NUM_REG_RD           ,"num_reg_rd"           ,Tgeneral_address_t,_param->_size_general_register);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1);
+       ALLOC1_SIGNAL_OUT(out_RETIRE_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);
+
+       ALLOC1_INTERFACE_END(_param->_nb_inst_retire);
+     }
+     
+     // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
+       ALLOC1_INTERFACE_BEGIN("gpr_write",IN,SOUTH,_("Interface with write queue to bypass the write in the RegisterFile."),_param->_nb_gpr_write);
+       
+       ALLOC1_VALACK_IN ( in_GPR_WRITE_VAL          ,VAL);
+       ALLOC1_SIGNAL_IN ( in_GPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
+       ALLOC1_SIGNAL_IN ( in_GPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
+       ALLOC1_SIGNAL_IN ( in_GPR_WRITE_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
+
+       ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
      }
 
-    // ~~~~~[ Interface : "retire" ]~~~~~~~~~~~~~~~~~~~~~~~~~~
-    out_RETIRE_VAL            = new SC_OUT(Tcontrol_t        ) * [_param->_nb_inst_retire];
-     in_RETIRE_ACK            = new SC_IN (Tcontrol_t        ) * [_param->_nb_inst_retire];
-    if (_param->_have_port_context_id)
-    out_RETIRE_CONTEXT_ID     = new SC_OUT(Tcontext_t        ) * [_param->_nb_inst_retire];
-    if (_param->_have_port_front_end_id)
-    out_RETIRE_FRONT_END_ID   = new SC_OUT(Tcontext_t        ) * [_param->_nb_inst_retire];
-    if (_param->_have_port_ooo_engine_id)
-    out_RETIRE_OOO_ENGINE_ID  = new SC_OUT(Tcontext_t        ) * [_param->_nb_inst_retire];
-    if (_param->_have_port_rob_ptr)
-    out_RETIRE_ROB_ID         = new SC_OUT(Tpacket_t         ) * [_param->_nb_inst_retire];
-    out_RETIRE_OPERATION      = new SC_OUT(Toperation_t      ) * [_param->_nb_inst_retire];
-    out_RETIRE_TYPE           = new SC_OUT(Ttype_t           ) * [_param->_nb_inst_retire];
-    out_RETIRE_STORE_QUEUE_PTR_WRITE = new SC_OUT(Tlsq_ptr_t ) * [_param->_nb_inst_retire];
-    if (_param->_have_port_load_queue_ptr)
-    out_RETIRE_LOAD_QUEUE_PTR_WRITE  = new SC_OUT(Tlsq_ptr_t ) * [_param->_nb_inst_retire];
-    out_RETIRE_HAS_IMMEDIAT   = new SC_OUT(Tcontrol_t        ) * [_param->_nb_inst_retire];
-    out_RETIRE_IMMEDIAT       = new SC_OUT(Tgeneral_data_t   ) * [_param->_nb_inst_retire];
-    out_RETIRE_DATA_RA        = new SC_OUT(Tgeneral_data_t   ) * [_param->_nb_inst_retire];
-    out_RETIRE_DATA_RB        = new SC_OUT(Tgeneral_data_t   ) * [_param->_nb_inst_retire];
-    out_RETIRE_DATA_RC        = new SC_OUT(Tspecial_data_t   ) * [_param->_nb_inst_retire];
-    out_RETIRE_WRITE_RD       = new SC_OUT(Tcontrol_t        ) * [_param->_nb_inst_retire];
-    out_RETIRE_NUM_REG_RD     = new SC_OUT(Tgeneral_address_t) * [_param->_nb_inst_retire];
-    out_RETIRE_WRITE_RE       = new SC_OUT(Tcontrol_t        ) * [_param->_nb_inst_retire];
-    out_RETIRE_NUM_REG_RE     = new SC_OUT(Tspecial_address_t) * [_param->_nb_inst_retire];
-    
-    for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
-      {
-	Interface_fifo * interface = _interfaces->set_interface("retire_"+toString(i)
-#ifdef POSITION
-								,OUT
-								,WEST
-								,"Output of reservation_station"
-#endif
-								);
-	out_RETIRE_VAL          [i] = interface->set_signal_valack_out(VAL);
-	 in_RETIRE_ACK          [i] = interface->set_signal_valack_in (ACK);
-	if (_param->_have_port_context_id)
-	out_RETIRE_CONTEXT_ID   [i] = interface->set_signal_out<Tcontext_t        > ("context_id"   ,_param->_size_context_id);
-	if (_param->_have_port_front_end_id)
-	out_RETIRE_FRONT_END_ID [i] = interface->set_signal_out<Tcontext_t        > ("front_end_id" ,_param->_size_front_end_id);
-	if (_param->_have_port_ooo_engine_id)
-	out_RETIRE_OOO_ENGINE_ID[i] = interface->set_signal_out<Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
-	if (_param->_have_port_rob_ptr)
-	out_RETIRE_ROB_ID       [i] = interface->set_signal_out<Tpacket_t         > ("rob_id"       ,_param->_size_rob_ptr);
-	out_RETIRE_OPERATION    [i] = interface->set_signal_out<Toperation_t      > ("operation"    ,_param->_size_operation);
-	out_RETIRE_TYPE         [i] = interface->set_signal_out<Ttype_t           > ("type"         ,_param->_size_type);
-	out_RETIRE_STORE_QUEUE_PTR_WRITE [i] = interface->set_signal_out<Tlsq_ptr_t> ("store_queue_ptr_write" ,_param->_size_store_queue_ptr);
-	if (_param->_have_port_load_queue_ptr)
-	out_RETIRE_LOAD_QUEUE_PTR_WRITE  [i] = interface->set_signal_out<Tlsq_ptr_t> ("load_queue_ptr_write"  ,_param->_size_load_queue_ptr );
+    // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
+       ALLOC1_INTERFACE_BEGIN("spr_write",IN,SOUTH,_("Interface with write queue to bypass the write in the RegisterFile."),_param->_nb_spr_write);
+       
+       ALLOC1_VALACK_IN ( in_SPR_WRITE_VAL          ,VAL);
+       ALLOC1_SIGNAL_IN ( in_SPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
+       ALLOC1_SIGNAL_IN ( in_SPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
+       ALLOC1_SIGNAL_IN ( in_SPR_WRITE_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
 
-	out_RETIRE_HAS_IMMEDIAT [i] = interface->set_signal_out<Tcontrol_t        > ("has_immediat" ,1);
-	out_RETIRE_IMMEDIAT     [i] = interface->set_signal_out<Tgeneral_data_t   > ("immediat"     ,_param->_size_general_data);
-	out_RETIRE_DATA_RA      [i] = interface->set_signal_out<Tgeneral_data_t   > ("data_ra"      ,_param->_size_general_data);
-	out_RETIRE_DATA_RB      [i] = interface->set_signal_out<Tgeneral_data_t   > ("data_rb"      ,_param->_size_general_data);
-	out_RETIRE_DATA_RC      [i] = interface->set_signal_out<Tspecial_data_t   > ("data_rc"      ,_param->_size_special_data);
-	out_RETIRE_WRITE_RD     [i] = interface->set_signal_out<Tcontrol_t        > ("write_rd"     ,1);
-	out_RETIRE_NUM_REG_RD   [i] = interface->set_signal_out<Tgeneral_address_t> ("num_reg_rd"   ,_param->_size_general_register);
-	out_RETIRE_WRITE_RE     [i] = interface->set_signal_out<Tcontrol_t        > ("write_re"     ,1);
-	out_RETIRE_NUM_REG_RE   [i] = interface->set_signal_out<Tspecial_address_t> ("num_reg_re"   ,_param->_size_special_register);
-      }
+       ALLOC1_INTERFACE_END(_param->_nb_spr_write);
+     }
 
-    // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-     in_GPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_gpr_write];
-     if (_param->_have_port_ooo_engine_id)
-     in_GPR_WRITE_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_gpr_write];
-     in_GPR_WRITE_NUM_REG      = new SC_IN (Tgeneral_address_t) * [_param->_nb_gpr_write];
-     in_GPR_WRITE_DATA         = new SC_IN (Tgeneral_data_t   ) * [_param->_nb_gpr_write];
+     // ~~~~~[ Interface : "bypass_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
+       ALLOC1_INTERFACE_BEGIN("bypass_write",IN,NORTH,_("Interface with write queue to bypass the write in the RegisterFile."),_param->_nb_bypass_write);
 
-    for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
-      {
-        Interface_fifo * interface = _interfaces->set_interface("gpr_write_"+toString(i)
-#ifdef POSITION
-                                                                , IN  
-                                                                ,SOUTH
-                                                                , "Interface with write queue to bypass the write in the RegisterFile."
-#endif
-                                                                );
+       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
+       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_GPR_VAL      ,"gpr_val"      ,Tcontrol_t        ,1);
+       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_GPR_NUM_REG  ,"gpr_num_reg"  ,Tgeneral_address_t,_param->_size_general_register);
+       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_GPR_DATA     ,"gpr_data"     ,Tgeneral_data_t   ,_param->_size_general_data);
+       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_SPR_VAL      ,"spr_val"      ,Tcontrol_t        ,1);
+       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_SPR_NUM_REG  ,"spr_num_reg"  ,Tspecial_address_t,_param->_size_special_register);
+       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_SPR_DATA     ,"spr_data"     ,Tspecial_data_t   ,_param->_size_special_data);
+       
+       ALLOC1_INTERFACE_END(_param->_nb_bypass_write);
+     }
+     
+     // ~~~~~[ Interface : "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
+       ALLOC1_INTERFACE_BEGIN("bypass_memory",IN,NORTH,_("Interface with load/store unit to bypass the write in the RegisterFile."),_param->_nb_bypass_memory);
 
-	 in_GPR_WRITE_VAL           [i] = interface->set_signal_valack_in (VAL);
-	 if (_param->_have_port_ooo_engine_id)
-	 in_GPR_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
-	 in_GPR_WRITE_NUM_REG       [i] = interface->set_signal_in  <Tgeneral_address_t> ("num_reg"      ,_param->_size_general_register);
-	 in_GPR_WRITE_DATA          [i] = interface->set_signal_in  <Tgeneral_data_t   > ("data"         ,_param->_size_general_data);
-      }
-
-    // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-     in_SPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_spr_write];
-     if (_param->_have_port_ooo_engine_id)
-     in_SPR_WRITE_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_spr_write];
-     in_SPR_WRITE_NUM_REG      = new SC_IN (Tspecial_address_t) * [_param->_nb_spr_write];
-     in_SPR_WRITE_DATA         = new SC_IN (Tspecial_data_t   ) * [_param->_nb_spr_write];
-
-    for (uint32_t i=0; i<_param->_nb_spr_write; i++)
-      {
-        Interface_fifo * interface = _interfaces->set_interface("spr_write_"+toString(i)
-#ifdef POSITION
-                                                                , IN  
-                                                                ,SOUTH
-                                                                , "Interface with write queue to bypass the write in the RegisterFile."
-#endif
-                                                                );
-
-	 in_SPR_WRITE_VAL           [i] = interface->set_signal_valack_in (VAL);
-	 if (_param->_have_port_ooo_engine_id)
-         in_SPR_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
-	 in_SPR_WRITE_NUM_REG       [i] = interface->set_signal_in  <Tspecial_address_t> ("num_reg"      ,_param->_size_special_register);
-	 in_SPR_WRITE_DATA          [i] = interface->set_signal_in  <Tspecial_data_t   > ("data"         ,_param->_size_special_data);
-      }
-
-    // ~~~~~[ Interface : "bypass_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-     if (_param->_have_port_ooo_engine_id)
-     in_BYPASS_WRITE_OOO_ENGINE_ID  = new SC_IN (Tcontext_t        ) * [_param->_nb_bypass_write];
-     in_BYPASS_WRITE_GPR_VAL        = new SC_IN (Tcontrol_t        ) * [_param->_nb_bypass_write];
-     in_BYPASS_WRITE_GPR_NUM_REG    = new SC_IN (Tgeneral_address_t) * [_param->_nb_bypass_write];
-     in_BYPASS_WRITE_GPR_DATA       = new SC_IN (Tgeneral_data_t   ) * [_param->_nb_bypass_write];
-     in_BYPASS_WRITE_SPR_VAL        = new SC_IN (Tcontrol_t        ) * [_param->_nb_bypass_write];
-     in_BYPASS_WRITE_SPR_NUM_REG    = new SC_IN (Tspecial_address_t) * [_param->_nb_bypass_write];
-     in_BYPASS_WRITE_SPR_DATA       = new SC_IN (Tspecial_data_t   ) * [_param->_nb_bypass_write];
-
-    for (uint32_t i=0; i<_param->_nb_bypass_write; i++)
-      {
-        Interface_fifo * interface = _interfaces->set_interface("bypass_write_"+toString(i)
-#ifdef POSITION
-                                                                , IN  
-                                                                ,NORTH
-                                                                , "Interface with write queue to bypass the write in the RegisterFile."
-#endif
-                                                                );
-
-	 if (_param->_have_port_ooo_engine_id)
-         in_BYPASS_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id" ,_param->_size_ooo_engine_id);
-	 in_BYPASS_WRITE_GPR_VAL       [i] = interface->set_signal_valack_in ("gpr_val",VAL);		     
-	 in_BYPASS_WRITE_GPR_NUM_REG   [i] = interface->set_signal_in  <Tgeneral_address_t> ("gpr_num_reg"   ,_param->_size_general_register);
-	 in_BYPASS_WRITE_GPR_DATA      [i] = interface->set_signal_in  <Tgeneral_data_t   > ("gpr_data"      ,_param->_size_general_data);
-	 in_BYPASS_WRITE_SPR_VAL       [i] = interface->set_signal_valack_in ("spr_val",VAL);		     
-	 in_BYPASS_WRITE_SPR_NUM_REG   [i] = interface->set_signal_in  <Tspecial_address_t> ("spr_num_reg"   ,_param->_size_special_register);
-	 in_BYPASS_WRITE_SPR_DATA      [i] = interface->set_signal_in  <Tspecial_data_t   > ("spr_data"      ,_param->_size_special_data);
-      }
-
-    // ~~~~~[ Interface : "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-     in_BYPASS_MEMORY_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_bypass_memory];
-     if (_param->_have_port_ooo_engine_id)
-     in_BYPASS_MEMORY_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_bypass_memory];
-     in_BYPASS_MEMORY_NUM_REG      = new SC_IN (Tgeneral_address_t) * [_param->_nb_bypass_memory];
-     in_BYPASS_MEMORY_DATA         = new SC_IN (Tgeneral_data_t   ) * [_param->_nb_bypass_memory];
-
-    for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
-      {
-        Interface_fifo * interface = _interfaces->set_interface("bypass_memory_"+toString(i)
-#ifdef POSITION
-                                                                , IN  
-                                                                , NORTH
-                                                                , "Interface with load/store unit to bypass the write in the RegisterFile."
-#endif
-                                                                );
-
-	 in_BYPASS_MEMORY_VAL          [i] = interface->set_signal_valack_in (VAL);
-	 if (_param->_have_port_ooo_engine_id)
-         in_BYPASS_MEMORY_OOO_ENGINE_ID[i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
-	 in_BYPASS_MEMORY_NUM_REG      [i] = interface->set_signal_in  <Tgeneral_address_t> ("num_reg"      ,_param->_size_general_register);
-	 in_BYPASS_MEMORY_DATA         [i] = interface->set_signal_in  <Tgeneral_data_t   > ("data"         ,_param->_size_general_data);
-      }
-
+       ALLOC1_VALACK_IN ( in_BYPASS_MEMORY_VAL          ,VAL);
+       ALLOC1_SIGNAL_IN ( in_BYPASS_MEMORY_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
+       ALLOC1_SIGNAL_IN ( in_BYPASS_MEMORY_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
+       ALLOC1_SIGNAL_IN ( in_BYPASS_MEMORY_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
+       
+       ALLOC1_INTERFACE_END(_param->_nb_bypass_memory);
+     }
 
     if (usage_is_set(_usage,USE_SYSTEMC))
       {
     // ~~~~~[ internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
-    internal_RETIRE_VAL  = new Tcontrol_t [_param->_nb_inst_retire];
-    internal_RETIRE_SLOT = new uint32_t   [_param->_nb_inst_retire];
+        ALLOC1(internal_RETIRE_VAL ,Tcontrol_t,_param->_nb_inst_retire);
+        ALLOC1(internal_RETIRE_SLOT,uint32_t  ,_param->_nb_inst_retire);
       }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_deallocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_deallocation.cpp	(revision 112)
@@ -11,4 +11,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/include/Reservation_station.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -30,97 +31,83 @@
     if (usage_is_set(_usage,USE_SYSTEMC))
       {
-    delete     in_CLOCK ;
-    delete     in_NRESET;
+        delete     in_CLOCK ;
+        delete     in_NRESET;
 
-    delete     in_INSERT_VAL           ;
-    delete    out_INSERT_ACK           ;
-    if (_param->_have_port_context_id)
-    delete     in_INSERT_CONTEXT_ID    ;
-    if (_param->_have_port_front_end_id)
-    delete     in_INSERT_FRONT_END_ID  ;
-    if (_param->_have_port_ooo_engine_id)
-    delete     in_INSERT_OOO_ENGINE_ID ;
-    if (_param->_have_port_rob_ptr)
-    delete     in_INSERT_ROB_ID        ;
-    delete     in_INSERT_OPERATION     ;
-    delete     in_INSERT_TYPE          ;
-    delete     in_INSERT_STORE_QUEUE_PTR_WRITE;
-    if (_param->_have_port_load_queue_ptr)
-    delete     in_INSERT_LOAD_QUEUE_PTR_WRITE ;
-    delete     in_INSERT_HAS_IMMEDIAT  ;
-    delete     in_INSERT_IMMEDIAT      ;
-//  delete     in_INSERT_READ_RA       ;
-    delete     in_INSERT_NUM_REG_RA    ;
-    delete     in_INSERT_DATA_RA_VAL   ;
-    delete     in_INSERT_DATA_RA       ;
-//  delete     in_INSERT_READ_RB       ;
-    delete     in_INSERT_NUM_REG_RB    ;
-    delete     in_INSERT_DATA_RB_VAL   ;
-    delete     in_INSERT_DATA_RB       ;
-//  delete     in_INSERT_READ_RC       ;
-    delete     in_INSERT_NUM_REG_RC    ;
-    delete     in_INSERT_DATA_RC_VAL   ;
-    delete     in_INSERT_DATA_RC       ;
-    delete     in_INSERT_WRITE_RD      ;
-    delete     in_INSERT_NUM_REG_RD    ;
-    delete     in_INSERT_WRITE_RE      ;
-    delete     in_INSERT_NUM_REG_RE    ;
-    
-    delete [] out_RETIRE_VAL           ;
-    delete []  in_RETIRE_ACK           ;
-    if (_param->_have_port_context_id)
-    delete [] out_RETIRE_CONTEXT_ID    ;
-    if (_param->_have_port_front_end_id)
-    delete [] out_RETIRE_FRONT_END_ID  ;
-    if (_param->_have_port_ooo_engine_id)
-    delete [] out_RETIRE_OOO_ENGINE_ID ;
-    if (_param->_have_port_rob_ptr)
-    delete [] out_RETIRE_ROB_ID        ;
-    delete [] out_RETIRE_OPERATION     ;
-    delete [] out_RETIRE_TYPE          ;
-    delete [] out_RETIRE_STORE_QUEUE_PTR_WRITE;
-    if (_param->_have_port_load_queue_ptr)
-    delete [] out_RETIRE_LOAD_QUEUE_PTR_WRITE ;
-    delete [] out_RETIRE_HAS_IMMEDIAT  ;
-    delete [] out_RETIRE_IMMEDIAT      ;
-    delete [] out_RETIRE_DATA_RA       ;
-    delete [] out_RETIRE_DATA_RB       ;
-    delete [] out_RETIRE_DATA_RC       ;
-    delete [] out_RETIRE_WRITE_RD      ;
-    delete [] out_RETIRE_NUM_REG_RD    ;
-    delete [] out_RETIRE_WRITE_RE      ;
-    delete [] out_RETIRE_NUM_REG_RE    ;
-    
-    delete []  in_GPR_WRITE_VAL         ;
-    if (_param->_have_port_ooo_engine_id)
-    delete []  in_GPR_WRITE_OOO_ENGINE_ID;
-    delete []  in_GPR_WRITE_NUM_REG     ;
-    delete []  in_GPR_WRITE_DATA        ;
-    
-    delete []  in_SPR_WRITE_VAL       ;
-    if (_param->_have_port_ooo_engine_id)
-    delete []  in_SPR_WRITE_OOO_ENGINE_ID;
-    delete []  in_SPR_WRITE_NUM_REG   ;
-    delete []  in_SPR_WRITE_DATA      ;
-    
-    if (_param->_have_port_ooo_engine_id)
-    delete []  in_BYPASS_WRITE_OOO_ENGINE_ID;
-    delete []  in_BYPASS_WRITE_GPR_VAL    ;
-    delete []  in_BYPASS_WRITE_GPR_NUM_REG;
-    delete []  in_BYPASS_WRITE_GPR_DATA   ;
-    delete []  in_BYPASS_WRITE_SPR_VAL    ;
-    delete []  in_BYPASS_WRITE_SPR_NUM_REG;
-    delete []  in_BYPASS_WRITE_SPR_DATA   ;
-    
-    delete []  in_BYPASS_MEMORY_VAL       ;
-    if (_param->_have_port_ooo_engine_id)
-    delete []  in_BYPASS_MEMORY_OOO_ENGINE_ID;
-    delete []  in_BYPASS_MEMORY_NUM_REG   ;
-    delete []  in_BYPASS_MEMORY_DATA      ;
-    
-    // ~~~~~[ internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
-    delete []  internal_RETIRE_VAL;
-    delete []  internal_RETIRE_SLOT;
+        DELETE0_SIGNAL( in_INSERT_VAL                  ,1);
+        DELETE0_SIGNAL(out_INSERT_ACK                  ,1);
+        DELETE0_SIGNAL( in_INSERT_CONTEXT_ID           ,_param->_size_context_id      );
+        DELETE0_SIGNAL( in_INSERT_FRONT_END_ID         ,_param->_size_front_end_id    );
+        DELETE0_SIGNAL( in_INSERT_OOO_ENGINE_ID        ,_param->_size_ooo_engine_id   );
+        DELETE0_SIGNAL( in_INSERT_ROB_ID               ,_param->_size_rob_ptr         );
+        DELETE0_SIGNAL( in_INSERT_OPERATION            ,_param->_size_operation       );
+        DELETE0_SIGNAL( in_INSERT_TYPE                 ,_param->_size_type            );
+        DELETE0_SIGNAL( in_INSERT_STORE_QUEUE_PTR_WRITE,_param->_size_store_queue_ptr );
+        DELETE0_SIGNAL( in_INSERT_LOAD_QUEUE_PTR_WRITE ,_param->_size_load_queue_ptr  );
+        DELETE0_SIGNAL( in_INSERT_HAS_IMMEDIAT         ,1                             );
+        DELETE0_SIGNAL( in_INSERT_IMMEDIAT             ,_param->_size_general_data    );
+//      DELETE0_SIGNAL( in_INSERT_READ_RA              ,1                             );
+        DELETE0_SIGNAL( in_INSERT_NUM_REG_RA           ,_param->_size_general_register);
+        DELETE0_SIGNAL( in_INSERT_DATA_RA_VAL          ,1                             );
+        DELETE0_SIGNAL( in_INSERT_DATA_RA              ,_param->_size_general_data    );
+//      DELETE0_SIGNAL( in_INSERT_READ_RB              ,1                             );
+        DELETE0_SIGNAL( in_INSERT_NUM_REG_RB           ,_param->_size_general_register);
+        DELETE0_SIGNAL( in_INSERT_DATA_RB_VAL          ,1                             );
+        DELETE0_SIGNAL( in_INSERT_DATA_RB              ,_param->_size_general_data    );
+//      DELETE0_SIGNAL( in_INSERT_READ_RC              ,1                             );
+        DELETE0_SIGNAL( in_INSERT_NUM_REG_RC           ,_param->_size_special_register);
+        DELETE0_SIGNAL( in_INSERT_DATA_RC_VAL          ,1                             );
+        DELETE0_SIGNAL( in_INSERT_DATA_RC              ,_param->_size_special_data    );
+        DELETE0_SIGNAL( in_INSERT_WRITE_RD             ,1                             );
+        DELETE0_SIGNAL( in_INSERT_NUM_REG_RD           ,_param->_size_general_register);
+        DELETE0_SIGNAL( in_INSERT_WRITE_RE             ,1                             );
+        DELETE0_SIGNAL( in_INSERT_NUM_REG_RE           ,_param->_size_special_register);
+        
+        DELETE1_SIGNAL(out_RETIRE_VAL                  ,_param->_nb_inst_retire,1);
+        DELETE1_SIGNAL( in_RETIRE_ACK                  ,_param->_nb_inst_retire,1);
+        DELETE1_SIGNAL(out_RETIRE_CONTEXT_ID           ,_param->_nb_inst_retire,_param->_size_context_id);
+        DELETE1_SIGNAL(out_RETIRE_FRONT_END_ID         ,_param->_nb_inst_retire,_param->_size_front_end_id);
+        DELETE1_SIGNAL(out_RETIRE_OOO_ENGINE_ID        ,_param->_nb_inst_retire,_param->_size_ooo_engine_id);
+        DELETE1_SIGNAL(out_RETIRE_ROB_ID               ,_param->_nb_inst_retire,_param->_size_rob_ptr);
+        DELETE1_SIGNAL(out_RETIRE_OPERATION            ,_param->_nb_inst_retire,_param->_size_operation);
+        DELETE1_SIGNAL(out_RETIRE_TYPE                 ,_param->_nb_inst_retire,_param->_size_type);
+        DELETE1_SIGNAL(out_RETIRE_STORE_QUEUE_PTR_WRITE,_param->_nb_inst_retire,_param->_size_store_queue_ptr);
+        DELETE1_SIGNAL(out_RETIRE_LOAD_QUEUE_PTR_WRITE ,_param->_nb_inst_retire,_param->_size_load_queue_ptr );
+        DELETE1_SIGNAL(out_RETIRE_HAS_IMMEDIAT         ,_param->_nb_inst_retire,1);
+        DELETE1_SIGNAL(out_RETIRE_IMMEDIAT             ,_param->_nb_inst_retire,_param->_size_general_data);
+        DELETE1_SIGNAL(out_RETIRE_DATA_RA              ,_param->_nb_inst_retire,_param->_size_general_data);
+        DELETE1_SIGNAL(out_RETIRE_DATA_RB              ,_param->_nb_inst_retire,_param->_size_general_data);
+        DELETE1_SIGNAL(out_RETIRE_DATA_RC              ,_param->_nb_inst_retire,_param->_size_special_data);
+        DELETE1_SIGNAL(out_RETIRE_WRITE_RD             ,_param->_nb_inst_retire,1);
+        DELETE1_SIGNAL(out_RETIRE_NUM_REG_RD           ,_param->_nb_inst_retire,_param->_size_general_register);
+        DELETE1_SIGNAL(out_RETIRE_WRITE_RE             ,_param->_nb_inst_retire,1);
+        DELETE1_SIGNAL(out_RETIRE_NUM_REG_RE           ,_param->_nb_inst_retire,_param->_size_special_register);
+        
+        DELETE1_SIGNAL( in_GPR_WRITE_VAL          ,_param->_nb_gpr_write,1);
+        DELETE1_SIGNAL( in_GPR_WRITE_OOO_ENGINE_ID,_param->_nb_gpr_write,_param->_size_ooo_engine_id);
+        DELETE1_SIGNAL( in_GPR_WRITE_NUM_REG      ,_param->_nb_gpr_write,_param->_size_general_register);
+        DELETE1_SIGNAL( in_GPR_WRITE_DATA         ,_param->_nb_gpr_write,_param->_size_general_data);
+        
+        DELETE1_SIGNAL( in_SPR_WRITE_VAL          ,_param->_nb_spr_write,1);
+        DELETE1_SIGNAL( in_SPR_WRITE_OOO_ENGINE_ID,_param->_nb_spr_write,_param->_size_ooo_engine_id);
+        DELETE1_SIGNAL( in_SPR_WRITE_NUM_REG      ,_param->_nb_spr_write,_param->_size_general_register);
+        DELETE1_SIGNAL( in_SPR_WRITE_DATA         ,_param->_nb_spr_write,_param->_size_general_data);
+        
+        DELETE1_SIGNAL( in_BYPASS_WRITE_OOO_ENGINE_ID,_param->_nb_bypass_write,_param->_size_ooo_engine_id);
+        DELETE1_SIGNAL( in_BYPASS_WRITE_GPR_VAL      ,_param->_nb_bypass_write,1);
+        DELETE1_SIGNAL( in_BYPASS_WRITE_GPR_NUM_REG  ,_param->_nb_bypass_write,_param->_size_general_register);
+        DELETE1_SIGNAL( in_BYPASS_WRITE_GPR_DATA     ,_param->_nb_bypass_write,_param->_size_general_data);
+        DELETE1_SIGNAL( in_BYPASS_WRITE_SPR_VAL      ,_param->_nb_bypass_write,1);
+        DELETE1_SIGNAL( in_BYPASS_WRITE_SPR_NUM_REG  ,_param->_nb_bypass_write,_param->_size_special_register);
+        DELETE1_SIGNAL( in_BYPASS_WRITE_SPR_DATA     ,_param->_nb_bypass_write,_param->_size_special_data);
+        
+        DELETE1_SIGNAL( in_BYPASS_MEMORY_VAL          ,_param->_nb_bypass_memory,1);
+        DELETE1_SIGNAL( in_BYPASS_MEMORY_OOO_ENGINE_ID,_param->_nb_bypass_memory,_param->_size_ooo_engine_id);
+        DELETE1_SIGNAL( in_BYPASS_MEMORY_NUM_REG      ,_param->_nb_bypass_memory,_param->_size_general_register);
+        DELETE1_SIGNAL( in_BYPASS_MEMORY_DATA         ,_param->_nb_bypass_memory,_param->_size_general_data);
+        
+        DELETE1(internal_RETIRE_VAL ,_param->_nb_inst_retire);
+        DELETE1(internal_RETIRE_SLOT,_param->_nb_inst_retire);
       }
+
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/SelfTest/src/test.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/SelfTest/src/test.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/SelfTest/src/test.cpp	(revision 112)
@@ -64,26 +64,26 @@
   sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
 
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_VAL                   ," in_READ_UNIT_IN_VAL                   ",Tcontrol_t        );
-  ALLOC_SC_SIGNAL (out_READ_UNIT_IN_ACK                   ,"out_READ_UNIT_IN_ACK                   ",Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_CONTEXT_ID            ," in_READ_UNIT_IN_CONTEXT_ID            ",Tcontext_t        );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_FRONT_END_ID          ," in_READ_UNIT_IN_FRONT_END_ID          ",Tcontext_t        );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_OOO_ENGINE_ID         ," in_READ_UNIT_IN_OOO_ENGINE_ID         ",Tcontext_t        );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_PACKET_ID             ," in_READ_UNIT_IN_PACKET_ID             ",Tpacket_t         );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_OPERATION             ," in_READ_UNIT_IN_OPERATION             ",Toperation_t      );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_TYPE                  ," in_READ_UNIT_IN_TYPE                  ",Ttype_t           );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE ," in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE ",Tlsq_ptr_t        );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE  ," in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE  ",Tlsq_ptr_t        );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_HAS_IMMEDIAT          ," in_READ_UNIT_IN_HAS_IMMEDIAT          ",Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_IMMEDIAT              ," in_READ_UNIT_IN_IMMEDIAT              ",Tgeneral_data_t   );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_READ_RA               ," in_READ_UNIT_IN_READ_RA               ",Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_NUM_REG_RA            ," in_READ_UNIT_IN_NUM_REG_RA            ",Tgeneral_address_t);
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_READ_RB               ," in_READ_UNIT_IN_READ_RB               ",Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_NUM_REG_RB            ," in_READ_UNIT_IN_NUM_REG_RB            ",Tgeneral_address_t);
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_READ_RC               ," in_READ_UNIT_IN_READ_RC               ",Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_NUM_REG_RC            ," in_READ_UNIT_IN_NUM_REG_RC            ",Tspecial_address_t);
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_WRITE_RD              ," in_READ_UNIT_IN_WRITE_RD              ",Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_NUM_REG_RD            ," in_READ_UNIT_IN_NUM_REG_RD            ",Tgeneral_address_t);
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_WRITE_RE              ," in_READ_UNIT_IN_WRITE_RE              ",Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_NUM_REG_RE            ," in_READ_UNIT_IN_NUM_REG_RE            ",Tspecial_address_t);
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_VAL                   ," in_READ_UNIT_IN_VAL                   ",Tcontrol_t        );
+  ALLOC0_SC_SIGNAL(out_READ_UNIT_IN_ACK                   ,"out_READ_UNIT_IN_ACK                   ",Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_CONTEXT_ID            ," in_READ_UNIT_IN_CONTEXT_ID            ",Tcontext_t        );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_FRONT_END_ID          ," in_READ_UNIT_IN_FRONT_END_ID          ",Tcontext_t        );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_OOO_ENGINE_ID         ," in_READ_UNIT_IN_OOO_ENGINE_ID         ",Tcontext_t        );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_PACKET_ID             ," in_READ_UNIT_IN_PACKET_ID             ",Tpacket_t         );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_OPERATION             ," in_READ_UNIT_IN_OPERATION             ",Toperation_t      );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_TYPE                  ," in_READ_UNIT_IN_TYPE                  ",Ttype_t           );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE ," in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE ",Tlsq_ptr_t        );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE  ," in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE  ",Tlsq_ptr_t        );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_HAS_IMMEDIAT          ," in_READ_UNIT_IN_HAS_IMMEDIAT          ",Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_IMMEDIAT              ," in_READ_UNIT_IN_IMMEDIAT              ",Tgeneral_data_t   );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_READ_RA               ," in_READ_UNIT_IN_READ_RA               ",Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_NUM_REG_RA            ," in_READ_UNIT_IN_NUM_REG_RA            ",Tgeneral_address_t);
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_READ_RB               ," in_READ_UNIT_IN_READ_RB               ",Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_NUM_REG_RB            ," in_READ_UNIT_IN_NUM_REG_RB            ",Tgeneral_address_t);
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_READ_RC               ," in_READ_UNIT_IN_READ_RC               ",Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_NUM_REG_RC            ," in_READ_UNIT_IN_NUM_REG_RC            ",Tspecial_address_t);
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_WRITE_RD              ," in_READ_UNIT_IN_WRITE_RD              ",Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_NUM_REG_RD            ," in_READ_UNIT_IN_NUM_REG_RD            ",Tgeneral_address_t);
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_WRITE_RE              ," in_READ_UNIT_IN_WRITE_RE              ",Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_NUM_REG_RE            ," in_READ_UNIT_IN_NUM_REG_RE            ",Tspecial_address_t);
   ALLOC1_SC_SIGNAL(out_READ_UNIT_OUT_VAL                  ,"out_READ_UNIT_OUT_VAL                  ",Tcontrol_t        ,_param->_nb_inst_retire);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_ACK                  ," in_READ_UNIT_OUT_ACK                  ",Tcontrol_t        ,_param->_nb_inst_retire);
@@ -146,31 +146,31 @@
   (*(_Read_unit->in_NRESET))       (*(in_NRESET));
 
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_VAL                   );
-  INSTANCE_SC_SIGNAL (_Read_unit,out_READ_UNIT_IN_ACK                   );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_VAL                   );
+  INSTANCE0_SC_SIGNAL(_Read_unit,out_READ_UNIT_IN_ACK                   );
   if (_param->_have_port_context_id)
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_CONTEXT_ID            );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_CONTEXT_ID            );
   if (_param->_have_port_front_end_id)
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_FRONT_END_ID          );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_FRONT_END_ID          );
   if (_param->_have_port_ooo_engine_id)
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_OOO_ENGINE_ID         );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_OOO_ENGINE_ID         );
   if (_param->_have_port_rob_ptr)
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_PACKET_ID             );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_OPERATION             );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_TYPE                  );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_PACKET_ID             );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_OPERATION             );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_TYPE                  );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE );
   if (_param->_have_port_load_queue_ptr)
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE  );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_HAS_IMMEDIAT          );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_IMMEDIAT              );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_READ_RA               );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_NUM_REG_RA            );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_READ_RB               );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_NUM_REG_RB            );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_READ_RC               );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_NUM_REG_RC            );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_WRITE_RD              );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_NUM_REG_RD            );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_WRITE_RE              );
-  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_NUM_REG_RE            );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE  );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_HAS_IMMEDIAT          );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_IMMEDIAT              );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_READ_RA               );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_NUM_REG_RA            );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_READ_RB               );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_NUM_REG_RB            );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_READ_RC               );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_NUM_REG_RC            );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_WRITE_RD              );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_NUM_REG_RD            );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_WRITE_RE              );
+  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_NUM_REG_RE            );
   INSTANCE1_SC_SIGNAL(_Read_unit,out_READ_UNIT_OUT_VAL                  ,_param->_nb_inst_retire);
   INSTANCE1_SC_SIGNAL(_Read_unit, in_READ_UNIT_OUT_ACK                  ,_param->_nb_inst_retire);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Read_unit_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Read_unit_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Read_unit_allocation.cpp	(revision 112)
@@ -57,33 +57,35 @@
     // ~~~~~[ Interface "read_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC_INTERFACE("read_unit_in", IN, WEST, _("Enter of new operation"));
-
-       ALLOC_VALACK_IN    ( in_READ_UNIT_IN_VAL,VAL);
-       ALLOC_VALACK_OUT   (out_READ_UNIT_IN_ACK,ACK);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_CONTEXT_ID           ,"context_id"           ,Tcontext_t        ,_param->_size_context_id   );
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id );
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_OOO_ENGINE_ID        ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_PACKET_ID            ,"packet_id"            ,Tpacket_t         ,_param->_size_rob_ptr    );
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation    );
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type         );
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_READ_RA              ,"read_ra"              ,Tcontrol_t        ,1);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RA           ,"num_reg_ra"           ,Tgeneral_address_t,_param->_size_general_register);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_READ_RB              ,"read_rb"              ,Tcontrol_t        ,1);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RB           ,"num_reg_rb"           ,Tgeneral_address_t,_param->_size_general_register);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_READ_RC              ,"read_rc"              ,Tcontrol_t        ,1);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RC           ,"num_reg_rc"           ,Tspecial_address_t,_param->_size_special_register);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_WRITE_RD             ,"write_rd"             ,Tcontrol_t        ,1);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RD           ,"num_reg_rd"           ,Tgeneral_address_t,_param->_size_general_register);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1);
-       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);
+       ALLOC0_INTERFACE_BEGIN("read_unit_in", IN, WEST, _("Enter of new operation"));
+
+       ALLOC0_VALACK_IN    ( in_READ_UNIT_IN_VAL,VAL);
+       ALLOC0_VALACK_OUT   (out_READ_UNIT_IN_ACK,ACK);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_CONTEXT_ID           ,"context_id"           ,Tcontext_t        ,_param->_size_context_id   );
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id );
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_OOO_ENGINE_ID        ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_PACKET_ID            ,"packet_id"            ,Tpacket_t         ,_param->_size_rob_ptr    );
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation    );
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type         );
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_READ_RA              ,"read_ra"              ,Tcontrol_t        ,1);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RA           ,"num_reg_ra"           ,Tgeneral_address_t,_param->_size_general_register);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_READ_RB              ,"read_rb"              ,Tcontrol_t        ,1);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RB           ,"num_reg_rb"           ,Tgeneral_address_t,_param->_size_general_register);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_READ_RC              ,"read_rc"              ,Tcontrol_t        ,1);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RC           ,"num_reg_rc"           ,Tspecial_address_t,_param->_size_special_register);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_WRITE_RD             ,"write_rd"             ,Tcontrol_t        ,1);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RD           ,"num_reg_rd"           ,Tgeneral_address_t,_param->_size_general_register);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1);
+       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);
+
+       ALLOC0_INTERFACE_END();
      }
 
     // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC1_INTERFACE("read_unit_out", OUT, EAST, _("Output of operation. All operand is valid."), _param->_nb_inst_retire);
+       ALLOC1_INTERFACE_BEGIN("read_unit_out", OUT, EAST, _("Output of operation. All operand is valid."), _param->_nb_inst_retire);
 
        ALLOC1_VALACK_OUT   (out_READ_UNIT_OUT_VAL,VAL);
@@ -106,9 +108,11 @@
        ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1                             );
        ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);
+
+       ALLOC1_INTERFACE_END(_param->_nb_inst_retire);
      }
 
     // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC1_INTERFACE("gpr_read", OUT, SOUTH, _("Read port."), _param->_nb_gpr_read);
+       ALLOC1_INTERFACE_BEGIN("gpr_read", OUT, SOUTH, _("Read port."), _param->_nb_gpr_read);
 
        ALLOC1_VALACK_OUT   (out_GPR_READ_VAL,VAL);
@@ -118,9 +122,11 @@
        ALLOC1_SIGNAL_IN ( in_GPR_READ_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data    );
        ALLOC1_SIGNAL_IN ( in_GPR_READ_DATA_VAL     ,"data_val"     ,Tcontrol_t        ,1);
+
+       ALLOC1_INTERFACE_END(_param->_nb_gpr_read);
      }
 
     // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC1_INTERFACE("spr_read", OUT, SOUTH, _("Read port."), _param->_nb_spr_read);
+       ALLOC1_INTERFACE_BEGIN("spr_read", OUT, SOUTH, _("Read port."), _param->_nb_spr_read);
 
        ALLOC1_VALACK_OUT   (out_SPR_READ_VAL,VAL);
@@ -130,9 +136,11 @@
        ALLOC1_SIGNAL_IN ( in_SPR_READ_DATA         ,"data"         ,Tspecial_data_t   ,_param->_size_special_data    );
        ALLOC1_SIGNAL_IN ( in_SPR_READ_DATA_VAL     ,"data_val"     ,Tcontrol_t        ,1);
+
+       ALLOC1_INTERFACE_END(_param->_nb_spr_read);
      }
 
     // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC1_INTERFACE("gpr_write", IN , SOUTH, _("Write port."), _param->_nb_gpr_write);
+       ALLOC1_INTERFACE_BEGIN("gpr_write", IN , SOUTH, _("Write port."), _param->_nb_gpr_write);
 
        ALLOC1_VALACK_IN    ( in_GPR_WRITE_VAL,VAL);
@@ -140,9 +148,11 @@
        ALLOC1_SIGNAL_IN ( in_GPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
        ALLOC1_SIGNAL_IN ( in_GPR_WRITE_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
+
+       ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
      }
 
     // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC1_INTERFACE("spr_write", IN , SOUTH, _("Write port."), _param->_nb_spr_write);
+       ALLOC1_INTERFACE_BEGIN("spr_write", IN , SOUTH, _("Write port."), _param->_nb_spr_write);
 
        ALLOC1_VALACK_IN    ( in_SPR_WRITE_VAL,VAL);
@@ -150,9 +160,11 @@
        ALLOC1_SIGNAL_IN ( in_SPR_WRITE_NUM_REG      ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);
        ALLOC1_SIGNAL_IN ( in_SPR_WRITE_DATA         ,"data"         ,Tspecial_data_t   ,_param->_size_special_data);
+
+       ALLOC1_INTERFACE_END(_param->_nb_spr_write);
      }
 
     // ~~~~~[ Interface "bypass_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC1_INTERFACE("bypass_write", IN , NORTH, _("Output of write_queue."), _param->_nb_bypass_write);
+       ALLOC1_INTERFACE_BEGIN("bypass_write", IN , NORTH, _("Output of write_queue."), _param->_nb_bypass_write);
 
        ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
@@ -163,9 +175,11 @@
        ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_SPR_NUM_REG  ,"spr_num_reg"  ,Tspecial_address_t,_param->_size_special_register);
        ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_SPR_DATA     ,"spr_data"     ,Tspecial_data_t   ,_param->_size_special_data    );
+
+       ALLOC1_INTERFACE_END(_param->_nb_bypass_write);
      }
 
     // ~~~~~[ Interface "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC1_INTERFACE("bypass_memory", IN , NORTH, _("Output of write_queue."), _param->_nb_bypass_memory);
+       ALLOC1_INTERFACE_BEGIN("bypass_memory", IN , NORTH, _("Output of write_queue."), _param->_nb_bypass_memory);
 
        ALLOC1_SIGNAL_IN ( in_BYPASS_MEMORY_VAL          ,"val"          ,Tcontrol_t        ,1);
@@ -173,4 +187,6 @@
        ALLOC1_SIGNAL_IN ( in_BYPASS_MEMORY_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
        ALLOC1_SIGNAL_IN ( in_BYPASS_MEMORY_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data    );
+
+       ALLOC1_INTERFACE_END(_param->_nb_bypass_memory);
      }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Read_unit_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Read_unit_deallocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Read_unit_deallocation.cpp	(revision 112)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/include/Read_unit.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -28,107 +29,83 @@
 	delete     in_NRESET;
 
-	// ~~~~~[ Interface "read_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	delete     in_READ_UNIT_IN_VAL                  ;
-	delete    out_READ_UNIT_IN_ACK                  ;
-	if (_param->_have_port_context_id)
-	delete     in_READ_UNIT_IN_CONTEXT_ID           ;
-	if (_param->_have_port_front_end_id)
-	delete     in_READ_UNIT_IN_FRONT_END_ID         ;
-	if (_param->_have_port_ooo_engine_id)
-	delete     in_READ_UNIT_IN_OOO_ENGINE_ID        ;
-	if (_param->_have_port_rob_ptr)
-	delete     in_READ_UNIT_IN_PACKET_ID            ;
-	delete     in_READ_UNIT_IN_OPERATION            ;
-	delete     in_READ_UNIT_IN_TYPE                 ;
-	delete     in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE;
-	if (_param->_have_port_load_queue_ptr)
-	delete     in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;
-	delete     in_READ_UNIT_IN_HAS_IMMEDIAT         ;
-	delete     in_READ_UNIT_IN_IMMEDIAT             ;
-	delete     in_READ_UNIT_IN_READ_RA              ;
-	delete     in_READ_UNIT_IN_NUM_REG_RA           ;
-	delete     in_READ_UNIT_IN_READ_RB              ;
-	delete     in_READ_UNIT_IN_NUM_REG_RB           ;
-	delete     in_READ_UNIT_IN_READ_RC              ;
-	delete     in_READ_UNIT_IN_NUM_REG_RC           ;
-	delete     in_READ_UNIT_IN_WRITE_RD             ;
-	delete     in_READ_UNIT_IN_NUM_REG_RD           ;
-	delete     in_READ_UNIT_IN_WRITE_RE             ;
-	delete     in_READ_UNIT_IN_NUM_REG_RE           ;
+        DELETE0_SIGNAL( in_READ_UNIT_IN_VAL                  ,1);
+        DELETE0_SIGNAL(out_READ_UNIT_IN_ACK                  ,1);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_CONTEXT_ID           ,_param->_size_context_id   );
+        DELETE0_SIGNAL( in_READ_UNIT_IN_FRONT_END_ID         ,_param->_size_front_end_id );
+        DELETE0_SIGNAL( in_READ_UNIT_IN_OOO_ENGINE_ID        ,_param->_size_ooo_engine_id);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_PACKET_ID            ,_param->_size_rob_ptr    );
+        DELETE0_SIGNAL( in_READ_UNIT_IN_OPERATION            ,_param->_size_operation    );
+        DELETE0_SIGNAL( in_READ_UNIT_IN_TYPE                 ,_param->_size_type         );
+        DELETE0_SIGNAL( in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE,_param->_size_store_queue_ptr);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,_param->_size_load_queue_ptr);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_HAS_IMMEDIAT         ,1);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_IMMEDIAT             ,_param->_size_general_data);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_READ_RA              ,1);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_NUM_REG_RA           ,_param->_size_general_register);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_READ_RB              ,1);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_NUM_REG_RB           ,_param->_size_general_register);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_READ_RC              ,1);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_NUM_REG_RC           ,_param->_size_special_register);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_WRITE_RD             ,1);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_NUM_REG_RD           ,_param->_size_general_register);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_WRITE_RE             ,1);
+        DELETE0_SIGNAL( in_READ_UNIT_IN_NUM_REG_RE           ,_param->_size_special_register);
 
-	// ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	delete [] out_READ_UNIT_OUT_VAL                  ;
-	delete []  in_READ_UNIT_OUT_ACK                  ;
-	if (_param->_have_port_context_id)
-	delete [] out_READ_UNIT_OUT_CONTEXT_ID           ;
-	if (_param->_have_port_front_end_id)
-	delete [] out_READ_UNIT_OUT_FRONT_END_ID         ;
-	if (_param->_have_port_ooo_engine_id)
-	delete [] out_READ_UNIT_OUT_OOO_ENGINE_ID        ;
-	if (_param->_have_port_rob_ptr)
-	delete [] out_READ_UNIT_OUT_PACKET_ID            ;
-	delete [] out_READ_UNIT_OUT_OPERATION            ;
-	delete [] out_READ_UNIT_OUT_TYPE                 ;
-	delete [] out_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE;
-	if (_param->_have_port_load_queue_ptr)
-	delete [] out_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ;
-	delete [] out_READ_UNIT_OUT_HAS_IMMEDIAT         ;
-	delete [] out_READ_UNIT_OUT_IMMEDIAT             ;
-	delete [] out_READ_UNIT_OUT_DATA_RA              ;
-	delete [] out_READ_UNIT_OUT_DATA_RB              ;
-	delete [] out_READ_UNIT_OUT_DATA_RC              ;
-	delete [] out_READ_UNIT_OUT_WRITE_RD             ;
-	delete [] out_READ_UNIT_OUT_NUM_REG_RD           ;
-	delete [] out_READ_UNIT_OUT_WRITE_RE             ;
-	delete [] out_READ_UNIT_OUT_NUM_REG_RE           ;
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_VAL                  ,_param->_nb_inst_retire,1);
+        DELETE1_SIGNAL( in_READ_UNIT_OUT_ACK                  ,_param->_nb_inst_retire,1);
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_CONTEXT_ID           ,_param->_nb_inst_retire,_param->_size_context_id      );
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_FRONT_END_ID         ,_param->_nb_inst_retire,_param->_size_front_end_id    );
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_OOO_ENGINE_ID        ,_param->_nb_inst_retire,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_PACKET_ID            ,_param->_nb_inst_retire,_param->_size_rob_ptr       );
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_OPERATION            ,_param->_nb_inst_retire,_param->_size_operation       );
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_TYPE                 ,_param->_nb_inst_retire,_param->_size_type            );
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,_param->_nb_inst_retire,_param->_size_store_queue_ptr);
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,_param->_nb_inst_retire,_param->_size_load_queue_ptr);
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_HAS_IMMEDIAT         ,_param->_nb_inst_retire,1                             );
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_IMMEDIAT             ,_param->_nb_inst_retire,_param->_size_general_data    );
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_DATA_RA              ,_param->_nb_inst_retire,_param->_size_general_data    );
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_DATA_RB              ,_param->_nb_inst_retire,_param->_size_general_data    );
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_DATA_RC              ,_param->_nb_inst_retire,_param->_size_special_data    );
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_WRITE_RD             ,_param->_nb_inst_retire,1                             );
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_NUM_REG_RD           ,_param->_nb_inst_retire,_param->_size_general_register);
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_WRITE_RE             ,_param->_nb_inst_retire,1                             );
+        DELETE1_SIGNAL(out_READ_UNIT_OUT_NUM_REG_RE           ,_param->_nb_inst_retire,_param->_size_special_register);
 
-	// ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	delete [] out_GPR_READ_VAL          ;
-	delete []  in_GPR_READ_ACK          ;
-	if (_param->_have_port_ooo_engine_id)
-	delete [] out_GPR_READ_OOO_ENGINE_ID;
-	delete [] out_GPR_READ_NUM_REG      ;
-	delete []  in_GPR_READ_DATA         ;
-	delete []  in_GPR_READ_DATA_VAL     ;
+        DELETE1_SIGNAL(out_GPR_READ_VAL          , _param->_nb_gpr_read,1);
+        DELETE1_SIGNAL( in_GPR_READ_ACK          , _param->_nb_gpr_read,1);
+        DELETE1_SIGNAL(out_GPR_READ_OOO_ENGINE_ID, _param->_nb_gpr_read,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL(out_GPR_READ_NUM_REG      , _param->_nb_gpr_read,_param->_size_general_register);
+        DELETE1_SIGNAL( in_GPR_READ_DATA         , _param->_nb_gpr_read,_param->_size_general_data    );
+        DELETE1_SIGNAL( in_GPR_READ_DATA_VAL     , _param->_nb_gpr_read,1);
 
-	// ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	delete [] out_SPR_READ_VAL          ;
-	delete []  in_SPR_READ_ACK          ;
-	if (_param->_have_port_ooo_engine_id)
-	delete [] out_SPR_READ_OOO_ENGINE_ID;
-	delete [] out_SPR_READ_NUM_REG      ;
-	delete []  in_SPR_READ_DATA         ;
-	delete []  in_SPR_READ_DATA_VAL     ;
+        DELETE1_SIGNAL(out_SPR_READ_VAL          , _param->_nb_spr_read,1);
+        DELETE1_SIGNAL( in_SPR_READ_ACK          , _param->_nb_spr_read,1);
+        DELETE1_SIGNAL(out_SPR_READ_OOO_ENGINE_ID, _param->_nb_spr_read,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL(out_SPR_READ_NUM_REG      , _param->_nb_spr_read,_param->_size_special_register);
+        DELETE1_SIGNAL( in_SPR_READ_DATA         , _param->_nb_spr_read,_param->_size_special_data    );
+        DELETE1_SIGNAL( in_SPR_READ_DATA_VAL     , _param->_nb_spr_read,1);
 
-	// ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	delete []  in_GPR_WRITE_VAL          ;
-	if (_param->_have_port_ooo_engine_id)
-	delete []  in_GPR_WRITE_OOO_ENGINE_ID;
-	delete []  in_GPR_WRITE_NUM_REG      ;
-	delete []  in_GPR_WRITE_DATA         ;
+        DELETE1_SIGNAL( in_GPR_WRITE_VAL          , _param->_nb_gpr_write,1);
+        DELETE1_SIGNAL( in_GPR_WRITE_OOO_ENGINE_ID, _param->_nb_gpr_write,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL( in_GPR_WRITE_NUM_REG      , _param->_nb_gpr_write,_param->_size_general_register);
+        DELETE1_SIGNAL( in_GPR_WRITE_DATA         , _param->_nb_gpr_write,_param->_size_general_data);
 
-	// ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	delete []  in_SPR_WRITE_VAL          ;
-	if (_param->_have_port_ooo_engine_id)
-	delete []  in_SPR_WRITE_OOO_ENGINE_ID;
-	delete []  in_SPR_WRITE_NUM_REG      ;
-	delete []  in_SPR_WRITE_DATA         ;
+        DELETE1_SIGNAL( in_SPR_WRITE_VAL          , _param->_nb_spr_write,1);
+        DELETE1_SIGNAL( in_SPR_WRITE_OOO_ENGINE_ID, _param->_nb_spr_write,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL( in_SPR_WRITE_NUM_REG      , _param->_nb_spr_write,_param->_size_special_register);
+        DELETE1_SIGNAL( in_SPR_WRITE_DATA         , _param->_nb_spr_write,_param->_size_special_data);
 
-	// ~~~~~[ Interface "bypass_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	if (_param->_have_port_ooo_engine_id)
-	delete []  in_BYPASS_WRITE_OOO_ENGINE_ID ;
-	delete []  in_BYPASS_WRITE_GPR_VAL       ;
-	delete []  in_BYPASS_WRITE_GPR_NUM_REG   ;
-	delete []  in_BYPASS_WRITE_GPR_DATA      ;
-	delete []  in_BYPASS_WRITE_SPR_VAL       ;
-	delete []  in_BYPASS_WRITE_SPR_NUM_REG   ;
-	delete []  in_BYPASS_WRITE_SPR_DATA      ;
+        DELETE1_SIGNAL( in_BYPASS_WRITE_OOO_ENGINE_ID, _param->_nb_bypass_write,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL( in_BYPASS_WRITE_GPR_VAL      , _param->_nb_bypass_write,1);
+        DELETE1_SIGNAL( in_BYPASS_WRITE_GPR_NUM_REG  , _param->_nb_bypass_write,_param->_size_general_register);
+        DELETE1_SIGNAL( in_BYPASS_WRITE_GPR_DATA     , _param->_nb_bypass_write,_param->_size_general_data    );
+        DELETE1_SIGNAL( in_BYPASS_WRITE_SPR_VAL      , _param->_nb_bypass_write,1);
+        DELETE1_SIGNAL( in_BYPASS_WRITE_SPR_NUM_REG  , _param->_nb_bypass_write,_param->_size_special_register);
+        DELETE1_SIGNAL( in_BYPASS_WRITE_SPR_DATA     , _param->_nb_bypass_write,_param->_size_special_data    );
 
-	// ~~~~~[ Interface "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	delete []  in_BYPASS_MEMORY_VAL          ;
-	if (_param->_have_port_ooo_engine_id)
-	delete []  in_BYPASS_MEMORY_OOO_ENGINE_ID;
-	delete []  in_BYPASS_MEMORY_NUM_REG      ;
-	delete []  in_BYPASS_MEMORY_DATA         ;
+        DELETE1_SIGNAL( in_BYPASS_MEMORY_VAL          , _param->_nb_bypass_memory,1);
+        DELETE1_SIGNAL( in_BYPASS_MEMORY_OOO_ENGINE_ID, _param->_nb_bypass_memory,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL( in_BYPASS_MEMORY_NUM_REG      , _param->_nb_bypass_memory,_param->_size_general_register);
+        DELETE1_SIGNAL( in_BYPASS_MEMORY_DATA         , _param->_nb_bypass_memory,_param->_size_general_data    );
       }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
