Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Execute_loop_Glue/src/Execute_loop_Glue_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Execute_loop_Glue/src/Execute_loop_Glue_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Execute_loop_Glue/src/Execute_loop_Glue_allocation.cpp	(revision 112)
@@ -58,5 +58,5 @@
     // -----[ Interface "gpr_write_write_unit" ]--------------------------
     {
-      ALLOC1_INTERFACE("gpr_write_write_unit", IN, EAST, _("General register write (from write_unit)"), _param->_nb_gpr_write);
+      ALLOC1_INTERFACE_BEGIN("gpr_write_write_unit", IN, EAST, _("General register write (from write_unit)"), _param->_nb_gpr_write);
       
       ALLOC1_VALACK_IN ( in_GPR_WRITE_WRITE_UNIT_VAL               ,VAL);
@@ -65,9 +65,11 @@
       ALLOC1_SIGNAL_IN ( in_GPR_WRITE_WRITE_UNIT_NUM_REG           ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
       ALLOC1_SIGNAL_IN ( in_GPR_WRITE_WRITE_UNIT_DATA              ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
+
+      ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
     }
 
     // -----[ Interface "gpr_write_register_file" ]-----------------------
     {
-      ALLOC1_INTERFACE("gpr_write_register_file",OUT,SOUTH, _("General register write (to register file)"), _param->_nb_gpr_write);
+      ALLOC1_INTERFACE_BEGIN("gpr_write_register_file",OUT,SOUTH, _("General register write (to register file)"), _param->_nb_gpr_write);
 
       ALLOC1_VALACK_OUT(out_GPR_WRITE_REGISTER_FILE_VAL            ,VAL);							   
@@ -76,9 +78,11 @@
       ALLOC1_SIGNAL_OUT(out_GPR_WRITE_REGISTER_FILE_NUM_REG        ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
       ALLOC1_SIGNAL_OUT(out_GPR_WRITE_REGISTER_FILE_DATA           ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
+
+      ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
     }
 
     // -----[ Interface "gpr_write_read_unit" ]---------------------------
     {
-      ALLOC1_INTERFACE("gpr_write_read_unit",OUT,SOUTH, _("General register write (to read unit)"), _param->_nb_gpr_write);
+      ALLOC1_INTERFACE_BEGIN("gpr_write_read_unit",OUT,SOUTH, _("General register write (to read unit)"), _param->_nb_gpr_write);
 
       ALLOC1_VALACK_OUT(out_GPR_WRITE_READ_UNIT_VAL                ,VAL);							   
@@ -86,9 +90,11 @@
       ALLOC1_SIGNAL_OUT(out_GPR_WRITE_READ_UNIT_NUM_REG            ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
       ALLOC1_SIGNAL_OUT(out_GPR_WRITE_READ_UNIT_DATA               ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
+
+      ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
     }
 
     // -----[ Interface "spr_write_write_unit" ]--------------------------
     {
-      ALLOC1_INTERFACE("spr_write_write_unit", IN, EAST, _("Special register write (from write_unit)"), _param->_nb_spr_write);
+      ALLOC1_INTERFACE_BEGIN("spr_write_write_unit", IN, EAST, _("Special register write (from write_unit)"), _param->_nb_spr_write);
       
       ALLOC1_VALACK_IN ( in_SPR_WRITE_WRITE_UNIT_VAL               ,VAL);
@@ -97,9 +103,11 @@
       ALLOC1_SIGNAL_IN ( in_SPR_WRITE_WRITE_UNIT_NUM_REG           ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);
       ALLOC1_SIGNAL_IN ( in_SPR_WRITE_WRITE_UNIT_DATA              ,"data"         ,Tspecial_data_t   ,_param->_size_special_data);
+
+      ALLOC1_INTERFACE_END(_param->_nb_spr_write);
     }
 
     // -----[ Interface "spr_write_register_file" ]-----------------------
     {
-      ALLOC1_INTERFACE("spr_write_register_file",OUT,SOUTH, _("Special register write (to register file)"), _param->_nb_spr_write);
+      ALLOC1_INTERFACE_BEGIN("spr_write_register_file",OUT,SOUTH, _("Special register write (to register file)"), _param->_nb_spr_write);
 
       ALLOC1_VALACK_OUT(out_SPR_WRITE_REGISTER_FILE_VAL            ,VAL);							   
@@ -108,9 +116,11 @@
       ALLOC1_SIGNAL_OUT(out_SPR_WRITE_REGISTER_FILE_NUM_REG        ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);
       ALLOC1_SIGNAL_OUT(out_SPR_WRITE_REGISTER_FILE_DATA           ,"data"         ,Tspecial_data_t   ,_param->_size_special_data);
+
+      ALLOC1_INTERFACE_END(_param->_nb_spr_write);
     }
 
     // -----[ Interface "spr_write_read_unit" ]---------------------------
     {
-      ALLOC1_INTERFACE("spr_write_read_unit",OUT,SOUTH, _("Special register write (to read unit)"), _param->_nb_spr_write);
+      ALLOC1_INTERFACE_BEGIN("spr_write_read_unit",OUT,SOUTH, _("Special register write (to read unit)"), _param->_nb_spr_write);
 
       ALLOC1_VALACK_OUT(out_SPR_WRITE_READ_UNIT_VAL                ,VAL);							   
@@ -118,4 +128,6 @@
       ALLOC1_SIGNAL_OUT(out_SPR_WRITE_READ_UNIT_NUM_REG            ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);
       ALLOC1_SIGNAL_OUT(out_SPR_WRITE_READ_UNIT_DATA               ,"data"         ,Tspecial_data_t   ,_param->_size_special_data);
+
+      ALLOC1_INTERFACE_END(_param->_nb_spr_write);
     }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_allocation.cpp	(revision 112)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Functionnal_unit.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -50,69 +51,52 @@
     // ~~~~~[ Interface : "execute_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-     {
-      Interface_fifo * interface = _interfaces->set_interface("execute_in"
-#ifdef POSITION
-							      ,IN
-							      ,WEST,
-							      "Input of Functionnal Unit"
-#endif
-							      );
-
-       in_EXECUTE_IN_VAL           = interface->set_signal_valack_in  (VAL);
-      out_EXECUTE_IN_ACK           = interface->set_signal_valack_out (ACK);
-      if (_param->_have_port_context_id)
-       in_EXECUTE_IN_CONTEXT_ID    = interface->set_signal_in <Tcontext_t        > ("context_id"   , _param->_size_context_id   );
-      if (_param->_have_port_front_end_id)
-       in_EXECUTE_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_EXECUTE_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_EXECUTE_IN_PACKET_ID     = interface->set_signal_in <Tpacket_t         > ("packet_id"    , _param->_size_rob_ptr    );
-       in_EXECUTE_IN_OPERATION     = interface->set_signal_in <Toperation_t      > ("operation"    , _param->_size_operation    );
-       in_EXECUTE_IN_TYPE          = interface->set_signal_in <Ttype_t           > ("type"         , _param->_size_type         );
-       in_EXECUTE_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_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE  = interface->set_signal_in <Tlsq_ptr_t> ("load_queue_ptr_write" ,_param->_size_load_queue_ptr);
-       in_EXECUTE_IN_HAS_IMMEDIAT  = interface->set_signal_in <Tcontrol_t        > ("has_immediat" , 1);
-       in_EXECUTE_IN_IMMEDIAT      = interface->set_signal_in <Tgeneral_data_t   > ("immediat"     , _param->_size_general_data);
-       in_EXECUTE_IN_DATA_RA       = interface->set_signal_in <Tgeneral_data_t   > ("data_ra"      , _param->_size_general_data);
-       in_EXECUTE_IN_DATA_RB       = interface->set_signal_in <Tgeneral_data_t   > ("data_rb"      , _param->_size_general_data);
-       in_EXECUTE_IN_DATA_RC       = interface->set_signal_in <Tspecial_data_t   > ("data_rc"      , _param->_size_special_data);
-       in_EXECUTE_IN_WRITE_RD      = interface->set_signal_in <Tcontrol_t        > ("write_rd"     , 1);
-       in_EXECUTE_IN_NUM_REG_RD    = interface->set_signal_in <Tgeneral_address_t> ("num_reg_rd"   , _param->_size_general_register);
-       in_EXECUTE_IN_WRITE_RE      = interface->set_signal_in <Tcontrol_t        > ("write_re"     , 1);
-       in_EXECUTE_IN_NUM_REG_RE    = interface->set_signal_in <Tspecial_address_t> ("num_reg_re"   , _param->_size_special_register);
+    {
+      ALLOC0_INTERFACE_BEGIN("execute_in",IN,WEST,"Input of Functionnal Unit");
+
+      ALLOC0_VALACK_IN ( in_EXECUTE_IN_VAL                   ,VAL);
+      ALLOC0_VALACK_OUT(out_EXECUTE_IN_ACK                   ,ACK);
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_CONTEXT_ID            ,"context_id"           ,Tcontext_t        , _param->_size_context_id   );
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_FRONT_END_ID          ,"front_end_id"         ,Tcontext_t        , _param->_size_front_end_id );
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_OOO_ENGINE_ID         ,"ooo_engine_id"        ,Tcontext_t        , _param->_size_ooo_engine_id);
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_PACKET_ID             ,"packet_id"            ,Tpacket_t         , _param->_size_rob_ptr    );
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_OPERATION             ,"operation"            ,Toperation_t      , _param->_size_operation    );
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_TYPE                  ,"type"                 ,Ttype_t           , _param->_size_type         );
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE ,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr);
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE  ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr);
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_HAS_IMMEDIAT          ,"has_immediat"         ,Tcontrol_t        , 1);
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_IMMEDIAT              ,"immediat"             ,Tgeneral_data_t   , _param->_size_general_data);
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_DATA_RA               ,"data_ra"              ,Tgeneral_data_t   , _param->_size_general_data);
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_DATA_RB               ,"data_rb"              ,Tgeneral_data_t   , _param->_size_general_data);
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_DATA_RC               ,"data_rc"              ,Tspecial_data_t   , _param->_size_special_data);
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_WRITE_RD              ,"write_rd"             ,Tcontrol_t        , 1);
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_NUM_REG_RD            ,"num_reg_rd"           ,Tgeneral_address_t, _param->_size_general_register);
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_WRITE_RE              ,"write_re"             ,Tcontrol_t        , 1);
+      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_NUM_REG_RE            ,"num_reg_re"           ,Tspecial_address_t, _param->_size_special_register);
+
+      ALLOC0_INTERFACE_END();
      }
     // ~~~~~[ Interface : "execute_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~     
      {
-       Interface_fifo * interface = _interfaces->set_interface("execute_out"
-#ifdef POSITION
-							       ,IN
-							       ,EAST,
-							       "Output of Functionnal Unit"
-#endif
-							       );
-
-       out_EXECUTE_OUT_VAL            = interface->set_signal_valack_out (VAL);
-        in_EXECUTE_OUT_ACK            = interface->set_signal_valack_in  (ACK);
-       if (_param->_have_port_context_id)
-       out_EXECUTE_OUT_CONTEXT_ID     = interface->set_signal_out<Tcontext_t        > ("context_id"   ,_param->_size_context_id   );
-       if (_param->_have_port_front_end_id)
-       out_EXECUTE_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_EXECUTE_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_EXECUTE_OUT_PACKET_ID      = interface->set_signal_out<Tpacket_t         > ("packet_id"    ,_param->_size_rob_ptr    );
-     //out_EXECUTE_OUT_OPERATION      = interface->set_signal_out<Toperation_t      > ("operation"    ,_param->_size_operation    );
-     //out_EXECUTE_OUT_TYPE           = interface->set_signal_out<Ttype_t           > ("type"         ,_param->_size_type         );
-       out_EXECUTE_OUT_WRITE_RD       = interface->set_signal_out<Tcontrol_t        > ("write_rd"     ,1);
-       out_EXECUTE_OUT_NUM_REG_RD     = interface->set_signal_out<Tgeneral_address_t> ("num_reg_rd"   ,_param->_size_general_register);
-       out_EXECUTE_OUT_DATA_RD        = interface->set_signal_out<Tgeneral_data_t   > ("data_rd"      ,_param->_size_general_data);
-       out_EXECUTE_OUT_WRITE_RE       = interface->set_signal_out<Tcontrol_t        > ("write_re"     ,1);
-       out_EXECUTE_OUT_NUM_REG_RE     = interface->set_signal_out<Tspecial_address_t> ("num_reg_re"   ,_param->_size_special_register);
-       out_EXECUTE_OUT_DATA_RE        = interface->set_signal_out<Tspecial_data_t   > ("data_re"      ,_param->_size_special_data);
-       out_EXECUTE_OUT_EXCEPTION      = interface->set_signal_out<Texception_t      > ("exception"    ,_param->_size_exception);
-       out_EXECUTE_OUT_NO_SEQUENCE    = interface->set_signal_out<Tcontrol_t        > ("no_sequence"  ,1);
-       out_EXECUTE_OUT_ADDRESS        = interface->set_signal_out<Taddress_t        > ("address"      ,_param->_size_instruction_address);
+       ALLOC0_INTERFACE_BEGIN("execute_out",IN,EAST,"Output of Functionnal Unit");
+
+       ALLOC0_VALACK_OUT(out_EXECUTE_OUT_VAL            ,VAL);
+       ALLOC0_VALACK_IN ( in_EXECUTE_OUT_ACK            ,ACK);
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_CONTEXT_ID     ,"context_id"   ,Tcontext_t        ,_param->_size_context_id   );
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_FRONT_END_ID   ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id );
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_OOO_ENGINE_ID  ,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_PACKET_ID      ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr    );
+     //ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_OPERATION      ,"operation"    ,Toperation_t      ,_param->_size_operation    );
+     //ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_TYPE           ,"type"         ,Ttype_t           ,_param->_size_type         );
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_WRITE_RD       ,"write_rd"     ,Tcontrol_t        ,1);
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_NUM_REG_RD     ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register);
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_DATA_RD        ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data);
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_WRITE_RE       ,"write_re"     ,Tcontrol_t        ,1);
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_NUM_REG_RE     ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register);
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_DATA_RE        ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data);
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_EXCEPTION      ,"exception"    ,Texception_t      ,_param->_size_exception);
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_NO_SEQUENCE    ,"no_sequence"  ,Tcontrol_t        ,1);
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_ADDRESS        ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
+
+       ALLOC0_INTERFACE_END();
      }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_deallocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_deallocation.cpp	(revision 112)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Functionnal_unit.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -29,50 +30,41 @@
 	delete    in_NRESET;
 	
-	delete  in_EXECUTE_IN_VAL           ;
-	delete out_EXECUTE_IN_ACK           ;
-	if (_param->_have_port_context_id)
-	delete  in_EXECUTE_IN_CONTEXT_ID    ;
-	if (_param->_have_port_front_end_id)
-	delete  in_EXECUTE_IN_FRONT_END_ID  ;
-	if (_param->_have_port_ooo_engine_id)
-	delete  in_EXECUTE_IN_OOO_ENGINE_ID ;
-	if (_param->_have_port_rob_ptr)
-	delete  in_EXECUTE_IN_PACKET_ID     ;
-	delete  in_EXECUTE_IN_OPERATION     ;
-	delete  in_EXECUTE_IN_TYPE          ;
-	delete  in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE;
-	if (_param->_have_port_load_queue_ptr)
-	delete  in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE ;
-	delete  in_EXECUTE_IN_HAS_IMMEDIAT  ;
-	delete  in_EXECUTE_IN_IMMEDIAT      ;
-	delete  in_EXECUTE_IN_DATA_RA       ;
-	delete  in_EXECUTE_IN_DATA_RB       ;
-	delete  in_EXECUTE_IN_DATA_RC       ;
-	delete  in_EXECUTE_IN_WRITE_RD      ;
-	delete  in_EXECUTE_IN_NUM_REG_RD    ;
-	delete  in_EXECUTE_IN_WRITE_RE      ;
-	delete  in_EXECUTE_IN_NUM_REG_RE    ;
+        DELETE0_SIGNAL( in_EXECUTE_IN_VAL                   ,1);
+        DELETE0_SIGNAL(out_EXECUTE_IN_ACK                   ,1);
+        DELETE0_SIGNAL( in_EXECUTE_IN_CONTEXT_ID            , _param->_size_context_id   );
+        DELETE0_SIGNAL( in_EXECUTE_IN_FRONT_END_ID          , _param->_size_front_end_id );
+        DELETE0_SIGNAL( in_EXECUTE_IN_OOO_ENGINE_ID         , _param->_size_ooo_engine_id);
+        DELETE0_SIGNAL( in_EXECUTE_IN_PACKET_ID             , _param->_size_rob_ptr    );
+        DELETE0_SIGNAL( in_EXECUTE_IN_OPERATION             , _param->_size_operation    );
+        DELETE0_SIGNAL( in_EXECUTE_IN_TYPE                  , _param->_size_type         );
+        DELETE0_SIGNAL( in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE ,_param->_size_store_queue_ptr);
+        DELETE0_SIGNAL( in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE  ,_param->_size_load_queue_ptr);
+        DELETE0_SIGNAL( in_EXECUTE_IN_HAS_IMMEDIAT          , 1);
+        DELETE0_SIGNAL( in_EXECUTE_IN_IMMEDIAT              , _param->_size_general_data);
+        DELETE0_SIGNAL( in_EXECUTE_IN_DATA_RA               , _param->_size_general_data);
+        DELETE0_SIGNAL( in_EXECUTE_IN_DATA_RB               , _param->_size_general_data);
+        DELETE0_SIGNAL( in_EXECUTE_IN_DATA_RC               , _param->_size_special_data);
+        DELETE0_SIGNAL( in_EXECUTE_IN_WRITE_RD              , 1);
+        DELETE0_SIGNAL( in_EXECUTE_IN_NUM_REG_RD            , _param->_size_general_register);
+        DELETE0_SIGNAL( in_EXECUTE_IN_WRITE_RE              , 1);
+        DELETE0_SIGNAL( in_EXECUTE_IN_NUM_REG_RE            , _param->_size_special_register);
 
-	delete out_EXECUTE_OUT_VAL            ;
-	delete  in_EXECUTE_OUT_ACK            ;
-	if (_param->_have_port_context_id)
-	delete out_EXECUTE_OUT_CONTEXT_ID     ; 
-	if (_param->_have_port_front_end_id)
-	delete out_EXECUTE_OUT_FRONT_END_ID   ; 
-	if (_param->_have_port_ooo_engine_id)
-	delete out_EXECUTE_OUT_OOO_ENGINE_ID  ; 
-	if (_param->_have_port_rob_ptr)
-	delete out_EXECUTE_OUT_PACKET_ID      ; 
-//      delete out_EXECUTE_OUT_OPERATION      ; 
-// 	delete out_EXECUTE_OUT_TYPE           ; 
-	delete out_EXECUTE_OUT_WRITE_RD       ; 
-	delete out_EXECUTE_OUT_NUM_REG_RD     ; 
-	delete out_EXECUTE_OUT_DATA_RD        ; 
-	delete out_EXECUTE_OUT_WRITE_RE       ; 
-	delete out_EXECUTE_OUT_NUM_REG_RE     ; 
-	delete out_EXECUTE_OUT_DATA_RE        ;
-	delete out_EXECUTE_OUT_EXCEPTION      ;
-	delete out_EXECUTE_OUT_NO_SEQUENCE    ;
-	delete out_EXECUTE_OUT_ADDRESS        ;
+        DELETE0_SIGNAL(out_EXECUTE_OUT_VAL            ,1);
+        DELETE0_SIGNAL( in_EXECUTE_OUT_ACK            ,1);
+        DELETE0_SIGNAL(out_EXECUTE_OUT_CONTEXT_ID     ,_param->_size_context_id   );
+        DELETE0_SIGNAL(out_EXECUTE_OUT_FRONT_END_ID   ,_param->_size_front_end_id );
+        DELETE0_SIGNAL(out_EXECUTE_OUT_OOO_ENGINE_ID  ,_param->_size_ooo_engine_id);
+        DELETE0_SIGNAL(out_EXECUTE_OUT_PACKET_ID      ,_param->_size_rob_ptr    );
+      //DELETE0_SIGNAL(out_EXECUTE_OUT_OPERATION      ,_param->_size_operation    );
+      //DELETE0_SIGNAL(out_EXECUTE_OUT_TYPE           ,_param->_size_type         );
+        DELETE0_SIGNAL(out_EXECUTE_OUT_WRITE_RD       ,1);
+        DELETE0_SIGNAL(out_EXECUTE_OUT_NUM_REG_RD     ,_param->_size_general_register);
+        DELETE0_SIGNAL(out_EXECUTE_OUT_DATA_RD        ,_param->_size_general_data);
+        DELETE0_SIGNAL(out_EXECUTE_OUT_WRITE_RE       ,1);
+        DELETE0_SIGNAL(out_EXECUTE_OUT_NUM_REG_RE     ,_param->_size_special_register);
+        DELETE0_SIGNAL(out_EXECUTE_OUT_DATA_RE        ,_param->_size_special_data);
+        DELETE0_SIGNAL(out_EXECUTE_OUT_EXCEPTION      ,_param->_size_exception);
+        DELETE0_SIGNAL(out_EXECUTE_OUT_NO_SEQUENCE    ,1);
+        DELETE0_SIGNAL(out_EXECUTE_OUT_ADDRESS        ,_param->_size_instruction_address);
 
         // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_allocation.cpp	(revision 112)
@@ -54,5 +54,5 @@
     // ~~~~~[ Interface "memory_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     {
-      ALLOC1_INTERFACE("memory_in",IN,WEST,_("Instruction from Reservations station"),_param->_nb_inst_memory);
+      ALLOC1_INTERFACE_BEGIN("memory_in",IN,WEST,_("Instruction from Reservations station"),_param->_nb_inst_memory);
 
       ALLOC1_VALACK_IN ( in_MEMORY_IN_VAL                  ,VAL);
@@ -75,9 +75,11 @@
       ALLOC1_SIGNAL_IN ( in_MEMORY_IN_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1                                  );
       ALLOC1_SIGNAL_IN ( in_MEMORY_IN_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register     );
+    
+      ALLOC1_INTERFACE_END(_param->_nb_inst_memory);
     }
 
     // ~~~~~[ Interface "memory_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     {
-      ALLOC1_INTERFACE("memory_out",OUT,EAST,_("Instruction to write queue"),_param->_nb_inst_memory);
+      ALLOC1_INTERFACE_BEGIN("memory_out",OUT,EAST,_("Instruction to write queue"),_param->_nb_inst_memory);
 
       ALLOC1_VALACK_OUT(out_MEMORY_OUT_VAL          ,VAL);
@@ -98,9 +100,11 @@
       ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_NO_SEQUENCE  ,"no_sequence"   ,Tcontrol_t        ,1                              );
       ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_ADDRESS      ,"address"       ,Taddress_t        ,_param->_size_instruction_address);
+    
+      ALLOC1_INTERFACE_END(_param->_nb_inst_memory);
     }
 
     // ~~~~~[ Interface "dcache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     {
-      ALLOC1_INTERFACE("dcache_req",OUT,NORTH,_("Request port to dcache"),_param->_nb_cache_port);
+      ALLOC1_INTERFACE_BEGIN("dcache_req",OUT,NORTH,_("Request port to dcache"),_param->_nb_cache_port);
 
       ALLOC1_VALACK_OUT(out_DCACHE_REQ_VAL        ,VAL);
@@ -111,9 +115,11 @@
       ALLOC1_SIGNAL_OUT(out_DCACHE_REQ_TYPE       ,"type"      ,Tdcache_type_t   ,_param->_size_dcache_type );
       ALLOC1_SIGNAL_OUT(out_DCACHE_REQ_WDATA      ,"wdata"     ,Tdcache_data_t   ,_param->_size_general_data);
+    
+      ALLOC1_INTERFACE_END(_param->_nb_cache_port);
     }
 
     // ~~~~~[ Interface "dcache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     {
-      ALLOC1_INTERFACE("dcache_rsp",IN,NORTH,_("Respons port from dcache"),_param->_nb_cache_port);
+      ALLOC1_INTERFACE_BEGIN("dcache_rsp",IN,NORTH,_("Respons port from dcache"),_param->_nb_cache_port);
 
       ALLOC1_VALACK_IN ( in_DCACHE_RSP_VAL        ,VAL);
@@ -123,9 +129,11 @@
       ALLOC1_SIGNAL_IN ( in_DCACHE_RSP_RDATA      ,"rdata"     ,Tdcache_data_t ,_param->_size_general_data);
       ALLOC1_SIGNAL_IN ( in_DCACHE_RSP_ERROR      ,"error"     ,Tdcache_error_t,_param->_size_dcache_error);
+
+      ALLOC1_INTERFACE_END(_param->_nb_cache_port);
     }
     // ~~~~~[ Interface "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     {
-      ALLOC1_INTERFACE("bypass_memory",OUT,NORTH,_("Bypass between the load queue and the reservation station"),_param->_nb_bypass_memory);
+      ALLOC1_INTERFACE_BEGIN("bypass_memory",OUT,NORTH,_("Bypass between the load queue and the reservation station"),_param->_nb_bypass_memory);
 	    
       ALLOC1_VALACK_OUT(out_BYPASS_MEMORY_VAL           ,VAL);
@@ -133,4 +141,6 @@
       ALLOC1_SIGNAL_OUT(out_BYPASS_MEMORY_NUM_REG       ,"num_reg"      ,Tgeneral_address_t, _param->_size_general_register);
       ALLOC1_SIGNAL_OUT(out_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_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_function_speculative_load_commit_transition.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_function_speculative_load_commit_transition.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_function_speculative_load_commit_transition.cpp	(revision 112)
@@ -596,6 +596,6 @@
 
 			  // check find a bypass. A speculative load have been committed : report a speculation miss.
-			  if ((_load_queue[index_load]._check_hit != 0)//  and 
-//                               (_load_queue[index_load]._write_rd  == 0)
+			  if ((_load_queue[index_load]._check_hit != 0) and 
+                              (_load_queue[index_load]._write_rd  == 0) // is commit
                               )
 			    {
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 ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/SelfTest/src/test.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/SelfTest/src/test.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/SelfTest/src/test.cpp	(revision 112)
@@ -112,30 +112,30 @@
   sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
 
-  ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_VAL           ," in_EXECUTE_QUEUE_IN_VAL"           , Tcontrol_t        );
-  ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_IN_ACK           ,"out_EXECUTE_QUEUE_IN_ACK"           , Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_CONTEXT_ID    ," in_EXECUTE_QUEUE_IN_CONTEXT_ID"    , Tcontext_t        );
-  ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_FRONT_END_ID  ," in_EXECUTE_QUEUE_IN_FRONT_END_ID"  , Tcontext_t        );
-  ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID ," in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID" , Tcontext_t        );
-  ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_PACKET_ID     ," in_EXECUTE_QUEUE_IN_PACKET_ID"     , Tpacket_t         );
-//ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_OPERATION     ," in_EXECUTE_QUEUE_IN_OPERATION"     , Toperation_t      );
-//ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_TYPE          ," in_EXECUTE_QUEUE_IN_TYPE"          , Ttype_t           );
-  ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_FLAGS         ," in_EXECUTE_QUEUE_IN_FLAGS"         , Tspecial_data_t   );
-  ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_EXCEPTION     ," in_EXECUTE_QUEUE_IN_EXCEPTION"     , Texception_t      );
-  ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_NO_SEQUENCE   ," in_EXECUTE_QUEUE_IN_NO_SEQUENCE"   , Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_ADDRESS       ," in_EXECUTE_QUEUE_IN_ADDRESS"       , Taddress_t        );
-  ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_DATA          ," in_EXECUTE_QUEUE_IN_DATA"          , Tgeneral_data_t   );
-  ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_VAL          ,"out_EXECUTE_QUEUE_OUT_VAL"          , Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_OUT_ACK          ," in_EXECUTE_QUEUE_OUT_ACK"          , Tcontrol_t        );
-  ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_CONTEXT_ID   ,"out_EXECUTE_QUEUE_OUT_CONTEXT_ID"   , Tcontext_t        );
-  ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_FRONT_END_ID ,"out_EXECUTE_QUEUE_OUT_FRONT_END_ID" , Tcontext_t        );
-  ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID,"out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID", Tcontext_t        );
-  ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_PACKET_ID    ,"out_EXECUTE_QUEUE_OUT_PACKET_ID"    , Tpacket_t         );
-//ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_OPERATION    ,"out_EXECUTE_QUEUE_OUT_OPERATION"    , Toperation_t      );
-//ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_TYPE         ,"out_EXECUTE_QUEUE_OUT_TYPE"         , Ttype_t           );
-  ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_FLAGS        ,"out_EXECUTE_QUEUE_OUT_FLAGS"        , Tspecial_data_t   );
-  ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_EXCEPTION    ,"out_EXECUTE_QUEUE_OUT_EXCEPTION"    , Texception_t      );
-  ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ,"out_EXECUTE_QUEUE_OUT_NO_SEQUENCE"  , Tcontrol_t        );
-  ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_ADDRESS      ,"out_EXECUTE_QUEUE_OUT_ADDRESS"      , Taddress_t        );
-  ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_DATA         ,"out_EXECUTE_QUEUE_OUT_DATA"         , Tgeneral_data_t   );
+  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_VAL           ," in_EXECUTE_QUEUE_IN_VAL"           , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_IN_ACK           ,"out_EXECUTE_QUEUE_IN_ACK"           , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_CONTEXT_ID    ," in_EXECUTE_QUEUE_IN_CONTEXT_ID"    , Tcontext_t        );
+  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_FRONT_END_ID  ," in_EXECUTE_QUEUE_IN_FRONT_END_ID"  , Tcontext_t        );
+  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID ," in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID" , Tcontext_t        );
+  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_PACKET_ID     ," in_EXECUTE_QUEUE_IN_PACKET_ID"     , Tpacket_t         );
+//ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_OPERATION     ," in_EXECUTE_QUEUE_IN_OPERATION"     , Toperation_t      );
+//ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_TYPE          ," in_EXECUTE_QUEUE_IN_TYPE"          , Ttype_t           );
+  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_FLAGS         ," in_EXECUTE_QUEUE_IN_FLAGS"         , Tspecial_data_t   );
+  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_EXCEPTION     ," in_EXECUTE_QUEUE_IN_EXCEPTION"     , Texception_t      );
+  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_NO_SEQUENCE   ," in_EXECUTE_QUEUE_IN_NO_SEQUENCE"   , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_ADDRESS       ," in_EXECUTE_QUEUE_IN_ADDRESS"       , Taddress_t        );
+  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_DATA          ," in_EXECUTE_QUEUE_IN_DATA"          , Tgeneral_data_t   );
+  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_VAL          ,"out_EXECUTE_QUEUE_OUT_VAL"          , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_OUT_ACK          ," in_EXECUTE_QUEUE_OUT_ACK"          , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_CONTEXT_ID   ,"out_EXECUTE_QUEUE_OUT_CONTEXT_ID"   , Tcontext_t        );
+  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_FRONT_END_ID ,"out_EXECUTE_QUEUE_OUT_FRONT_END_ID" , Tcontext_t        );
+  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID,"out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID", Tcontext_t        );
+  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_PACKET_ID    ,"out_EXECUTE_QUEUE_OUT_PACKET_ID"    , Tpacket_t         );
+//ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_OPERATION    ,"out_EXECUTE_QUEUE_OUT_OPERATION"    , Toperation_t      );
+//ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_TYPE         ,"out_EXECUTE_QUEUE_OUT_TYPE"         , Ttype_t           );
+  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_FLAGS        ,"out_EXECUTE_QUEUE_OUT_FLAGS"        , Tspecial_data_t   );
+  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_EXCEPTION    ,"out_EXECUTE_QUEUE_OUT_EXCEPTION"    , Texception_t      );
+  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ,"out_EXECUTE_QUEUE_OUT_NO_SEQUENCE"  , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_ADDRESS      ,"out_EXECUTE_QUEUE_OUT_ADDRESS"      , Taddress_t        );
+  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_DATA         ,"out_EXECUTE_QUEUE_OUT_DATA"         , Tgeneral_data_t   );
 
   
@@ -149,39 +149,39 @@
   (*(_Execute_queue->in_NRESET))       (*(in_NRESET));
 
-  INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_VAL           );
-  INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_IN_ACK           );
+  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_VAL           );
+  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_IN_ACK           );
   if (_param->_have_port_context_id)
-  INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_CONTEXT_ID    );
+  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_CONTEXT_ID    );
   if (_param->_have_port_front_end_id)
-  INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_FRONT_END_ID  );
+  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_FRONT_END_ID  );
   if (_param->_have_port_ooo_engine_id)
-  INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID );
+  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID );
   if (_param->_have_port_rob_ptr)
-  INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_PACKET_ID     );
-//INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_OPERATION     );
-//INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_TYPE          );
-  INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_FLAGS         );
-  INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_EXCEPTION     );
-  INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_NO_SEQUENCE   );
-  INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_ADDRESS       );
-  INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_DATA          );
-
-  INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_VAL          );
-  INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_OUT_ACK          );
+  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_PACKET_ID     );
+//INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_OPERATION     );
+//INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_TYPE          );
+  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_FLAGS         );
+  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_EXCEPTION     );
+  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_NO_SEQUENCE   );
+  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_ADDRESS       );
+  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_DATA          );
+
+  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_VAL          );
+  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_OUT_ACK          );
   if (_param->_have_port_context_id)
-  INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_CONTEXT_ID   );
+  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_CONTEXT_ID   );
   if (_param->_have_port_front_end_id)
-  INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_FRONT_END_ID );
+  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_FRONT_END_ID );
   if (_param->_have_port_ooo_engine_id)
-  INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID);
+  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID);
   if (_param->_have_port_rob_ptr)
-  INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_PACKET_ID    );
-//INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_OPERATION    );
-//INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_TYPE         );
-  INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_FLAGS        );
-  INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_EXCEPTION    );
-  INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  );
-  INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_ADDRESS      );
-  INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_DATA         );
+  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_PACKET_ID    );
+//INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_OPERATION    );
+//INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_TYPE         );
+  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_FLAGS        );
+  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_EXCEPTION    );
+  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  );
+  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_ADDRESS      );
+  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_DATA         );
 
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Execute_queue_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Execute_queue_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Execute_queue_allocation.cpp	(revision 112)
@@ -50,46 +50,42 @@
     // -----[ Interface "execute_queue_in" ]--------------------------------    
      {
-       ALLOC_INTERFACE ("execute_queue_in", IN, WEST, "Input of execute_queue");
+       ALLOC0_INTERFACE_BEGIN("execute_queue_in", IN, WEST, "Input of execute_queue");
        
-       ALLOC_VALACK_IN ( in_EXECUTE_QUEUE_IN_VAL,VAL);
-       ALLOC_VALACK_OUT(out_EXECUTE_QUEUE_IN_ACK,ACK);
-       if(_param->_have_port_context_id)
-       ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
-       if(_param->_have_port_front_end_id)
-       ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
-       if(_param->_have_port_ooo_engine_id)
-       ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id    );
-       if(_param->_have_port_rob_ptr)
-       ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr        );
-//     ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation        );
-//     ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type             );
-       ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_FLAGS        ,"flags"        ,Tspecial_data_t   ,_param->_size_special_data     );
-       ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception        );
-       ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                              );
-       ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
-       ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data     );
+       ALLOC0_VALACK_IN ( in_EXECUTE_QUEUE_IN_VAL,VAL);
+       ALLOC0_VALACK_OUT(out_EXECUTE_QUEUE_IN_ACK,ACK);
+       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
+       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
+       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id    );
+       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr        );
+//     ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation        );
+//     ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type             );
+       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_FLAGS        ,"flags"        ,Tspecial_data_t   ,_param->_size_special_data     );
+       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception        );
+       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                              );
+       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
+       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data     );
+
+       ALLOC0_INTERFACE_END();
      }
 
     // -----[ Interface "execute_queue_out" ]-------------------------------
      {
-       ALLOC_INTERFACE ("execute_queue_out", OUT, EAST, "Output of execute_queue");
+       ALLOC0_INTERFACE_BEGIN("execute_queue_out", OUT, EAST, "Output of execute_queue");
        
-       ALLOC_VALACK_OUT(out_EXECUTE_QUEUE_OUT_VAL,VAL);
-       ALLOC_VALACK_IN ( in_EXECUTE_QUEUE_OUT_ACK,ACK);
-       if(_param->_have_port_context_id)
-       ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
-       if(_param->_have_port_front_end_id)
-       ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
-       if(_param->_have_port_ooo_engine_id)
-       ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t     ,_param->_size_ooo_engine_id);
-       if(_param->_have_port_rob_ptr)
-       ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_rob_ptr    );
-//     ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_OPERATION    ,"operation"    ,Toperation_t   ,_param->_size_operation    );
-//     ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_TYPE         ,"type"         ,Ttype_t        ,_param->_size_type         );
-       ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_FLAGS        ,"flags"        ,Tspecial_data_t,_param->_size_special_data );
-       ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_EXCEPTION    ,"exception"    ,Texception_t   ,_param->_size_exception    );
-       ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
-       ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
-       ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
+       ALLOC0_VALACK_OUT(out_EXECUTE_QUEUE_OUT_VAL,VAL);
+       ALLOC0_VALACK_IN ( in_EXECUTE_QUEUE_OUT_ACK,ACK);
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t     ,_param->_size_ooo_engine_id);
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_rob_ptr    );
+//     ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_OPERATION    ,"operation"    ,Toperation_t   ,_param->_size_operation    );
+//     ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_TYPE         ,"type"         ,Ttype_t        ,_param->_size_type         );
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_FLAGS        ,"flags"        ,Tspecial_data_t,_param->_size_special_data );
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_EXCEPTION    ,"exception"    ,Texception_t   ,_param->_size_exception    );
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
+       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
+
+       ALLOC0_INTERFACE_END();
      }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Execute_queue_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Execute_queue_deallocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Execute_queue_deallocation.cpp	(revision 112)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/include/Execute_queue.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -29,41 +30,31 @@
 	delete    in_NRESET;
 
-	// -----[ Interface "execute_queue_in" ]--------------------------------    
-	delete      in_EXECUTE_QUEUE_IN_VAL          ;
-	delete     out_EXECUTE_QUEUE_IN_ACK          ;
-	if (_param->_have_port_context_id)
-	delete      in_EXECUTE_QUEUE_IN_CONTEXT_ID   ;
-	if (_param->_have_port_front_end_id)
-	delete      in_EXECUTE_QUEUE_IN_FRONT_END_ID ;
-	if (_param->_have_port_ooo_engine_id)
-	delete      in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID;
-        if (_param->_have_port_rob_ptr)
-	delete      in_EXECUTE_QUEUE_IN_PACKET_ID    ;
-//      delete      in_EXECUTE_QUEUE_IN_OPERATION    ;
-//      delete      in_EXECUTE_QUEUE_IN_TYPE         ;
-        delete      in_EXECUTE_QUEUE_IN_FLAGS        ;
-        delete      in_EXECUTE_QUEUE_IN_EXCEPTION    ;
-        delete      in_EXECUTE_QUEUE_IN_NO_SEQUENCE  ;
-        delete      in_EXECUTE_QUEUE_IN_ADDRESS      ;
-        delete      in_EXECUTE_QUEUE_IN_DATA         ;
-
-	// -----[ Interface "execute_queue_out" ]-------------------------------    
-        delete     out_EXECUTE_QUEUE_OUT_VAL          ;
-        delete      in_EXECUTE_QUEUE_OUT_ACK          ;
-        if (_param->_have_port_context_id)
-	delete     out_EXECUTE_QUEUE_OUT_CONTEXT_ID   ;
-        if (_param->_have_port_front_end_id)
-	delete     out_EXECUTE_QUEUE_OUT_FRONT_END_ID ;
-        if (_param->_have_port_ooo_engine_id)
-	delete     out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID;
-        if (_param->_have_port_rob_ptr)
-	delete     out_EXECUTE_QUEUE_OUT_PACKET_ID    ;
-//      delete     out_EXECUTE_QUEUE_OUT_OPERATION    ;
-//      delete     out_EXECUTE_QUEUE_OUT_TYPE         ;
-        delete     out_EXECUTE_QUEUE_OUT_FLAGS        ;
-        delete     out_EXECUTE_QUEUE_OUT_EXCEPTION    ;
-        delete     out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ;
-        delete     out_EXECUTE_QUEUE_OUT_ADDRESS      ;
-        delete     out_EXECUTE_QUEUE_OUT_DATA         ;
+        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_VAL           ,1);
+        DELETE0_SIGNAL(out_EXECUTE_QUEUE_IN_ACK           ,1);
+        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_CONTEXT_ID    ,_param->_size_context_id       );
+        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_FRONT_END_ID  ,_param->_size_front_end_id     );
+        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID ,_param->_size_ooo_engine_id    );
+        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_PACKET_ID     ,_param->_size_rob_ptr          );
+//      DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_OPERATION     ,_param->_size_operation        );
+//      DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_TYPE          ,_param->_size_type             );
+        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_FLAGS         ,_param->_size_special_data     );
+        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_EXCEPTION     ,_param->_size_exception        );
+        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_NO_SEQUENCE   ,1                              );
+        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_ADDRESS       ,_param->_size_instruction_address);
+        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_DATA          ,_param->_size_general_data     );
+        
+        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_VAL          ,1);
+        DELETE0_SIGNAL( in_EXECUTE_QUEUE_OUT_ACK          ,1);
+        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_CONTEXT_ID   ,_param->_size_context_id   );
+        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_FRONT_END_ID ,_param->_size_front_end_id );
+        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID,_param->_size_ooo_engine_id);
+        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_PACKET_ID    ,_param->_size_rob_ptr    );
+//      DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_OPERATION    ,_param->_size_operation    );
+//      DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_TYPE         ,_param->_size_type         );
+        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_FLAGS        ,_param->_size_special_data );
+        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_EXCEPTION    ,_param->_size_exception    );
+        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ,1                          );
+        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_ADDRESS      ,_param->_size_instruction_address);
+        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_DATA         ,_param->_size_general_data );
       }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/SelfTest/src/test.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/SelfTest/src/test.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/SelfTest/src/test.cpp	(revision 112)
@@ -126,34 +126,34 @@
   sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
 
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_VAL           ," in_WRITE_UNIT_IN_VAL"           , Tcontrol_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_UNIT_IN_ACK           ,"out_WRITE_UNIT_IN_ACK"           , Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_CONTEXT_ID    ," in_WRITE_UNIT_IN_CONTEXT_ID"    , Tcontext_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_FRONT_END_ID  ," in_WRITE_UNIT_IN_FRONT_END_ID"  , Tcontext_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_OOO_ENGINE_ID ," in_WRITE_UNIT_IN_OOO_ENGINE_ID" , Tcontext_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_PACKET_ID     ," in_WRITE_UNIT_IN_PACKET_ID"     , Tpacket_t         );
-//ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_OPERATION     ," in_WRITE_UNIT_IN_OPERATION"     , Toperation_t      );
-//ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_TYPE          ," in_WRITE_UNIT_IN_TYPE"          , Ttype_t           );
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_WRITE_RD      ," in_WRITE_UNIT_IN_WRITE_RD"      , Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_NUM_REG_RD    ," in_WRITE_UNIT_IN_NUM_REG_RD"    , Tgeneral_address_t);
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_DATA_RD       ," in_WRITE_UNIT_IN_DATA_RD"       , Tgeneral_data_t   );
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_WRITE_RE      ," in_WRITE_UNIT_IN_WRITE_RE"      , Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_NUM_REG_RE    ," in_WRITE_UNIT_IN_NUM_REG_RE"    , Tspecial_address_t);
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_DATA_RE       ," in_WRITE_UNIT_IN_DATA_RE"       , Tspecial_data_t   );
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_EXCEPTION     ," in_WRITE_UNIT_IN_EXCEPTION"     , Texception_t      );
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_NO_SEQUENCE   ," in_WRITE_UNIT_IN_NO_SEQUENCE"   , Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_ADDRESS       ," in_WRITE_UNIT_IN_ADDRESS"       , Taddress_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_VAL          ,"out_WRITE_UNIT_OUT_VAL"          , Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_UNIT_OUT_ACK          ," in_WRITE_UNIT_OUT_ACK"          , Tcontrol_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_CONTEXT_ID   ,"out_WRITE_UNIT_OUT_CONTEXT_ID"   , Tcontext_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_FRONT_END_ID ,"out_WRITE_UNIT_OUT_FRONT_END_ID" , Tcontext_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_OOO_ENGINE_ID,"out_WRITE_UNIT_OUT_OOO_ENGINE_ID", Tcontext_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_PACKET_ID    ,"out_WRITE_UNIT_OUT_PACKET_ID"    , Tpacket_t         );
-//ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_OPERATION    ,"out_WRITE_UNIT_OUT_OPERATION"    , Toperation_t      );
-//ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_TYPE         ,"out_WRITE_UNIT_OUT_TYPE"         , Ttype_t           );
-  ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_FLAGS        ,"out_WRITE_UNIT_OUT_FLAGS"        , Tspecial_data_t   );
-  ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_EXCEPTION    ,"out_WRITE_UNIT_OUT_EXCEPTION"    , Texception_t      );
-  ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_NO_SEQUENCE  ,"out_WRITE_UNIT_OUT_NO_SEQUENCE"  , Tcontrol_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_ADDRESS      ,"out_WRITE_UNIT_OUT_ADDRESS"      , Taddress_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_DATA         ,"out_WRITE_UNIT_OUT_DATA"         , Tgeneral_data_t   );
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_VAL           ," in_WRITE_UNIT_IN_VAL"           , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_IN_ACK           ,"out_WRITE_UNIT_IN_ACK"           , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_CONTEXT_ID    ," in_WRITE_UNIT_IN_CONTEXT_ID"    , Tcontext_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_FRONT_END_ID  ," in_WRITE_UNIT_IN_FRONT_END_ID"  , Tcontext_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_OOO_ENGINE_ID ," in_WRITE_UNIT_IN_OOO_ENGINE_ID" , Tcontext_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_PACKET_ID     ," in_WRITE_UNIT_IN_PACKET_ID"     , Tpacket_t         );
+//ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_OPERATION     ," in_WRITE_UNIT_IN_OPERATION"     , Toperation_t      );
+//ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_TYPE          ," in_WRITE_UNIT_IN_TYPE"          , Ttype_t           );
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_WRITE_RD      ," in_WRITE_UNIT_IN_WRITE_RD"      , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_NUM_REG_RD    ," in_WRITE_UNIT_IN_NUM_REG_RD"    , Tgeneral_address_t);
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_DATA_RD       ," in_WRITE_UNIT_IN_DATA_RD"       , Tgeneral_data_t   );
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_WRITE_RE      ," in_WRITE_UNIT_IN_WRITE_RE"      , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_NUM_REG_RE    ," in_WRITE_UNIT_IN_NUM_REG_RE"    , Tspecial_address_t);
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_DATA_RE       ," in_WRITE_UNIT_IN_DATA_RE"       , Tspecial_data_t   );
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_EXCEPTION     ," in_WRITE_UNIT_IN_EXCEPTION"     , Texception_t      );
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_NO_SEQUENCE   ," in_WRITE_UNIT_IN_NO_SEQUENCE"   , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_ADDRESS       ," in_WRITE_UNIT_IN_ADDRESS"       , Taddress_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_VAL          ,"out_WRITE_UNIT_OUT_VAL"          , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_OUT_ACK          ," in_WRITE_UNIT_OUT_ACK"          , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_CONTEXT_ID   ,"out_WRITE_UNIT_OUT_CONTEXT_ID"   , Tcontext_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_FRONT_END_ID ,"out_WRITE_UNIT_OUT_FRONT_END_ID" , Tcontext_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_OOO_ENGINE_ID,"out_WRITE_UNIT_OUT_OOO_ENGINE_ID", Tcontext_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_PACKET_ID    ,"out_WRITE_UNIT_OUT_PACKET_ID"    , Tpacket_t         );
+//ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_OPERATION    ,"out_WRITE_UNIT_OUT_OPERATION"    , Toperation_t      );
+//ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_TYPE         ,"out_WRITE_UNIT_OUT_TYPE"         , Ttype_t           );
+  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_FLAGS        ,"out_WRITE_UNIT_OUT_FLAGS"        , Tspecial_data_t   );
+  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_EXCEPTION    ,"out_WRITE_UNIT_OUT_EXCEPTION"    , Texception_t      );
+  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_NO_SEQUENCE  ,"out_WRITE_UNIT_OUT_NO_SEQUENCE"  , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_ADDRESS      ,"out_WRITE_UNIT_OUT_ADDRESS"      , Taddress_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_DATA         ,"out_WRITE_UNIT_OUT_DATA"         , Tgeneral_data_t   );
   ALLOC1_SC_SIGNAL(out_GPR_WRITE_VAL                ,"out_GPR_WRITE_VAL"                , Tcontrol_t        , _param->_nb_gpr_write);
   ALLOC1_SC_SIGNAL( in_GPR_WRITE_ACK                ," in_GPR_WRITE_ACK"                , Tcontrol_t        , _param->_nb_gpr_write);
@@ -184,42 +184,42 @@
   (*(_Write_unit->in_NRESET))       (*(in_NRESET));
 
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_VAL           );
-  INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_IN_ACK           );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_VAL           );
+  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_IN_ACK           );
   if (_param->_have_port_context_id)
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_CONTEXT_ID    );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_CONTEXT_ID    );
   if (_param->_have_port_front_end_id)
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_FRONT_END_ID  );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_FRONT_END_ID  );
   if (_param->_have_port_ooo_engine_id)
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_OOO_ENGINE_ID );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_OOO_ENGINE_ID );
   if (_param->_have_port_rob_ptr)
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_PACKET_ID     );
-//INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_OPERATION     );
-//INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_TYPE          );
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_WRITE_RD      );
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_NUM_REG_RD    );
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_DATA_RD       );
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_WRITE_RE      );
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_NUM_REG_RE    );
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_DATA_RE       );
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_EXCEPTION     );
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_NO_SEQUENCE   );
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_ADDRESS       );
-  INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_VAL          );
-  INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_OUT_ACK          );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_PACKET_ID     );
+//INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_OPERATION     );
+//INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_TYPE          );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_WRITE_RD      );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_NUM_REG_RD    );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_DATA_RD       );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_WRITE_RE      );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_NUM_REG_RE    );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_DATA_RE       );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_EXCEPTION     );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_NO_SEQUENCE   );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_ADDRESS       );
+  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_VAL          );
+  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_OUT_ACK          );
   if (_param->_have_port_context_id)
-  INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_CONTEXT_ID   );
+  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_CONTEXT_ID   );
   if (_param->_have_port_front_end_id)
-  INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_FRONT_END_ID );
+  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_FRONT_END_ID );
   if (_param->_have_port_ooo_engine_id)
-  INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_OOO_ENGINE_ID);
+  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_OOO_ENGINE_ID);
   if (_param->_have_port_rob_ptr)
-  INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_PACKET_ID    );
-//INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_OPERATION    );
-//INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_TYPE         );
-  INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_FLAGS        );
-  INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_EXCEPTION    );
-  INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_NO_SEQUENCE  );
-  INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_ADDRESS      );
-  INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_DATA         );
+  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_PACKET_ID    );
+//INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_OPERATION    );
+//INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_TYPE         );
+  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_FLAGS        );
+  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_EXCEPTION    );
+  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_NO_SEQUENCE  );
+  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_ADDRESS      );
+  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_DATA         );
   INSTANCE1_SC_SIGNAL(_Write_unit, out_GPR_WRITE_VAL                , _param->_nb_gpr_write);
   INSTANCE1_SC_SIGNAL(_Write_unit,  in_GPR_WRITE_ACK                , _param->_nb_gpr_write);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/SelfTest/src/test.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/SelfTest/src/test.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/SelfTest/src/test.cpp	(revision 112)
@@ -125,34 +125,34 @@
   sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
 
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_VAL           ," in_WRITE_QUEUE_IN_VAL"           , Tcontrol_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_QUEUE_IN_ACK           ,"out_WRITE_QUEUE_IN_ACK"           , Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_CONTEXT_ID    ," in_WRITE_QUEUE_IN_CONTEXT_ID"    , Tcontext_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_FRONT_END_ID  ," in_WRITE_QUEUE_IN_FRONT_END_ID"  , Tcontext_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_OOO_ENGINE_ID ," in_WRITE_QUEUE_IN_OOO_ENGINE_ID" , Tcontext_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_PACKET_ID     ," in_WRITE_QUEUE_IN_PACKET_ID"     , Tpacket_t         );
-//ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_OPERATION     ," in_WRITE_QUEUE_IN_OPERATION"     , Toperation_t      );
-//ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_TYPE          ," in_WRITE_QUEUE_IN_TYPE"          , Ttype_t           );
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_WRITE_RD      ," in_WRITE_QUEUE_IN_WRITE_RD"      , Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_NUM_REG_RD    ," in_WRITE_QUEUE_IN_NUM_REG_RD"    , Tgeneral_address_t);
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_DATA_RD       ," in_WRITE_QUEUE_IN_DATA_RD"       , Tgeneral_data_t   );
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_WRITE_RE      ," in_WRITE_QUEUE_IN_WRITE_RE"      , Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_NUM_REG_RE    ," in_WRITE_QUEUE_IN_NUM_REG_RE"    , Tspecial_address_t);
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_DATA_RE       ," in_WRITE_QUEUE_IN_DATA_RE"       , Tspecial_data_t   );
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_EXCEPTION     ," in_WRITE_QUEUE_IN_EXCEPTION"     , Texception_t      );
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_NO_SEQUENCE   ," in_WRITE_QUEUE_IN_NO_SEQUENCE"   , Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_ADDRESS       ," in_WRITE_QUEUE_IN_ADDRESS"       , Taddress_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_VAL          ,"out_WRITE_QUEUE_OUT_VAL"          , Tcontrol_t        );
-  ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_OUT_ACK          ," in_WRITE_QUEUE_OUT_ACK"          , Tcontrol_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_CONTEXT_ID   ,"out_WRITE_QUEUE_OUT_CONTEXT_ID"   , Tcontext_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_FRONT_END_ID ,"out_WRITE_QUEUE_OUT_FRONT_END_ID" , Tcontext_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_OOO_ENGINE_ID,"out_WRITE_QUEUE_OUT_OOO_ENGINE_ID", Tcontext_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_PACKET_ID    ,"out_WRITE_QUEUE_OUT_PACKET_ID"    , Tpacket_t         );
-//ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_OPERATION    ,"out_WRITE_QUEUE_OUT_OPERATION"    , Toperation_t      );
-//ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_TYPE         ,"out_WRITE_QUEUE_OUT_TYPE"         , Ttype_t           );
-  ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_FLAGS        ,"out_WRITE_QUEUE_OUT_FLAGS"        , Tspecial_data_t   );
-  ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_EXCEPTION    ,"out_WRITE_QUEUE_OUT_EXCEPTION"    , Texception_t      );
-  ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_NO_SEQUENCE  ,"out_WRITE_QUEUE_OUT_NO_SEQUENCE"  , Tcontrol_t        );
-  ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_ADDRESS      ,"out_WRITE_QUEUE_OUT_ADDRESS"      , Tgeneral_data_t   );
-  ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_DATA         ,"out_WRITE_QUEUE_OUT_DATA"         , Taddress_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_VAL           ," in_WRITE_QUEUE_IN_VAL"           , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_IN_ACK           ,"out_WRITE_QUEUE_IN_ACK"           , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_CONTEXT_ID    ," in_WRITE_QUEUE_IN_CONTEXT_ID"    , Tcontext_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_FRONT_END_ID  ," in_WRITE_QUEUE_IN_FRONT_END_ID"  , Tcontext_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_OOO_ENGINE_ID ," in_WRITE_QUEUE_IN_OOO_ENGINE_ID" , Tcontext_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_PACKET_ID     ," in_WRITE_QUEUE_IN_PACKET_ID"     , Tpacket_t         );
+//ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_OPERATION     ," in_WRITE_QUEUE_IN_OPERATION"     , Toperation_t      );
+//ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_TYPE          ," in_WRITE_QUEUE_IN_TYPE"          , Ttype_t           );
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_WRITE_RD      ," in_WRITE_QUEUE_IN_WRITE_RD"      , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_NUM_REG_RD    ," in_WRITE_QUEUE_IN_NUM_REG_RD"    , Tgeneral_address_t);
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_DATA_RD       ," in_WRITE_QUEUE_IN_DATA_RD"       , Tgeneral_data_t   );
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_WRITE_RE      ," in_WRITE_QUEUE_IN_WRITE_RE"      , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_NUM_REG_RE    ," in_WRITE_QUEUE_IN_NUM_REG_RE"    , Tspecial_address_t);
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_DATA_RE       ," in_WRITE_QUEUE_IN_DATA_RE"       , Tspecial_data_t   );
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_EXCEPTION     ," in_WRITE_QUEUE_IN_EXCEPTION"     , Texception_t      );
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_NO_SEQUENCE   ," in_WRITE_QUEUE_IN_NO_SEQUENCE"   , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_ADDRESS       ," in_WRITE_QUEUE_IN_ADDRESS"       , Taddress_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_VAL          ,"out_WRITE_QUEUE_OUT_VAL"          , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_OUT_ACK          ," in_WRITE_QUEUE_OUT_ACK"          , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_CONTEXT_ID   ,"out_WRITE_QUEUE_OUT_CONTEXT_ID"   , Tcontext_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_FRONT_END_ID ,"out_WRITE_QUEUE_OUT_FRONT_END_ID" , Tcontext_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_OOO_ENGINE_ID,"out_WRITE_QUEUE_OUT_OOO_ENGINE_ID", Tcontext_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_PACKET_ID    ,"out_WRITE_QUEUE_OUT_PACKET_ID"    , Tpacket_t         );
+//ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_OPERATION    ,"out_WRITE_QUEUE_OUT_OPERATION"    , Toperation_t      );
+//ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_TYPE         ,"out_WRITE_QUEUE_OUT_TYPE"         , Ttype_t           );
+  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_FLAGS        ,"out_WRITE_QUEUE_OUT_FLAGS"        , Tspecial_data_t   );
+  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_EXCEPTION    ,"out_WRITE_QUEUE_OUT_EXCEPTION"    , Texception_t      );
+  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_NO_SEQUENCE  ,"out_WRITE_QUEUE_OUT_NO_SEQUENCE"  , Tcontrol_t        );
+  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_ADDRESS      ,"out_WRITE_QUEUE_OUT_ADDRESS"      , Tgeneral_data_t   );
+  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_DATA         ,"out_WRITE_QUEUE_OUT_DATA"         , Taddress_t        );
   ALLOC1_SC_SIGNAL(out_GPR_WRITE_VAL                ,"out_GPR_WRITE_VAL"                , Tcontrol_t        , _param->_nb_gpr_write);
   ALLOC1_SC_SIGNAL( in_GPR_WRITE_ACK                ," in_GPR_WRITE_ACK"                , Tcontrol_t        , _param->_nb_gpr_write);
@@ -182,42 +182,42 @@
   (*(_Write_queue->in_NRESET))       (*(in_NRESET));
 
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_VAL           );
-  INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_IN_ACK           );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_VAL           );
+  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_IN_ACK           );
   if (_param->_have_port_context_id)
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_CONTEXT_ID    );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_CONTEXT_ID    );
   if (_param->_have_port_front_end_id)
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_FRONT_END_ID  );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_FRONT_END_ID  );
   if (_param->_have_port_ooo_engine_id)
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_OOO_ENGINE_ID );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_OOO_ENGINE_ID );
   if (_param->_have_port_rob_ptr  )
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_PACKET_ID     );
-//INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_OPERATION     );
-//INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_TYPE          );
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_WRITE_RD      );
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_NUM_REG_RD    );
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_DATA_RD       );
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_WRITE_RE      );
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_NUM_REG_RE    );
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_DATA_RE       );
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_EXCEPTION     );
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_NO_SEQUENCE   );
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_ADDRESS       );
-  INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_VAL          );
-  INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_OUT_ACK          );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_PACKET_ID     );
+//INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_OPERATION     );
+//INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_TYPE          );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_WRITE_RD      );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_NUM_REG_RD    );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_DATA_RD       );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_WRITE_RE      );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_NUM_REG_RE    );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_DATA_RE       );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_EXCEPTION     );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_NO_SEQUENCE   );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_ADDRESS       );
+  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_VAL          );
+  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_OUT_ACK          );
   if (_param->_have_port_context_id)
-  INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_CONTEXT_ID   );
+  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_CONTEXT_ID   );
   if (_param->_have_port_front_end_id)
-  INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_FRONT_END_ID );
+  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_FRONT_END_ID );
   if (_param->_have_port_ooo_engine_id)
-  INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_OOO_ENGINE_ID);
+  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_OOO_ENGINE_ID);
   if (_param->_have_port_rob_ptr  )
-  INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_PACKET_ID    );
-//INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_OPERATION    );
-//INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_TYPE         );
-  INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_FLAGS        );
-  INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_EXCEPTION    );
-  INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_NO_SEQUENCE  );
-  INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_ADDRESS      );
-  INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_DATA         );
+  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_PACKET_ID    );
+//INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_OPERATION    );
+//INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_TYPE         );
+  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_FLAGS        );
+  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_EXCEPTION    );
+  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_NO_SEQUENCE  );
+  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_ADDRESS      );
+  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_DATA         );
   INSTANCE1_SC_SIGNAL(_Write_queue, out_GPR_WRITE_VAL                , _param->_nb_gpr_write);
   INSTANCE1_SC_SIGNAL(_Write_queue,  in_GPR_WRITE_ACK                , _param->_nb_gpr_write);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_allocation.cpp	(revision 112)
@@ -51,47 +51,51 @@
     // -----[ Interface "Write_queue_in" ]--------------------------------    
      {
-       ALLOC_INTERFACE ("write_queue_in", IN, WEST, "Input of write_queue");
+       ALLOC0_INTERFACE_BEGIN ("write_queue_in", IN, WEST, "Input of write_queue");
        
-       ALLOC_VALACK_IN ( in_WRITE_QUEUE_IN_VAL,VAL);
-       ALLOC_VALACK_OUT(out_WRITE_QUEUE_IN_ACK,ACK);
-       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
-       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
-       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id    );
-       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr          );
-//     ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation        );
-//     ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type             );
-       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                              );
-       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register );
-       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data     );
-       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                              );
-       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register );
-       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data     );
-       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception        );
-       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                              );
-       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
+       ALLOC0_VALACK_IN ( in_WRITE_QUEUE_IN_VAL,VAL);
+       ALLOC0_VALACK_OUT(out_WRITE_QUEUE_IN_ACK,ACK);
+       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
+       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
+       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id    );
+       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr          );
+//     ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation        );
+//     ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type             );
+       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                              );
+       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register );
+       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data     );
+       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                              );
+       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register );
+       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data     );
+       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception        );
+       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                              );
+       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
+
+       ALLOC0_INTERFACE_END();
      }
 
     // -----[ Interface "Write_queue_out" ]-------------------------------
      {
-       ALLOC_INTERFACE ("write_queue_out", OUT, EAST, "Output of write_queue");
+       ALLOC0_INTERFACE_BEGIN("write_queue_out", OUT, EAST, "Output of write_queue");
        
-       ALLOC_VALACK_OUT(out_WRITE_QUEUE_OUT_VAL,VAL);
-       ALLOC_VALACK_IN ( in_WRITE_QUEUE_OUT_ACK,ACK);
-       ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
-       ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
-       ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t     ,_param->_size_ooo_engine_id);
-       ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_rob_ptr      );
-//     ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_OPERATION    ,"operation"    ,Toperation_t   ,_param->_size_operation    );
-//     ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_TYPE         ,"type"         ,Ttype_t        ,_param->_size_type         );
-       ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_FLAGS        ,"flags"        ,Tspecial_data_t,_param->_size_special_data );
-       ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_EXCEPTION    ,"exception"    ,Texception_t   ,_param->_size_exception    );
-       ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
-       ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
-       ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
+       ALLOC0_VALACK_OUT(out_WRITE_QUEUE_OUT_VAL,VAL);
+       ALLOC0_VALACK_IN ( in_WRITE_QUEUE_OUT_ACK,ACK);
+       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
+       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
+       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t     ,_param->_size_ooo_engine_id);
+       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_rob_ptr      );
+//     ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_OPERATION    ,"operation"    ,Toperation_t   ,_param->_size_operation    );
+//     ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_TYPE         ,"type"         ,Ttype_t        ,_param->_size_type         );
+       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_FLAGS        ,"flags"        ,Tspecial_data_t,_param->_size_special_data );
+       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_EXCEPTION    ,"exception"    ,Texception_t   ,_param->_size_exception    );
+       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
+       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
+       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
+
+       ALLOC0_INTERFACE_END();
      }
 
     // -----[ Interface "gpr_write" ]-------------------------------------
      {
-       ALLOC1_INTERFACE("gpr_write", OUT, SOUTH ,"Output of write_queue", _param->_nb_gpr_write);
+       ALLOC1_INTERFACE_BEGIN("gpr_write", OUT, SOUTH ,"Output of write_queue", _param->_nb_gpr_write);
 
        ALLOC1_VALACK_OUT(out_GPR_WRITE_VAL,VAL);
@@ -100,9 +104,11 @@
        ALLOC1_SIGNAL_OUT(out_GPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
        ALLOC1_SIGNAL_OUT(out_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", OUT, SOUTH ,"Output of write_queue", _param->_nb_spr_write);
+       ALLOC1_INTERFACE_BEGIN("spr_write", OUT, SOUTH ,"Output of write_queue", _param->_nb_spr_write);
 
        ALLOC1_VALACK_OUT(out_SPR_WRITE_VAL,VAL);
@@ -111,9 +117,11 @@
        ALLOC1_SIGNAL_OUT(out_SPR_WRITE_NUM_REG      ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);
        ALLOC1_SIGNAL_OUT(out_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", OUT, NORTH ,"Output of internal write_queue", _param->_nb_bypass_write);
+       ALLOC1_INTERFACE_BEGIN("bypass_write", OUT, NORTH ,"Output of internal write_queue", _param->_nb_bypass_write);
        
        ALLOC1_SIGNAL_OUT(out_BYPASS_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
@@ -124,5 +132,8 @@
        ALLOC1_SIGNAL_OUT(out_BYPASS_WRITE_SPR_NUM_REG  ,"spr_num_reg"  ,Tspecial_address_t,_param->_size_special_register);
        ALLOC1_SIGNAL_OUT(out_BYPASS_WRITE_SPR_DATA     ,"spr_data"     ,Tspecial_data_t   ,_param->_size_special_data    );
+
+       ALLOC1_INTERFACE_END(_param->_nb_bypass_write);
      }
+
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_deallocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_deallocation.cpp	(revision 112)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/include/Write_queue.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -29,71 +30,55 @@
 	delete    in_NRESET;
 	
-	// -----[ Interface "Write_queue_in" ]--------------------------------    
-	delete      in_WRITE_QUEUE_IN_VAL          ;
-	delete     out_WRITE_QUEUE_IN_ACK          ;
-	if (_param->_have_port_context_id)
-	delete      in_WRITE_QUEUE_IN_CONTEXT_ID   ;
-	if (_param->_have_port_front_end_id)
-	delete      in_WRITE_QUEUE_IN_FRONT_END_ID ;
-	if (_param->_have_port_ooo_engine_id)
-	delete      in_WRITE_QUEUE_IN_OOO_ENGINE_ID;
-        if (_param->_have_port_rob_ptr  )
-	delete      in_WRITE_QUEUE_IN_PACKET_ID    ;
-//      delete      in_WRITE_QUEUE_IN_OPERATION    ;
-// 	delete      in_WRITE_QUEUE_IN_TYPE         ;
-        delete      in_WRITE_QUEUE_IN_WRITE_RD     ;
-        delete      in_WRITE_QUEUE_IN_NUM_REG_RD   ;
-        delete      in_WRITE_QUEUE_IN_DATA_RD      ;
-        delete      in_WRITE_QUEUE_IN_WRITE_RE     ;
-        delete      in_WRITE_QUEUE_IN_NUM_REG_RE   ;
-        delete      in_WRITE_QUEUE_IN_DATA_RE      ;
-        delete      in_WRITE_QUEUE_IN_EXCEPTION    ;
-        delete      in_WRITE_QUEUE_IN_NO_SEQUENCE  ;
-        delete      in_WRITE_QUEUE_IN_ADDRESS      ;
-
-	// -----[ Interface "Write_queue_out" ]-------------------------------    
-        delete     out_WRITE_QUEUE_OUT_VAL          ;
-        delete      in_WRITE_QUEUE_OUT_ACK          ;
-        if (_param->_have_port_context_id)
-	delete     out_WRITE_QUEUE_OUT_CONTEXT_ID   ;
-        if (_param->_have_port_front_end_id)
-	delete     out_WRITE_QUEUE_OUT_FRONT_END_ID ;
-        if (_param->_have_port_ooo_engine_id)
-	delete     out_WRITE_QUEUE_OUT_OOO_ENGINE_ID;
-        if (_param->_have_port_rob_ptr  )
-	delete     out_WRITE_QUEUE_OUT_PACKET_ID    ;
-//      delete     out_WRITE_QUEUE_OUT_OPERATION    ;
-//      delete     out_WRITE_QUEUE_OUT_TYPE         ;
-        delete     out_WRITE_QUEUE_OUT_FLAGS        ;
-        delete     out_WRITE_QUEUE_OUT_EXCEPTION    ;
-        delete     out_WRITE_QUEUE_OUT_NO_SEQUENCE  ;
-        delete     out_WRITE_QUEUE_OUT_ADDRESS      ;
-        delete     out_WRITE_QUEUE_OUT_DATA         ;
-
-	// -----[ Interface "gpr_write" ]-------------------------------------
-        delete []  out_GPR_WRITE_VAL               ;
-        delete []   in_GPR_WRITE_ACK               ;
-        if (_param->_have_port_ooo_engine_id)
-	delete []  out_GPR_WRITE_OOO_ENGINE_ID     ;
-        delete []  out_GPR_WRITE_NUM_REG           ;
-        delete []  out_GPR_WRITE_DATA              ;
-	
-	// -----[ Interface "spr_write" ]-------------------------------------
-        delete []  out_SPR_WRITE_VAL               ;
-        delete []   in_SPR_WRITE_ACK               ;
-        if (_param->_have_port_ooo_engine_id)
-	delete []  out_SPR_WRITE_OOO_ENGINE_ID     ;
-        delete []  out_SPR_WRITE_NUM_REG           ;
-        delete []  out_SPR_WRITE_DATA              ;
-
-	// -----[ Interface "bypass_write" ]----------------------------------
-        if (_param->_have_port_ooo_engine_id)
-	delete []  out_BYPASS_WRITE_OOO_ENGINE_ID ;
-        delete []  out_BYPASS_WRITE_GPR_VAL       ;
-        delete []  out_BYPASS_WRITE_GPR_NUM_REG   ;
-        delete []  out_BYPASS_WRITE_GPR_DATA      ;
-        delete []  out_BYPASS_WRITE_SPR_VAL       ;
-        delete []  out_BYPASS_WRITE_SPR_NUM_REG   ;
-        delete []  out_BYPASS_WRITE_SPR_DATA      ;
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_VAL           ,1);
+        DELETE0_SIGNAL(out_WRITE_QUEUE_IN_ACK           ,1);
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_CONTEXT_ID    ,_param->_size_context_id       );
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_FRONT_END_ID  ,_param->_size_front_end_id     );
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_OOO_ENGINE_ID ,_param->_size_ooo_engine_id    );
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_PACKET_ID     ,_param->_size_rob_ptr          );
+//      DELETE0_SIGNAL( in_WRITE_QUEUE_IN_OPERATION     ,_param->_size_operation        );
+//      DELETE0_SIGNAL( in_WRITE_QUEUE_IN_TYPE          ,_param->_size_type             );
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_WRITE_RD      ,1                              );
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_NUM_REG_RD    ,_param->_size_general_register );
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_DATA_RD       ,_param->_size_general_data     );
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_WRITE_RE      ,1                              );
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_NUM_REG_RE    ,_param->_size_special_register );
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_DATA_RE       ,_param->_size_special_data     );
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_EXCEPTION     ,_param->_size_exception        );
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_NO_SEQUENCE   ,1                              );
+        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_ADDRESS       ,_param->_size_instruction_address);
+        
+        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_VAL          ,1);
+        DELETE0_SIGNAL( in_WRITE_QUEUE_OUT_ACK          ,1);
+        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_CONTEXT_ID   ,_param->_size_context_id   );
+        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_FRONT_END_ID ,_param->_size_front_end_id );
+        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_OOO_ENGINE_ID,_param->_size_ooo_engine_id);
+        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_PACKET_ID    ,_param->_size_rob_ptr      );
+//      DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_OPERATION    ,_param->_size_operation    );
+//      DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_TYPE         ,_param->_size_type         );
+        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_FLAGS        ,_param->_size_special_data );
+        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_EXCEPTION    ,_param->_size_exception    );
+        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_NO_SEQUENCE  ,1                          );
+        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_ADDRESS      ,_param->_size_instruction_address);
+        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_DATA         ,_param->_size_general_data );
+        
+        DELETE1_SIGNAL(out_GPR_WRITE_VAL          , _param->_nb_gpr_write,1);
+        DELETE1_SIGNAL( in_GPR_WRITE_ACK          , _param->_nb_gpr_write,1);
+        DELETE1_SIGNAL(out_GPR_WRITE_OOO_ENGINE_ID, _param->_nb_gpr_write,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL(out_GPR_WRITE_NUM_REG      , _param->_nb_gpr_write,_param->_size_general_register);
+        DELETE1_SIGNAL(out_GPR_WRITE_DATA         , _param->_nb_gpr_write,_param->_size_general_data    );
+        
+        DELETE1_SIGNAL(out_SPR_WRITE_VAL          , _param->_nb_spr_write,1);
+        DELETE1_SIGNAL( in_SPR_WRITE_ACK          , _param->_nb_spr_write,1);
+        DELETE1_SIGNAL(out_SPR_WRITE_OOO_ENGINE_ID, _param->_nb_spr_write,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL(out_SPR_WRITE_NUM_REG      , _param->_nb_spr_write,_param->_size_special_register);
+        DELETE1_SIGNAL(out_SPR_WRITE_DATA         , _param->_nb_spr_write,_param->_size_special_data    );
+        
+        DELETE1_SIGNAL(out_BYPASS_WRITE_OOO_ENGINE_ID,_param->_nb_bypass_write,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL(out_BYPASS_WRITE_GPR_VAL      ,_param->_nb_bypass_write,1                             );
+        DELETE1_SIGNAL(out_BYPASS_WRITE_GPR_NUM_REG  ,_param->_nb_bypass_write,_param->_size_general_register);
+        DELETE1_SIGNAL(out_BYPASS_WRITE_GPR_DATA     ,_param->_nb_bypass_write,_param->_size_general_data    );
+        DELETE1_SIGNAL(out_BYPASS_WRITE_SPR_VAL      ,_param->_nb_bypass_write,1                             );
+        DELETE1_SIGNAL(out_BYPASS_WRITE_SPR_NUM_REG  ,_param->_nb_bypass_write,_param->_size_special_register);
+        DELETE1_SIGNAL(out_BYPASS_WRITE_SPR_DATA     ,_param->_nb_bypass_write,_param->_size_special_data    );
       }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Write_unit_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Write_unit_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Write_unit_allocation.cpp	(revision 112)
@@ -57,47 +57,51 @@
     // -----[ Interface "write_unit_in" ]--------------------------------    
      {
-       ALLOC_INTERFACE ("write_unit_in", IN, WEST, "Input of write_unit");
-       
-       ALLOC_VALACK_IN ( in_WRITE_UNIT_IN_VAL,VAL);
-       ALLOC_VALACK_OUT(out_WRITE_UNIT_IN_ACK,ACK);
-       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
-       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
-       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id    );
-       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr          );
-//     ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation        );
-//     ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type             );
-       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                              );
-       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register );
-       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data     );
-       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                              );
-       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register );
-       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data     );
-       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception        );
-       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                              );
-       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
+       ALLOC0_INTERFACE_BEGIN("write_unit_in", IN, WEST, "Input of write_unit");
+       
+       ALLOC0_VALACK_IN ( in_WRITE_UNIT_IN_VAL,VAL);
+       ALLOC0_VALACK_OUT(out_WRITE_UNIT_IN_ACK,ACK);
+       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
+       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
+       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id    );
+       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr          );
+//     ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation        );
+//     ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type             );
+       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                              );
+       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register );
+       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data     );
+       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                              );
+       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register );
+       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data     );
+       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception        );
+       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                              );
+       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
+
+       ALLOC0_INTERFACE_END();
      }
 
     // -----[ Interface "write_unit_out" ]-------------------------------
      {
-       ALLOC_INTERFACE ("write_unit_out", OUT, EAST, "Output of write_unit");
-       
-       ALLOC_VALACK_OUT(out_WRITE_UNIT_OUT_VAL,VAL);
-       ALLOC_VALACK_IN ( in_WRITE_UNIT_OUT_ACK,ACK);
-       ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
-       ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
-       ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t     ,_param->_size_ooo_engine_id);
-       ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_rob_ptr      );
-//     ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_OPERATION    ,"operation"    ,Toperation_t   ,_param->_size_operation    );
-//     ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_TYPE         ,"type"         ,Ttype_t        ,_param->_size_type         );
-       ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_FLAGS        ,"flags"        ,Tspecial_data_t,_param->_size_special_data );
-       ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_EXCEPTION    ,"exception"    ,Texception_t   ,_param->_size_exception    );
-       ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
-       ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
-       ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
+       ALLOC0_INTERFACE_BEGIN("write_unit_out", OUT, EAST, "Output of write_unit");
+       
+       ALLOC0_VALACK_OUT(out_WRITE_UNIT_OUT_VAL,VAL);
+       ALLOC0_VALACK_IN ( in_WRITE_UNIT_OUT_ACK,ACK);
+       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
+       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
+       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t     ,_param->_size_ooo_engine_id);
+       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_rob_ptr      );
+//     ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_OPERATION    ,"operation"    ,Toperation_t   ,_param->_size_operation    );
+//     ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_TYPE         ,"type"         ,Ttype_t        ,_param->_size_type         );
+       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_FLAGS        ,"flags"        ,Tspecial_data_t,_param->_size_special_data );
+       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_EXCEPTION    ,"exception"    ,Texception_t   ,_param->_size_exception    );
+       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
+       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
+       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
+
+       ALLOC0_INTERFACE_END();
      }
 
     // -----[ Interface "gpr_write" ]-------------------------------------
      {
-       ALLOC1_INTERFACE("gpr_write", OUT, SOUTH ,"Output of write_unit", _param->_nb_gpr_write);
+       ALLOC1_INTERFACE_BEGIN("gpr_write", OUT, SOUTH ,"Output of write_unit", _param->_nb_gpr_write);
 
        ALLOC1_VALACK_OUT(out_GPR_WRITE_VAL,VAL);
@@ -106,9 +110,11 @@
        ALLOC1_SIGNAL_OUT(out_GPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
        ALLOC1_SIGNAL_OUT(out_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", OUT, SOUTH ,"Output of write_unit", _param->_nb_spr_write);
+       ALLOC1_INTERFACE_BEGIN("spr_write", OUT, SOUTH ,"Output of write_unit", _param->_nb_spr_write);
 
        ALLOC1_VALACK_OUT(out_SPR_WRITE_VAL,VAL);
@@ -117,9 +123,11 @@
        ALLOC1_SIGNAL_OUT(out_SPR_WRITE_NUM_REG      ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);
        ALLOC1_SIGNAL_OUT(out_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", OUT, NORTH ,"Output of internal write_unit", _param->_nb_bypass_write);
+       ALLOC1_INTERFACE_BEGIN("bypass_write", OUT, NORTH ,"Output of internal write_unit", _param->_nb_bypass_write);
        
        ALLOC1_SIGNAL_OUT(out_BYPASS_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
@@ -130,6 +138,7 @@
        ALLOC1_SIGNAL_OUT(out_BYPASS_WRITE_SPR_NUM_REG  ,"spr_num_reg"  ,Tspecial_address_t,_param->_size_special_register);
        ALLOC1_SIGNAL_OUT(out_BYPASS_WRITE_SPR_DATA     ,"spr_data"     ,Tspecial_data_t   ,_param->_size_special_data    );
-     }
-
+
+       ALLOC1_INTERFACE_END(_param->_nb_bypass_write);
+     }
 
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Write_unit_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Write_unit_deallocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Write_unit_deallocation.cpp	(revision 112)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/include/Write_unit.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -28,73 +29,57 @@
 	delete    in_NRESET;
 
-	// -----[ Interface "write_unit_in" ]--------------------------------    
-	delete      in_WRITE_UNIT_IN_VAL          ;
-	delete     out_WRITE_UNIT_IN_ACK          ;
-	if (_param->_have_port_context_id)
-	delete      in_WRITE_UNIT_IN_CONTEXT_ID   ;
-	if (_param->_have_port_front_end_id)
-	delete      in_WRITE_UNIT_IN_FRONT_END_ID ;
-	if (_param->_have_port_ooo_engine_id)
-	delete      in_WRITE_UNIT_IN_OOO_ENGINE_ID;
-        if (_param->_have_port_rob_ptr)
-	delete      in_WRITE_UNIT_IN_PACKET_ID    ;
-//      delete      in_WRITE_UNIT_IN_OPERATION    ;
-//	delete      in_WRITE_UNIT_IN_TYPE         ;
-        delete      in_WRITE_UNIT_IN_WRITE_RD     ;
-        delete      in_WRITE_UNIT_IN_NUM_REG_RD   ;
-        delete      in_WRITE_UNIT_IN_DATA_RD      ;
-        delete      in_WRITE_UNIT_IN_WRITE_RE     ;
-        delete      in_WRITE_UNIT_IN_NUM_REG_RE   ;
-        delete      in_WRITE_UNIT_IN_DATA_RE      ;
-        delete      in_WRITE_UNIT_IN_EXCEPTION    ;
-        delete      in_WRITE_UNIT_IN_NO_SEQUENCE  ;
-        delete      in_WRITE_UNIT_IN_ADDRESS      ;
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_VAL          ,1);
+        DELETE0_SIGNAL(out_WRITE_UNIT_IN_ACK          ,1);
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_CONTEXT_ID   ,_param->_size_context_id       );
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_FRONT_END_ID ,_param->_size_front_end_id     );
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_OOO_ENGINE_ID,_param->_size_ooo_engine_id    );
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_PACKET_ID    ,_param->_size_rob_ptr          );
+//      DELETE0_SIGNAL( in_WRITE_UNIT_IN_OPERATION    ,_param->_size_operation        );
+//      DELETE0_SIGNAL( in_WRITE_UNIT_IN_TYPE         ,_param->_size_type             );
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_WRITE_RD     ,1                              );
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_NUM_REG_RD   ,_param->_size_general_register );
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_DATA_RD      ,_param->_size_general_data     );
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_WRITE_RE     ,1                              );
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_NUM_REG_RE   ,_param->_size_special_register );
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_DATA_RE      ,_param->_size_special_data     );
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_EXCEPTION    ,_param->_size_exception        );
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_NO_SEQUENCE  ,1                              );
+        DELETE0_SIGNAL( in_WRITE_UNIT_IN_ADDRESS      ,_param->_size_instruction_address);
+        
+        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_VAL          ,1);
+        DELETE0_SIGNAL( in_WRITE_UNIT_OUT_ACK          ,1);
+        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_CONTEXT_ID   ,_param->_size_context_id   );
+        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_FRONT_END_ID ,_param->_size_front_end_id );
+        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_OOO_ENGINE_ID,_param->_size_ooo_engine_id);
+        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_PACKET_ID    ,_param->_size_rob_ptr      );
+//      DELETE0_SIGNAL(out_WRITE_UNIT_OUT_OPERATION    ,_param->_size_operation    );
+//      DELETE0_SIGNAL(out_WRITE_UNIT_OUT_TYPE         ,_param->_size_type         );
+        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_FLAGS        ,_param->_size_special_data );
+        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_EXCEPTION    ,_param->_size_exception    );
+        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_NO_SEQUENCE  ,1                          );
+        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_ADDRESS      ,_param->_size_instruction_address);
+        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_DATA         ,_param->_size_general_data );
+        
+        DELETE1_SIGNAL(out_GPR_WRITE_VAL          , _param->_nb_gpr_write,1);
+        DELETE1_SIGNAL( in_GPR_WRITE_ACK          , _param->_nb_gpr_write,1);
+        DELETE1_SIGNAL(out_GPR_WRITE_OOO_ENGINE_ID, _param->_nb_gpr_write,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL(out_GPR_WRITE_NUM_REG      , _param->_nb_gpr_write,_param->_size_general_register);
+        DELETE1_SIGNAL(out_GPR_WRITE_DATA         , _param->_nb_gpr_write,_param->_size_general_data    );
+        
+        DELETE1_SIGNAL(out_SPR_WRITE_VAL          , _param->_nb_spr_write,1);
+        DELETE1_SIGNAL( in_SPR_WRITE_ACK          , _param->_nb_spr_write,1);
+        DELETE1_SIGNAL(out_SPR_WRITE_OOO_ENGINE_ID, _param->_nb_spr_write,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL(out_SPR_WRITE_NUM_REG      , _param->_nb_spr_write,_param->_size_special_register);
+        DELETE1_SIGNAL(out_SPR_WRITE_DATA         , _param->_nb_spr_write,_param->_size_special_data    );
+        
+        DELETE1_SIGNAL(out_BYPASS_WRITE_OOO_ENGINE_ID, _param->_nb_bypass_write,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL(out_BYPASS_WRITE_GPR_VAL      , _param->_nb_bypass_write,1                             );
+        DELETE1_SIGNAL(out_BYPASS_WRITE_GPR_NUM_REG  , _param->_nb_bypass_write,_param->_size_general_register);
+        DELETE1_SIGNAL(out_BYPASS_WRITE_GPR_DATA     , _param->_nb_bypass_write,_param->_size_general_data    );
+        DELETE1_SIGNAL(out_BYPASS_WRITE_SPR_VAL      , _param->_nb_bypass_write,1                             );
+        DELETE1_SIGNAL(out_BYPASS_WRITE_SPR_NUM_REG  , _param->_nb_bypass_write,_param->_size_special_register);
+        DELETE1_SIGNAL(out_BYPASS_WRITE_SPR_DATA     , _param->_nb_bypass_write,_param->_size_special_data    );
+      }
 
-	// -----[ Interface "write_unit_out" ]-------------------------------    
-        delete     out_WRITE_UNIT_OUT_VAL          ;
-        delete      in_WRITE_UNIT_OUT_ACK          ;
-        if (_param->_have_port_context_id)
-	delete     out_WRITE_UNIT_OUT_CONTEXT_ID   ;
-        if (_param->_have_port_front_end_id)
-	delete     out_WRITE_UNIT_OUT_FRONT_END_ID ;
-        if (_param->_have_port_ooo_engine_id)
-	delete     out_WRITE_UNIT_OUT_OOO_ENGINE_ID;
-        if (_param->_have_port_rob_ptr)
-	delete     out_WRITE_UNIT_OUT_PACKET_ID    ;
-//      delete     out_WRITE_UNIT_OUT_OPERATION    ;
-//      delete     out_WRITE_UNIT_OUT_TYPE         ;
-        delete     out_WRITE_UNIT_OUT_FLAGS        ;
-        delete     out_WRITE_UNIT_OUT_EXCEPTION    ;
-        delete     out_WRITE_UNIT_OUT_NO_SEQUENCE  ;
-        delete     out_WRITE_UNIT_OUT_ADDRESS      ;
-        delete     out_WRITE_UNIT_OUT_DATA         ;
-
-	// -----[ Interface "gpr_write" ]-------------------------------------
-        delete []  out_GPR_WRITE_VAL               ;
-        delete []   in_GPR_WRITE_ACK               ;
-        if (_param->_have_port_ooo_engine_id)
-	delete []  out_GPR_WRITE_OOO_ENGINE_ID     ;
-        delete []  out_GPR_WRITE_NUM_REG           ;
-        delete []  out_GPR_WRITE_DATA              ;
-	
-	// -----[ Interface "spr_write" ]-------------------------------------
-        delete []  out_SPR_WRITE_VAL               ;
-        delete []   in_SPR_WRITE_ACK               ;
-        if (_param->_have_port_ooo_engine_id)
-	delete []  out_SPR_WRITE_OOO_ENGINE_ID     ;
-        delete []  out_SPR_WRITE_NUM_REG           ;
-        delete []  out_SPR_WRITE_DATA              ;
-
-	// -----[ Interface "bypass_write" ]----------------------------------
-        if (_param->_have_port_ooo_engine_id)
-	delete []  out_BYPASS_WRITE_OOO_ENGINE_ID ;
-        delete []  out_BYPASS_WRITE_GPR_VAL       ;
-        delete []  out_BYPASS_WRITE_GPR_NUM_REG   ;
-        delete []  out_BYPASS_WRITE_GPR_DATA      ;
-        delete []  out_BYPASS_WRITE_SPR_VAL       ;
-        delete []  out_BYPASS_WRITE_SPR_NUM_REG   ;
-        delete []  out_BYPASS_WRITE_SPR_DATA      ;
-
-      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_allocation.cpp	(revision 112)
@@ -58,5 +58,5 @@
     // ~~~~~[ Interface "execute_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC2_INTERFACE("execute_unit_out", IN, EAST, "Output of execution_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       ALLOC2_INTERFACE_BEGIN("execute_unit_out", IN, EAST, "Output of execution_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
 
        _ALLOC2_VALACK_IN ( in_EXECUTE_UNIT_OUT_VAL,VAL, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
@@ -77,9 +77,11 @@
        _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                             , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
        _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+
+       ALLOC2_INTERFACE_END(_param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
      }
 
     // ~~~~~[ Interface "write_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC1_INTERFACE("write_unit_in", OUT, WEST, "Input of write_unit", _param->_nb_write_unit);
+       ALLOC1_INTERFACE_BEGIN("write_unit_in", OUT, WEST, "Input of write_unit", _param->_nb_write_unit);
 
        ALLOC1_VALACK_OUT(out_WRITE_UNIT_IN_VAL,VAL);
@@ -100,4 +102,6 @@
        ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                             );
        ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
+
+       ALLOC1_INTERFACE_END(_param->_nb_write_unit);
      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
@@ -105,13 +109,5 @@
     if (usage_is_set(_usage,USE_SYSTEMC))
       {
-     _destination = new std::list<uint32_t> ** [_param->_nb_execute_unit];
-     for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
-       {
-	 _destination [i] = new std::list<uint32_t> * [_param->_nb_execute_unit_port[i]];
-	 for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
-	   {
-	     _destination [i][j] = new std::list<uint32_t> [_param->_nb_thread];
-	   }
-       }
+        ALLOC3(_destination,std::list<uint32_t>,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1],_param->_nb_thread);
       }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_deallocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_deallocation.cpp	(revision 112)
@@ -65,6 +65,7 @@
         DELETE1_SIGNAL(out_WRITE_UNIT_IN_ADDRESS      , _param->_nb_write_unit,_param->_size_general_data    );
       
-        delete [] _destination;
+        DELETE3(_destination,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1],_param->_nb_thread);
       }
+
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_allocation.cpp	(revision 112)
@@ -57,5 +57,5 @@
     // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC2_INTERFACE("read_unit_out", IN, EAST, "Output of read_unit",_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       ALLOC2_INTERFACE_BEGIN("read_unit_out", IN, EAST, "Output of read_unit",_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
 
        _ALLOC2_VALACK_IN ( in_READ_UNIT_OUT_VAL,VAL,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
@@ -78,8 +78,10 @@
        _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1                              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
        _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+
+       ALLOC2_INTERFACE_END(_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
      }
     // ~~~~~[ Interface "execute_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC2_INTERFACE("execute_unit_in", OUT, WEST, "Input of execute_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       ALLOC2_INTERFACE_BEGIN("execute_unit_in", OUT, WEST, "Input of execute_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
        
        _ALLOC2_VALACK_OUT(out_EXECUTE_UNIT_IN_VAL,VAL, _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
@@ -102,4 +104,6 @@
        _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
        _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+
+       ALLOC2_INTERFACE_END(_param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
      }
 
@@ -107,13 +111,5 @@
      if (usage_is_set(_usage,USE_SYSTEMC))
        {
-     _destination = new std::list<destination_t> ** [_param->_nb_read_unit];
-     for (uint32_t i=0; i<_param->_nb_read_unit; i++)
-       {
-	 _destination [i] = new std::list<destination_t> * [_param->_nb_thread];
-	 for (uint32_t j=0; j<_param->_nb_thread; j++)
-	   {
-	     _destination [i][j] = new std::list<destination_t> [_param->_nb_type];
-	   }
-       }
+         ALLOC3(_destination,std::list<destination_t>,_param->_nb_read_unit,_param->_nb_thread,_param->_nb_type);;
        }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_deallocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_deallocation.cpp	(revision 112)
@@ -69,5 +69,5 @@
          DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_register );
 
-         delete [] _destination;
+         DELETE3(_destination,_param->_nb_read_unit,_param->_nb_thread,_param->_nb_type);;
       }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_allocation.cpp	(revision 112)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Register_unit_Glue.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -50,353 +51,157 @@
     out_CONST_1      = interface->set_signal_out <Tcontrol_t> ("const_1",1);
 
-    // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-   in_GPR_READ_VAL               = new SC_IN (Tcontrol_t        )   * [_param->_nb_gpr_read];
-  out_GPR_READ_ACK               = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_read];
-  if (_param->_have_port_ooo_engine_id == true)
-   in_GPR_READ_OOO_ENGINE_ID     = new SC_IN (Tcontext_t        )   * [_param->_nb_gpr_read];
-  out_GPR_READ_DATA              = new SC_OUT(Tgeneral_data_t   )   * [_param->_nb_gpr_read];
-  out_GPR_READ_DATA_VAL          = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_read];
-
-  out_GPR_READ_REGISTERFILE_VAL  = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-   in_GPR_READ_REGISTERFILE_ACK  = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-   in_GPR_READ_REGISTERFILE_DATA = new SC_IN (Tgeneral_data_t   )  ** [_param->_nb_ooo_engine];
-
-  out_GPR_READ_STATUS_VAL        = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-   in_GPR_READ_STATUS_ACK        = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-   in_GPR_READ_STATUS_DATA_VAL   = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-
-   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
-     {
-       out_GPR_READ_REGISTERFILE_VAL  [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_gpr_read];
-        in_GPR_READ_REGISTERFILE_ACK  [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_gpr_read];
-        in_GPR_READ_REGISTERFILE_DATA [i] = new SC_IN (Tgeneral_data_t   )  * [_param->_nb_gpr_read];
-
-       out_GPR_READ_STATUS_VAL        [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_gpr_read];
-        in_GPR_READ_STATUS_ACK        [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_gpr_read];
-        in_GPR_READ_STATUS_DATA_VAL   [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_gpr_read];
-     }
-
-   for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
-     {
-       Interface_fifo * interface = _interfaces->set_interface("gpr_read_"+toString(j)
-#ifdef POSITION
-							  ,IN
-							  ,NORTH,
-							  "Interface to read generalist register"
-#endif
-							  );
-      
-        in_GPR_READ_VAL           [j] = interface->set_signal_valack_in  (VAL);
-       out_GPR_READ_ACK           [j] = interface->set_signal_valack_out (ACK);
-       if (_param->_have_port_ooo_engine_id == true)
-        in_GPR_READ_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", _param->_size_ooo_engine_id);
-       out_GPR_READ_DATA          [j] = interface->set_signal_out<Tgeneral_data_t> ("data"         , _param->_size_general_data);
-       out_GPR_READ_DATA_VAL      [j] = interface->set_signal_out<Tcontrol_t     > ("data_val"     , 1);
-
-       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
-	 {
-	   {
-	     Interface_fifo * interface = _interfaces->set_interface("gpr_read_registerfile_"+toString(i)+"_"+toString(j)
-#ifdef POSITION
-								,IN
-								,NORTH,
-								"Interface to read generalist register - from/to register file"
-#endif
-								);
-	     
-	     out_GPR_READ_REGISTERFILE_VAL  [i][j] = interface->set_signal_valack_out (VAL);
-	      in_GPR_READ_REGISTERFILE_ACK  [i][j] = interface->set_signal_valack_in  (ACK);
-	      in_GPR_READ_REGISTERFILE_DATA [i][j] = interface->set_signal_in <Tgeneral_data_t> ("data"         , _param->_size_general_data);
-	   }
-	   {
-	     Interface_fifo * interface = _interfaces->set_interface("gpr_read_status_"+toString(i)+"_"+toString(j)
-#ifdef POSITION
-								,IN
-								,NORTH,
-								"Interface to read generalist register - from/to status"
-#endif
-								);
-
-
-	     out_GPR_READ_STATUS_VAL        [i][j] = interface->set_signal_valack_out (VAL);
-	      in_GPR_READ_STATUS_ACK        [i][j] = interface->set_signal_valack_in  (ACK);
-	      in_GPR_READ_STATUS_DATA_VAL   [i][j] = interface->set_signal_in <Tcontrol_t     > ("data_val"     , 1);
-	   }
-	 }
-     }
-
-    // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-   in_SPR_READ_VAL               = new SC_IN (Tcontrol_t        )   * [_param->_nb_spr_read];
-  out_SPR_READ_ACK               = new SC_OUT(Tcontrol_t        )   * [_param->_nb_spr_read];
-  if (_param->_have_port_ooo_engine_id == true)
-   in_SPR_READ_OOO_ENGINE_ID     = new SC_IN (Tcontext_t        )   * [_param->_nb_spr_read];
-  out_SPR_READ_DATA              = new SC_OUT(Tspecial_data_t   )   * [_param->_nb_spr_read];
-  out_SPR_READ_DATA_VAL          = new SC_OUT(Tcontrol_t        )   * [_param->_nb_spr_read];
-
-  out_SPR_READ_REGISTERFILE_VAL  = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-   in_SPR_READ_REGISTERFILE_ACK  = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-   in_SPR_READ_REGISTERFILE_DATA = new SC_IN (Tspecial_data_t   )  ** [_param->_nb_ooo_engine];
-
-  out_SPR_READ_STATUS_VAL        = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-   in_SPR_READ_STATUS_ACK        = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-   in_SPR_READ_STATUS_DATA_VAL   = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-
-   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
-     {
-       out_SPR_READ_REGISTERFILE_VAL  [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_spr_read];
-        in_SPR_READ_REGISTERFILE_ACK  [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_spr_read];
-        in_SPR_READ_REGISTERFILE_DATA [i] = new SC_IN (Tspecial_data_t   )  * [_param->_nb_spr_read];
-
-       out_SPR_READ_STATUS_VAL        [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_spr_read];
-        in_SPR_READ_STATUS_ACK        [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_spr_read];
-        in_SPR_READ_STATUS_DATA_VAL   [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_spr_read];
-     }
-
-   for (uint32_t j=0; j<_param->_nb_spr_read; j++)
-     {
-       Interface_fifo * interface = _interfaces->set_interface("spr_read_"+toString(j)
-#ifdef POSITION
-							  ,IN
-							  ,NORTH,
-							  "Interface to read special register"
-#endif
-							  );
-      
-        in_SPR_READ_VAL           [j] = interface->set_signal_valack_in  (VAL);
-       out_SPR_READ_ACK           [j] = interface->set_signal_valack_out (ACK);
-       if (_param->_have_port_ooo_engine_id == true)
-        in_SPR_READ_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", _param->_size_ooo_engine_id);
-       out_SPR_READ_DATA          [j] = interface->set_signal_out<Tspecial_data_t> ("data"         , _param->_size_special_data);
-       out_SPR_READ_DATA_VAL      [j] = interface->set_signal_out<Tcontrol_t     > ("data_val"     , 1);
-
-       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
-	 {
-	   {
-	     Interface_fifo * interface = _interfaces->set_interface("spr_read_registerfile_"+toString(i)+"_"+toString(j)
-#ifdef POSITION
-								,IN
-								,NORTH,
-								"Interface to read special register - from/to register file"
-#endif
-								);
-	     
-	     out_SPR_READ_REGISTERFILE_VAL  [i][j] = interface->set_signal_valack_out (VAL);
-	      in_SPR_READ_REGISTERFILE_ACK  [i][j] = interface->set_signal_valack_in  (ACK);
-	      in_SPR_READ_REGISTERFILE_DATA [i][j] = interface->set_signal_in <Tspecial_data_t> ("data"         , _param->_size_special_data);
-	   }
-	   {
-	     Interface_fifo * interface = _interfaces->set_interface("spr_read_status_"+toString(i)+"_"+toString(j)
-#ifdef POSITION
-								,IN
-								,NORTH,
-								"Interface to read special register - from/to status"
-#endif
-								);
-
-
-	     out_SPR_READ_STATUS_VAL        [i][j] = interface->set_signal_valack_out (VAL);
-	      in_SPR_READ_STATUS_ACK        [i][j] = interface->set_signal_valack_in  (ACK);
-	      in_SPR_READ_STATUS_DATA_VAL   [i][j] = interface->set_signal_in <Tcontrol_t     > ("data_val"     , 1);
-	   }
-	 }
-     }
-
-    // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-   in_GPR_WRITE_VAL               = new SC_IN (Tcontrol_t        )   * [_param->_nb_gpr_write];
-  out_GPR_WRITE_ACK               = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_write];
-  if (_param->_have_port_ooo_engine_id == true) 
-  in_GPR_WRITE_OOO_ENGINE_ID     = new SC_IN (Tcontext_t        )   * [_param->_nb_gpr_write];
-
-  out_GPR_WRITE_REGISTERFILE_VAL  = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-   in_GPR_WRITE_REGISTERFILE_ACK  = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-
-  out_GPR_WRITE_STATUS_VAL        = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-   in_GPR_WRITE_STATUS_ACK        = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-
-   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
-     {
-       out_GPR_WRITE_REGISTERFILE_VAL  [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_gpr_write];
-        in_GPR_WRITE_REGISTERFILE_ACK  [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_gpr_write];
-
-       out_GPR_WRITE_STATUS_VAL        [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_gpr_write];
-        in_GPR_WRITE_STATUS_ACK        [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_gpr_write];
-     }
-
-   for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
-     {
-       Interface_fifo * interface = _interfaces->set_interface("gpr_write_"+toString(j)
-#ifdef POSITION
-							  ,IN
-							  ,NORTH,
-							  "Interface to write generalist register"
-#endif
-							  );
-      
-        in_GPR_WRITE_VAL           [j] = interface->set_signal_valack_in  (VAL);
-       out_GPR_WRITE_ACK           [j] = interface->set_signal_valack_out (ACK);
-       if (_param->_have_port_ooo_engine_id == true)
-        in_GPR_WRITE_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", _param->_size_ooo_engine_id);
-
-       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
-	 {
-	   {
-	     Interface_fifo * interface = _interfaces->set_interface("gpr_write_registerfile_"+toString(i)+"_"+toString(j)
-#ifdef POSITION
-								,IN
-								,NORTH,
-								"Interface to write generalist register - from/to register file"
-#endif
-								);
-	     
-	     out_GPR_WRITE_REGISTERFILE_VAL  [i][j] = interface->set_signal_valack_out (VAL);
-	      in_GPR_WRITE_REGISTERFILE_ACK  [i][j] = interface->set_signal_valack_in  (ACK);
-	   }
-	   {
-	     Interface_fifo * interface = _interfaces->set_interface("gpr_write_status_"+toString(i)+"_"+toString(j)
-#ifdef POSITION
-								,IN
-								,NORTH,
-								"Interface to write generalist register - from/to status"
-#endif
-								);
-
-
-	     out_GPR_WRITE_STATUS_VAL        [i][j] = interface->set_signal_valack_out (VAL);
-	      in_GPR_WRITE_STATUS_ACK        [i][j] = interface->set_signal_valack_in  (ACK);
-	   }
-	 }
-     }
-
-    // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-   in_SPR_WRITE_VAL               = new SC_IN (Tcontrol_t        )   * [_param->_nb_spr_write];
-  out_SPR_WRITE_ACK               = new SC_OUT(Tcontrol_t        )   * [_param->_nb_spr_write];
-  if (_param->_have_port_ooo_engine_id == true) 
-   in_SPR_WRITE_OOO_ENGINE_ID     = new SC_IN (Tcontext_t        )   * [_param->_nb_spr_write];
-
-  out_SPR_WRITE_REGISTERFILE_VAL  = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-   in_SPR_WRITE_REGISTERFILE_ACK  = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-
-  out_SPR_WRITE_STATUS_VAL        = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-   in_SPR_WRITE_STATUS_ACK        = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-
-   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
-     {
-       out_SPR_WRITE_REGISTERFILE_VAL  [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_spr_write];
-        in_SPR_WRITE_REGISTERFILE_ACK  [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_spr_write];
-
-       out_SPR_WRITE_STATUS_VAL        [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_spr_write];
-        in_SPR_WRITE_STATUS_ACK        [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_spr_write];
-     }
-
-   for (uint32_t j=0; j<_param->_nb_spr_write; j++)
-     {
-       Interface_fifo * interface = _interfaces->set_interface("spr_write_"+toString(j)
-#ifdef POSITION
-							  ,IN
-							  ,NORTH,
-							  "Interface to write special register"
-#endif
-							  );
-      
-        in_SPR_WRITE_VAL           [j] = interface->set_signal_valack_in  (VAL);
-       out_SPR_WRITE_ACK           [j] = interface->set_signal_valack_out (ACK);
-       if (_param->_have_port_ooo_engine_id == true)
-        in_SPR_WRITE_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", _param->_size_ooo_engine_id);
-
-       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
-	 {
-	   {
-	     Interface_fifo * interface = _interfaces->set_interface("spr_write_registerfile_"+toString(i)+"_"+toString(j)
-#ifdef POSITION
-								,IN
-								,NORTH,
-								"Interface to write special register - from/to register file"
-#endif
-								);
-	     
-	     out_SPR_WRITE_REGISTERFILE_VAL  [i][j] = interface->set_signal_valack_out (VAL);
-	      in_SPR_WRITE_REGISTERFILE_ACK  [i][j] = interface->set_signal_valack_in  (ACK);
-	   }
-	   {
-	     Interface_fifo * interface = _interfaces->set_interface("spr_write_status_"+toString(i)+"_"+toString(j)
-#ifdef POSITION
-								,IN
-								,NORTH,
-								"Interface to write special register - from/to status"
-#endif
-								);
-
-
-	     out_SPR_WRITE_STATUS_VAL        [i][j] = interface->set_signal_valack_out (VAL);
-	      in_SPR_WRITE_STATUS_ACK        [i][j] = interface->set_signal_valack_in  (ACK);
-	   }
-	 }
-     }
-
-   // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    in_INSERT_ROB_VAL                  = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
-   out_INSERT_ROB_ACK                  = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
-    in_INSERT_ROB_RD_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
-    in_INSERT_ROB_RE_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
-   out_INSERT_ROB_GPR_STATUS_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
-    in_INSERT_ROB_GPR_STATUS_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
-   out_INSERT_ROB_SPR_STATUS_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
-    in_INSERT_ROB_SPR_STATUS_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
-
-    for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
-      {
-	uint32_t x=_param->_nb_inst_insert_rob [i];
-
-	in_INSERT_ROB_VAL                  [i] = new SC_IN (Tcontrol_t) * [x];
-       out_INSERT_ROB_ACK                  [i] = new SC_OUT(Tcontrol_t) * [x];
-	in_INSERT_ROB_RD_USE               [i] = new SC_IN (Tcontrol_t) * [x];
-	in_INSERT_ROB_RE_USE               [i] = new SC_IN (Tcontrol_t) * [x];
-       out_INSERT_ROB_GPR_STATUS_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
-	in_INSERT_ROB_GPR_STATUS_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
-       out_INSERT_ROB_SPR_STATUS_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
-	in_INSERT_ROB_SPR_STATUS_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
-
-	for (uint32_t j=0; j<x; j++)
-	  {
-	    {
-	      Interface_fifo * interface = _interfaces->set_interface("insert_rob_"+toString(i)+"_"+toString(j)
-#ifdef POSITION
-								      ,IN
-								      ,WEST
-								      ,"Interface to update status (insert)"
-#endif
-								      );
-
-	       in_INSERT_ROB_VAL                  [i][j] = interface->set_signal_valack_in (VAL);
-	      out_INSERT_ROB_ACK                  [i][j] = interface->set_signal_valack_out(ACK);
-	       in_INSERT_ROB_RD_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("rd_use", 1);
-	       in_INSERT_ROB_RE_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("re_use", 1);
-	    }
-	    {
-	      Interface_fifo * interface = _interfaces->set_interface("insert_rob_gpr_status_"+toString(i)+"_"+toString(j)
-#ifdef POSITION
-								      ,IN
-								      ,EAST
-								      ,"Interface to update status (insert)"
-#endif
-								      );
-
-	      out_INSERT_ROB_GPR_STATUS_VAL       [i][j] = interface->set_signal_valack_out(VAL);
-	       in_INSERT_ROB_GPR_STATUS_ACK       [i][j] = interface->set_signal_valack_in (ACK);
-	    }
-	    {
-	      Interface_fifo * interface = _interfaces->set_interface("insert_rob_spr_status_"+toString(i)+"_"+toString(j)
-#ifdef POSITION
-								      ,IN
-								      ,EAST
-								      ,"Interface to update status (insert)"
-#endif
-								      );
-
-	      out_INSERT_ROB_SPR_STATUS_VAL       [i][j] = interface->set_signal_valack_out(VAL);
-	       in_INSERT_ROB_SPR_STATUS_ACK       [i][j] = interface->set_signal_valack_in (ACK);
-	    }
-	  }
-      }
+    // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE_BEGIN("gpr_read",IN,NORTH,_("Interface to read generalist register"),_param->_nb_gpr_read);
+
+      ALLOC1_VALACK_IN ( in_GPR_READ_VAL           ,VAL);
+      ALLOC1_VALACK_OUT(out_GPR_READ_ACK           ,ACK);
+      ALLOC1_SIGNAL_IN ( in_GPR_READ_OOO_ENGINE_ID ,"ooo_engine_id",Tcontext_t     , _param->_size_ooo_engine_id);
+      ALLOC1_SIGNAL_OUT(out_GPR_READ_DATA          ,"data"         ,Tgeneral_data_t, _param->_size_general_data);
+      ALLOC1_SIGNAL_OUT(out_GPR_READ_DATA_VAL      ,"data_val"     ,Tcontrol_t     , 1);
+
+      ALLOC1_INTERFACE_END(_param->_nb_gpr_read);
+    }
+
+    {
+      ALLOC2_INTERFACE_BEGIN("gpr_read_registerfile",IN,NORTH,_("Interface to read generalist register - from/to register file"),_param->_nb_ooo_engine,_param->_nb_gpr_read);
+      
+      ALLOC2_VALACK_OUT(out_GPR_READ_REGISTERFILE_VAL ,VAL);
+      ALLOC2_VALACK_IN ( in_GPR_READ_REGISTERFILE_ACK ,ACK);
+      ALLOC2_SIGNAL_IN ( in_GPR_READ_REGISTERFILE_DATA,"data",Tgeneral_data_t,_param->_size_general_data);
+      
+      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_gpr_read);
+    }
+    
+    {
+      ALLOC2_INTERFACE_BEGIN("gpr_read_status",IN,NORTH,_("Interface to read generalist register - from/to register file"),_param->_nb_ooo_engine,_param->_nb_gpr_read);
+      
+      ALLOC2_VALACK_OUT(out_GPR_READ_STATUS_VAL      ,VAL);
+      ALLOC2_VALACK_IN ( in_GPR_READ_STATUS_ACK      ,ACK);
+      ALLOC2_SIGNAL_IN ( in_GPR_READ_STATUS_DATA_VAL,"data_val",Tcontrol_t,1);
+
+      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_gpr_read);
+    }
+
+    // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE_BEGIN("spr_read",IN,NORTH,_("Interface to read generalist register"),_param->_nb_spr_read);
+
+      ALLOC1_VALACK_IN ( in_SPR_READ_VAL           ,VAL);
+      ALLOC1_VALACK_OUT(out_SPR_READ_ACK           ,ACK);
+      ALLOC1_SIGNAL_IN ( in_SPR_READ_OOO_ENGINE_ID ,"ooo_engine_id",Tcontext_t     , _param->_size_ooo_engine_id);
+      ALLOC1_SIGNAL_OUT(out_SPR_READ_DATA          ,"data"         ,Tspecial_data_t, _param->_size_special_data);
+      ALLOC1_SIGNAL_OUT(out_SPR_READ_DATA_VAL      ,"data_val"     ,Tcontrol_t     , 1);
+
+      ALLOC1_INTERFACE_END(_param->_nb_spr_read);
+    }
+    
+    {
+      ALLOC2_INTERFACE_BEGIN("spr_read_registerfile",IN,NORTH,_("Interface to read generalist register - from/to register file"),_param->_nb_ooo_engine,_param->_nb_spr_read);
+      
+      ALLOC2_VALACK_OUT(out_SPR_READ_REGISTERFILE_VAL ,VAL);
+      ALLOC2_VALACK_IN ( in_SPR_READ_REGISTERFILE_ACK ,ACK);
+      ALLOC2_SIGNAL_IN ( in_SPR_READ_REGISTERFILE_DATA,"data",Tspecial_data_t,_param->_size_special_data);
+      
+      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_spr_read);
+    }
+    
+    {
+      ALLOC2_INTERFACE_BEGIN("spr_read_status",IN,NORTH,_("Interface to read generalist register - from/to status"),_param->_nb_ooo_engine,_param->_nb_spr_read);
+      
+      ALLOC2_VALACK_OUT(out_SPR_READ_STATUS_VAL      ,VAL);
+      ALLOC2_VALACK_IN ( in_SPR_READ_STATUS_ACK      ,ACK);
+      ALLOC2_SIGNAL_IN ( in_SPR_READ_STATUS_DATA_VAL,"data_val",Tcontrol_t,1);
+      
+      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_spr_read);
+    }
+
+    // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE_BEGIN("gpr_write",IN,NORTH,_("Interface to write generalist register"),_param->_nb_gpr_write);
+      
+      ALLOC1_VALACK_IN ( in_GPR_WRITE_VAL          ,VAL);
+      ALLOC1_VALACK_OUT(out_GPR_WRITE_ACK          ,ACK);
+      ALLOC1_SIGNAL_IN ( in_GPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t, _param->_size_ooo_engine_id);
+
+      ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
+    }
+    
+    {
+      ALLOC2_INTERFACE_BEGIN("gpr_write_registerfile",IN,NORTH,_("Interface to write generalist register - from/to registerfile"),_param->_nb_ooo_engine,_param->_nb_gpr_write);
+      
+      ALLOC2_VALACK_OUT(out_GPR_WRITE_REGISTERFILE_VAL,VAL);
+      ALLOC2_VALACK_IN ( in_GPR_WRITE_REGISTERFILE_ACK,ACK);
+
+      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_gpr_write);
+    }
+    
+    {
+      ALLOC2_INTERFACE_BEGIN("gpr_write_status",IN,NORTH,_("Interface to write generalist register - from/to status"),_param->_nb_ooo_engine,_param->_nb_gpr_write);
+      
+      ALLOC2_VALACK_OUT(out_GPR_WRITE_STATUS_VAL,VAL);
+      ALLOC2_VALACK_IN ( in_GPR_WRITE_STATUS_ACK,ACK);
+
+      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_gpr_write);
+    }
+
+    // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE_BEGIN("spr_write",IN,NORTH,_("Interface to write generalist register"),_param->_nb_spr_write);
+      
+      ALLOC1_VALACK_IN ( in_SPR_WRITE_VAL          ,VAL);
+      ALLOC1_VALACK_OUT(out_SPR_WRITE_ACK          ,ACK);
+      ALLOC1_SIGNAL_IN ( in_SPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t, _param->_size_ooo_engine_id);
+
+      ALLOC1_INTERFACE_END(_param->_nb_spr_write);
+    }
+    
+    {
+      ALLOC2_INTERFACE_BEGIN("spr_write_registerfile",IN,NORTH,_("Interface to write generalist register - from/to registerfile"),_param->_nb_ooo_engine,_param->_nb_spr_write);
+      
+      ALLOC2_VALACK_OUT(out_SPR_WRITE_REGISTERFILE_VAL,VAL);
+      ALLOC2_VALACK_IN ( in_SPR_WRITE_REGISTERFILE_ACK,ACK);
+
+      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_spr_write);
+    }
+    
+    {
+      ALLOC2_INTERFACE_BEGIN("spr_write_status",IN,NORTH,_("Interface to write generalist register - from/to status"),_param->_nb_ooo_engine,_param->_nb_spr_write);
+      
+      ALLOC2_VALACK_OUT(out_SPR_WRITE_STATUS_VAL,VAL);
+      ALLOC2_VALACK_IN ( in_SPR_WRITE_STATUS_ACK,ACK);
+
+      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_spr_write);
+    }
+
+    // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC2_INTERFACE_BEGIN("insert_rob",IN,WEST,_("Interface to update status (insert)"),_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      
+      _ALLOC2_VALACK_IN ( in_INSERT_ROB_VAL   ,VAL                   ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      _ALLOC2_VALACK_OUT(out_INSERT_ROB_ACK   ,ACK                   ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RD_USE,"rd_use",Tcontrol_t, 1,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RE_USE,"re_use",Tcontrol_t, 1,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+
+      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+    }
+    
+    {
+      ALLOC2_INTERFACE_BEGIN("insert_rob_gpr_status",IN,WEST,_("Interface to update status (insert)"),_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      
+      _ALLOC2_VALACK_OUT(out_INSERT_ROB_GPR_STATUS_VAL,VAL,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      _ALLOC2_VALACK_IN ( in_INSERT_ROB_GPR_STATUS_ACK,ACK,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+
+      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+    }
+    
+    {
+      ALLOC2_INTERFACE_BEGIN("insert_rob_spr_status",IN,WEST,_("Interface to update status (insert)"),_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      
+      _ALLOC2_VALACK_OUT(out_INSERT_ROB_SPR_STATUS_VAL,VAL,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      _ALLOC2_VALACK_IN ( in_INSERT_ROB_SPR_STATUS_ACK,ACK,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+
+      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+    }
 
 //     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_deallocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_deallocation.cpp	(revision 112)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Register_unit_Glue.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -26,90 +27,69 @@
       {
 //#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
-    delete    in_CLOCK ;
+    delete  in_CLOCK ;
 //#endif
-    delete    in_NRESET;
+    delete  in_NRESET;
+    delete out_CONST_0;
+    delete out_CONST_1;
 
-    // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete []  in_GPR_READ_VAL               ;
-    delete [] out_GPR_READ_ACK               ;
-    if (_param->_have_port_ooo_engine_id == true)
-    delete []  in_GPR_READ_OOO_ENGINE_ID     ;
-    delete [] out_GPR_READ_DATA              ;
-    delete [] out_GPR_READ_DATA_VAL          ;
+    DELETE1_SIGNAL( in_GPR_READ_VAL           ,_param->_nb_gpr_read,1  );
+    DELETE1_SIGNAL(out_GPR_READ_ACK           ,_param->_nb_gpr_read,1  );
+    DELETE1_SIGNAL( in_GPR_READ_OOO_ENGINE_ID ,_param->_nb_gpr_read,_param->_size_ooo_engine_id);
+    DELETE1_SIGNAL(out_GPR_READ_DATA          ,_param->_nb_gpr_read,_param->_size_general_data);
+    DELETE1_SIGNAL(out_GPR_READ_DATA_VAL      ,_param->_nb_gpr_read,1);
+    
+    DELETE2_SIGNAL(out_GPR_READ_REGISTERFILE_VAL ,_param->_nb_ooo_engine,_param->_nb_gpr_read,1  );
+    DELETE2_SIGNAL( in_GPR_READ_REGISTERFILE_ACK ,_param->_nb_ooo_engine,_param->_nb_gpr_read,1  );
+    DELETE2_SIGNAL( in_GPR_READ_REGISTERFILE_DATA,_param->_nb_ooo_engine,_param->_nb_gpr_read,_param->_size_general_data);
 
-    delete [] out_GPR_READ_REGISTERFILE_VAL  ;
-    delete []  in_GPR_READ_REGISTERFILE_ACK  ;
-    delete []  in_GPR_READ_REGISTERFILE_DATA ;
+    DELETE2_SIGNAL(out_GPR_READ_STATUS_VAL     ,_param->_nb_ooo_engine,_param->_nb_gpr_read,1  );
+    DELETE2_SIGNAL( in_GPR_READ_STATUS_ACK     ,_param->_nb_ooo_engine,_param->_nb_gpr_read,1  );
+    DELETE2_SIGNAL( in_GPR_READ_STATUS_DATA_VAL,_param->_nb_ooo_engine,_param->_nb_gpr_read,1);
 
-    delete [] out_GPR_READ_STATUS_VAL        ;
-    delete []  in_GPR_READ_STATUS_ACK        ;
-    delete []  in_GPR_READ_STATUS_DATA_VAL   ;
+    DELETE1_SIGNAL( in_SPR_READ_VAL           ,_param->_nb_spr_read,1  );
+    DELETE1_SIGNAL(out_SPR_READ_ACK           ,_param->_nb_spr_read,1  );
+    DELETE1_SIGNAL( in_SPR_READ_OOO_ENGINE_ID ,_param->_nb_spr_read,_param->_size_ooo_engine_id);
+    DELETE1_SIGNAL(out_SPR_READ_DATA          ,_param->_nb_spr_read,_param->_size_special_data);
+    DELETE1_SIGNAL(out_SPR_READ_DATA_VAL      ,_param->_nb_spr_read,1);
+    
+    DELETE2_SIGNAL(out_SPR_READ_REGISTERFILE_VAL ,_param->_nb_ooo_engine,_param->_nb_spr_read,1  );
+    DELETE2_SIGNAL( in_SPR_READ_REGISTERFILE_ACK ,_param->_nb_ooo_engine,_param->_nb_spr_read,1  );
+    DELETE2_SIGNAL( in_SPR_READ_REGISTERFILE_DATA,_param->_nb_ooo_engine,_param->_nb_spr_read,_param->_size_special_data);
+    
+    DELETE2_SIGNAL(out_SPR_READ_STATUS_VAL     ,_param->_nb_ooo_engine,_param->_nb_spr_read,1  );
+    DELETE2_SIGNAL( in_SPR_READ_STATUS_ACK     ,_param->_nb_ooo_engine,_param->_nb_spr_read,1  );
+    DELETE2_SIGNAL( in_SPR_READ_STATUS_DATA_VAL,_param->_nb_ooo_engine,_param->_nb_spr_read,1);
+    
+    DELETE1_SIGNAL( in_GPR_WRITE_VAL          ,_param->_nb_gpr_write,1  );
+    DELETE1_SIGNAL(out_GPR_WRITE_ACK          ,_param->_nb_gpr_write,1  );
+    DELETE1_SIGNAL( in_GPR_WRITE_OOO_ENGINE_ID,_param->_nb_gpr_write,_param->_size_ooo_engine_id);
 
+    
+    DELETE2_SIGNAL(out_GPR_WRITE_REGISTERFILE_VAL,_param->_nb_ooo_engine,_param->_nb_gpr_write,1  );
+    DELETE2_SIGNAL( in_GPR_WRITE_REGISTERFILE_ACK,_param->_nb_ooo_engine,_param->_nb_gpr_write,1  );
 
-    // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete []  in_SPR_READ_VAL               ;
-    delete [] out_SPR_READ_ACK               ;
-    if (_param->_have_port_ooo_engine_id == true)
-    delete []  in_SPR_READ_OOO_ENGINE_ID     ;
-    delete [] out_SPR_READ_DATA              ;
-    delete [] out_SPR_READ_DATA_VAL          ;
+    DELETE2_SIGNAL(out_GPR_WRITE_STATUS_VAL,_param->_nb_ooo_engine,_param->_nb_gpr_write,1  );
+    DELETE2_SIGNAL( in_GPR_WRITE_STATUS_ACK,_param->_nb_ooo_engine,_param->_nb_gpr_write,1  );
 
-    delete [] out_SPR_READ_REGISTERFILE_VAL  ;
-    delete []  in_SPR_READ_REGISTERFILE_ACK  ;
-    delete []  in_SPR_READ_REGISTERFILE_DATA ;
+    DELETE1_SIGNAL( in_SPR_WRITE_VAL          ,_param->_nb_spr_write,1  );
+    DELETE1_SIGNAL(out_SPR_WRITE_ACK          ,_param->_nb_spr_write,1  );
+    DELETE1_SIGNAL( in_SPR_WRITE_OOO_ENGINE_ID,_param->_nb_spr_write,_param->_size_ooo_engine_id);
 
-    delete [] out_SPR_READ_STATUS_VAL        ;
-    delete []  in_SPR_READ_STATUS_ACK        ;
-    delete []  in_SPR_READ_STATUS_DATA_VAL   ;
+    DELETE2_SIGNAL(out_SPR_WRITE_REGISTERFILE_VAL,_param->_nb_ooo_engine,_param->_nb_spr_write,1  );
+    DELETE2_SIGNAL( in_SPR_WRITE_REGISTERFILE_ACK,_param->_nb_ooo_engine,_param->_nb_spr_write,1  );
 
-    // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete []  in_GPR_WRITE_VAL               ;
-    delete [] out_GPR_WRITE_ACK               ;
-    if (_param->_have_port_ooo_engine_id == true)
-    delete []  in_GPR_WRITE_OOO_ENGINE_ID     ;
+    DELETE2_SIGNAL(out_SPR_WRITE_STATUS_VAL,_param->_nb_ooo_engine,_param->_nb_spr_write,1  );
+    DELETE2_SIGNAL( in_SPR_WRITE_STATUS_ACK,_param->_nb_ooo_engine,_param->_nb_spr_write,1  );
 
-    delete [] out_GPR_WRITE_REGISTERFILE_VAL  ;
-    delete []  in_GPR_WRITE_REGISTERFILE_ACK  ;
+    DELETE2_SIGNAL( in_INSERT_ROB_VAL   ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
+    DELETE2_SIGNAL(out_INSERT_ROB_ACK   ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
+    DELETE2_SIGNAL( in_INSERT_ROB_RD_USE,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
+    DELETE2_SIGNAL( in_INSERT_ROB_RE_USE,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
 
-    delete [] out_GPR_WRITE_STATUS_VAL        ;
-    delete []  in_GPR_WRITE_STATUS_ACK        ;
+    DELETE2_SIGNAL(out_INSERT_ROB_GPR_STATUS_VAL,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
+    DELETE2_SIGNAL( in_INSERT_ROB_GPR_STATUS_ACK,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
 
-    // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete []  in_SPR_WRITE_VAL               ;
-    delete [] out_SPR_WRITE_ACK               ;
-    if (_param->_have_port_ooo_engine_id == true)
-    delete []  in_SPR_WRITE_OOO_ENGINE_ID     ;
-
-    delete [] out_SPR_WRITE_REGISTERFILE_VAL  ;
-    delete []  in_SPR_WRITE_REGISTERFILE_ACK  ;
-
-    delete [] out_SPR_WRITE_STATUS_VAL        ;
-    delete []  in_SPR_WRITE_STATUS_ACK        ;
-
-    // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete []  in_INSERT_ROB_VAL                  ;
-    delete [] out_INSERT_ROB_ACK                  ;
-    delete []  in_INSERT_ROB_RD_USE               ;
-    delete []  in_INSERT_ROB_RE_USE               ;
-    delete [] out_INSERT_ROB_GPR_STATUS_VAL       ;
-    delete []  in_INSERT_ROB_GPR_STATUS_ACK       ;
-    delete [] out_INSERT_ROB_SPR_STATUS_VAL       ;
-    delete []  in_INSERT_ROB_SPR_STATUS_ACK       ;
-
-//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//     delete []  in_RETIRE_ROB_VAL                      ;
-//     delete [] out_RETIRE_ROB_ACK                      ;
-//     delete []  in_RETIRE_ROB_RD_OLD_USE               ;
-//     delete []  in_RETIRE_ROB_RD_NEW_USE               ;
-//     delete []  in_RETIRE_ROB_RE_OLD_USE               ;
-//     delete []  in_RETIRE_ROB_RE_NEW_USE               ;
-//     delete [] out_RETIRE_ROB_GPR_STATUS_OLD_VAL       ;
-//     delete [] out_RETIRE_ROB_GPR_STATUS_NEW_VAL       ;
-//     delete []  in_RETIRE_ROB_GPR_STATUS_OLD_ACK       ;
-//     delete []  in_RETIRE_ROB_GPR_STATUS_NEW_ACK       ;
-//     delete [] out_RETIRE_ROB_SPR_STATUS_OLD_VAL       ;
-//     delete [] out_RETIRE_ROB_SPR_STATUS_NEW_VAL       ;
-//     delete []  in_RETIRE_ROB_SPR_STATUS_OLD_ACK       ;
-//     delete []  in_RETIRE_ROB_SPR_STATUS_NEW_ACK       ;
+    DELETE2_SIGNAL(out_INSERT_ROB_SPR_STATUS_VAL,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
+    DELETE2_SIGNAL( in_INSERT_ROB_SPR_STATUS_ACK,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
       }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit_allocation.cpp	(revision 112)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/include/Register_unit.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo {
@@ -52,150 +53,70 @@
 
     // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    in_GPR_READ_VAL                 = new SC_IN (Tcontrol_t        )   * [_param->_nb_gpr_read];
-    out_GPR_READ_ACK                 = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_read];
-    if (_param->_have_port_ooo_engine_id == true)
-      in_GPR_READ_OOO_ENGINE_ID       = new SC_IN (Tcontext_t        )   * [_param->_nb_gpr_read];
-    in_GPR_READ_NUM_REG             = new SC_IN (Tgeneral_address_t)   * [_param->_nb_gpr_read];
-    out_GPR_READ_DATA                = new SC_OUT(Tgeneral_data_t   )   * [_param->_nb_gpr_read];
-    out_GPR_READ_DATA_VAL            = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_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
-								,NORTH
-								,"Interface to read the register file"
-#endif
-								);
-	 
-	in_GPR_READ_VAL           [i]= interface->set_signal_valack_in  (VAL);
-	out_GPR_READ_ACK           [i]= interface->set_signal_valack_out (ACK);
-	if (_param->_have_port_ooo_engine_id == true)
-	  in_GPR_READ_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , _param->_size_ooo_engine_id);
-	in_GPR_READ_NUM_REG       [i]= interface->set_signal_in <Tgeneral_address_t> ("num_reg"       , _param->_size_gpr_address);
-	out_GPR_READ_DATA          [i]= interface->set_signal_out<Tgeneral_data_t   > ("data"          , _param->_size_general_data);
-	out_GPR_READ_DATA_VAL      [i]= interface->set_signal_out<Tcontrol_t        > ("data_val"      , 1);
-      }
+    {
+      ALLOC1_INTERFACE_BEGIN("gpr_read",IN,NORTH,_("Interface to read the register file"),_param->_nb_gpr_read);
+      
+      ALLOC1_VALACK_IN ( in_GPR_READ_VAL          ,VAL);
+      ALLOC1_VALACK_OUT(out_GPR_READ_ACK          ,ACK);
+      ALLOC1_SIGNAL_IN ( in_GPR_READ_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
+      ALLOC1_SIGNAL_IN ( in_GPR_READ_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_gpr_address);
+      ALLOC1_SIGNAL_OUT(out_GPR_READ_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
+      ALLOC1_SIGNAL_OUT(out_GPR_READ_DATA_VAL     ,"data_val"     ,Tcontrol_t        ,1);
+
+      ALLOC1_INTERFACE_END(_param->_nb_gpr_read);
+    }
 
     // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    in_GPR_WRITE_VAL                 = new SC_IN (Tcontrol_t        )   * [_param->_nb_gpr_write];
-    out_GPR_WRITE_ACK                 = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_write];
-    if (_param->_have_port_ooo_engine_id == true)
-      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];
-     
-    for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
-      {
-	Interface_fifo * interface = _interfaces->set_interface("gpr_write_"+toString(i)
-#ifdef POSITION
-								,IN
-								,NORTH,
-								"Interface to write the register file"
-#endif
-								);
-	 
-	in_GPR_WRITE_VAL           [i]= interface->set_signal_valack_in  (VAL);
-	out_GPR_WRITE_ACK           [i]= interface->set_signal_valack_out (ACK);
-	if (_param->_have_port_ooo_engine_id == true)
-	  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_gpr_address);
-	in_GPR_WRITE_DATA          [i]= interface->set_signal_in <Tgeneral_data_t   > ("data"          , _param->_size_general_data);
-      }
+    {
+      ALLOC1_INTERFACE_BEGIN("gpr_write",IN,NORTH,_("Interface to write the register file"),_param->_nb_gpr_write);
+
+      ALLOC1_VALACK_IN ( in_GPR_WRITE_VAL          ,VAL);
+      ALLOC1_VALACK_OUT(out_GPR_WRITE_ACK          ,ACK);
+      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_gpr_address);
+      ALLOC1_SIGNAL_IN ( in_GPR_WRITE_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
+
+      ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
+    }
 
     // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    in_SPR_READ_VAL                 = new SC_IN (Tcontrol_t        )   * [_param->_nb_spr_read];
-    out_SPR_READ_ACK                 = new SC_OUT(Tcontrol_t        )   * [_param->_nb_spr_read];
-    if (_param->_have_port_ooo_engine_id == true)
-      in_SPR_READ_OOO_ENGINE_ID       = new SC_IN (Tcontext_t        )   * [_param->_nb_spr_read];
-    in_SPR_READ_NUM_REG             = new SC_IN (Tspecial_address_t)   * [_param->_nb_spr_read];
-    out_SPR_READ_DATA                = new SC_OUT(Tspecial_data_t   )   * [_param->_nb_spr_read];
-    out_SPR_READ_DATA_VAL            = new SC_OUT(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
-								,NORTH,
-								"Interface to read the register file"
-#endif
-								);
-	 
-	in_SPR_READ_VAL           [i]= interface->set_signal_valack_in  (VAL);
-	out_SPR_READ_ACK           [i]= interface->set_signal_valack_out (ACK);
-	if (_param->_have_port_ooo_engine_id == true)
-	  in_SPR_READ_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , _param->_size_ooo_engine_id);
-	in_SPR_READ_NUM_REG       [i]= interface->set_signal_in <Tspecial_address_t> ("num_reg"       , _param->_size_spr_address);
-	out_SPR_READ_DATA          [i]= interface->set_signal_out<Tspecial_data_t   > ("data"          , _param->_size_special_data);
-	out_SPR_READ_DATA_VAL      [i]= interface->set_signal_out<Tcontrol_t        > ("data_val"      , 1);
-      }
+    {
+      ALLOC1_INTERFACE_BEGIN("spr_read",IN,NORTH,_("Interface to read the register file"),_param->_nb_spr_read);
+      
+      ALLOC1_VALACK_IN ( in_SPR_READ_VAL          ,VAL);
+      ALLOC1_VALACK_OUT(out_SPR_READ_ACK          ,ACK);
+      ALLOC1_SIGNAL_IN ( in_SPR_READ_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
+      ALLOC1_SIGNAL_IN ( in_SPR_READ_NUM_REG      ,"num_reg"      ,Tspecial_address_t,_param->_size_spr_address);
+      ALLOC1_SIGNAL_OUT(out_SPR_READ_DATA         ,"data"         ,Tspecial_data_t   ,_param->_size_special_data);
+      ALLOC1_SIGNAL_OUT(out_SPR_READ_DATA_VAL     ,"data_val"     ,Tcontrol_t        ,1);
+
+      ALLOC1_INTERFACE_END(_param->_nb_spr_read);
+    }
 
     // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    in_SPR_WRITE_VAL                 = new SC_IN (Tcontrol_t        )   * [_param->_nb_spr_write];
-    out_SPR_WRITE_ACK                 = new SC_OUT(Tcontrol_t        )   * [_param->_nb_spr_write];
-    if (_param->_have_port_ooo_engine_id == true)
-      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
-								,NORTH,
-								"Interface to write the register file"
-#endif
-								);
-	 
-	in_SPR_WRITE_VAL           [i]= interface->set_signal_valack_in  (VAL);
-	out_SPR_WRITE_ACK           [i]= interface->set_signal_valack_out (ACK);
-	if (_param->_have_port_ooo_engine_id == true)
-	  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_spr_address);
-	in_SPR_WRITE_DATA          [i]= interface->set_signal_in <Tspecial_data_t   > ("data"          , _param->_size_special_data);
-      }
-
-    // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    in_INSERT_ROB_VAL        = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-    out_INSERT_ROB_ACK        = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-    in_INSERT_ROB_RD_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-    in_INSERT_ROB_RD_NUM_REG = new SC_IN (Tgeneral_address_t)  ** [_param->_nb_ooo_engine];
-    in_INSERT_ROB_RE_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
-    in_INSERT_ROB_RE_NUM_REG = new SC_IN (Tspecial_address_t)  ** [_param->_nb_ooo_engine];
-
-    for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
-      {
-	uint32_t x=_param->_nb_inst_insert_rob [i];
-
-	in_INSERT_ROB_VAL        [i] = new SC_IN (Tcontrol_t        )  * [x];
-	out_INSERT_ROB_ACK        [i] = new SC_OUT(Tcontrol_t        )  * [x];
-	in_INSERT_ROB_RD_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
-	in_INSERT_ROB_RD_NUM_REG [i] = new SC_IN (Tgeneral_address_t)  * [x];
-	in_INSERT_ROB_RE_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
-	in_INSERT_ROB_RE_NUM_REG [i] = new SC_IN (Tspecial_address_t)  * [x];
-
-	for (uint32_t j=0; j<x; j++)
-	  {
-	    Interface_fifo * interface = _interfaces->set_interface("insert_rob_"+toString(i)+"_"+toString(j)
-#ifdef POSITION
-								    ,IN
-								    ,WEST
-								    ,"Interface to update status (insert)"
-#endif
-								    );
-
-
-	    in_INSERT_ROB_VAL        [i][j] = interface->set_signal_valack_in  (VAL);
-	    out_INSERT_ROB_ACK        [i][j] = interface->set_signal_valack_out (ACK);
-	    in_INSERT_ROB_RD_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("rd_use"    , 1);
-	    in_INSERT_ROB_RD_NUM_REG [i][j] = interface->set_signal_in <Tgeneral_address_t> ("rd_num_reg", _param->_size_gpr_address);
-	    in_INSERT_ROB_RE_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("re_use"    , 1);
-	    in_INSERT_ROB_RE_NUM_REG [i][j] = interface->set_signal_in <Tspecial_address_t> ("re_num_reg", _param->_size_spr_address);
-	     
-	  }
-      }
+    {
+      ALLOC1_INTERFACE_BEGIN("spr_write",IN,NORTH,_("Interface to write the register file"),_param->_nb_spr_write);
+
+      ALLOC1_VALACK_IN ( in_SPR_WRITE_VAL          ,VAL);
+      ALLOC1_VALACK_OUT(out_SPR_WRITE_ACK          ,ACK);
+      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"      ,Tspecial_address_t,_param->_size_spr_address);
+      ALLOC1_SIGNAL_IN ( in_SPR_WRITE_DATA         ,"data"         ,Tspecial_data_t   ,_param->_size_special_data);
+
+      ALLOC1_INTERFACE_END(_param->_nb_spr_write);
+    }
+
+    // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC2_INTERFACE_BEGIN("insert_rob",IN,WEST,_("Interface to update status (insert)"),_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      
+      _ALLOC2_VALACK_IN ( in_INSERT_ROB_VAL       ,VAL                                                      ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      _ALLOC2_VALACK_OUT(out_INSERT_ROB_ACK       ,ACK                                                      ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RD_USE    ,"rd_use"    ,Tcontrol_t        ,1                        ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RD_NUM_REG,"rd_num_reg",Tgeneral_address_t,_param->_size_gpr_address,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RE_USE    ,"re_use"    ,Tcontrol_t        ,1                        ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RE_NUM_REG,"re_num_reg",Tspecial_address_t,_param->_size_spr_address,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+      
+      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
+    }
 
 //     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit_deallocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit_deallocation.cpp	(revision 112)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/include/Register_unit.h"
+#include "Behavioural/include/Allocation.h"
 
 namespace morpheo                    {
@@ -24,41 +25,40 @@
     if (usage_is_set(_usage,USE_SYSTEMC))
       {
-//#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
-    delete     in_CLOCK ;
-//#endif
-    delete     in_NRESET;
+        delete     in_CLOCK ;
+        delete     in_NRESET;
 
-    delete []  in_GPR_READ_VAL                 ;
-    delete [] out_GPR_READ_ACK                 ;
-    if (_param->_have_port_ooo_engine_id == true)
-      delete []  in_GPR_READ_OOO_ENGINE_ID       ;
-    delete []  in_GPR_READ_NUM_REG             ;
-    delete [] out_GPR_READ_DATA                ;
-    delete [] out_GPR_READ_DATA_VAL            ;
-    delete []  in_GPR_WRITE_VAL                ;
-    delete [] out_GPR_WRITE_ACK                ;
-    if (_param->_have_port_ooo_engine_id == true)
-      delete []  in_GPR_WRITE_OOO_ENGINE_ID      ;
-    delete []  in_GPR_WRITE_NUM_REG            ;
-    delete []  in_GPR_WRITE_DATA               ;
-    delete []  in_SPR_READ_VAL                 ;
-    delete [] out_SPR_READ_ACK                 ;
-    if (_param->_have_port_ooo_engine_id == true)
-      delete []  in_SPR_READ_OOO_ENGINE_ID       ;
-    delete []  in_SPR_READ_NUM_REG             ;
-    delete [] out_SPR_READ_DATA                ;
-    delete [] out_SPR_READ_DATA_VAL            ;
-    delete []  in_SPR_WRITE_VAL                ;
-    delete [] out_SPR_WRITE_ACK                ;
-    if (_param->_have_port_ooo_engine_id == true)
-      delete []  in_SPR_WRITE_OOO_ENGINE_ID      ;
-    delete []  in_SPR_WRITE_NUM_REG            ;
-    delete []  in_SPR_WRITE_DATA               ;
-    delete []  in_INSERT_ROB_VAL               ;
-    delete [] out_INSERT_ROB_ACK               ;
-    delete []  in_INSERT_ROB_RD_USE            ;
-    delete []  in_INSERT_ROB_RD_NUM_REG        ;
-    delete []  in_INSERT_ROB_RE_USE            ;
-    delete []  in_INSERT_ROB_RE_NUM_REG        ;
+        DELETE1_SIGNAL( in_GPR_READ_VAL           ,_param->_nb_gpr_read,1);
+        DELETE1_SIGNAL(out_GPR_READ_ACK           ,_param->_nb_gpr_read,1);
+        DELETE1_SIGNAL( in_GPR_READ_OOO_ENGINE_ID ,_param->_nb_gpr_read,_param->_size_ooo_engine_id);
+        DELETE1_SIGNAL( in_GPR_READ_NUM_REG       ,_param->_nb_gpr_read,_param->_size_gpr_address);
+        DELETE1_SIGNAL(out_GPR_READ_DATA          ,_param->_nb_gpr_read,_param->_size_general_data);
+        DELETE1_SIGNAL(out_GPR_READ_DATA_VAL      ,_param->_nb_gpr_read,1);
+        
+        DELETE1_SIGNAL( in_GPR_WRITE_VAL          ,_param->_nb_gpr_write,1);
+        DELETE1_SIGNAL(out_GPR_WRITE_ACK          ,_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_gpr_address);
+        DELETE1_SIGNAL( in_GPR_WRITE_DATA         ,_param->_nb_gpr_write,_param->_size_general_data);
+
+        DELETE1_SIGNAL( in_SPR_READ_VAL           ,_param->_nb_spr_read,1);
+        DELETE1_SIGNAL(out_SPR_READ_ACK           ,_param->_nb_spr_read,1);
+        DELETE1_SIGNAL( in_SPR_READ_OOO_ENGINE_ID ,_param->_nb_spr_read,_param->_size_ooo_engine_id);
+        DELETE1_SIGNAL( in_SPR_READ_NUM_REG       ,_param->_nb_spr_read,_param->_size_spr_address);
+        DELETE1_SIGNAL(out_SPR_READ_DATA          ,_param->_nb_spr_read,_param->_size_special_data);
+        DELETE1_SIGNAL(out_SPR_READ_DATA_VAL      ,_param->_nb_spr_read,1);
+        
+        DELETE1_SIGNAL( in_SPR_WRITE_VAL          ,_param->_nb_spr_write,1);
+        DELETE1_SIGNAL(out_SPR_WRITE_ACK          ,_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_spr_address);
+        DELETE1_SIGNAL( in_SPR_WRITE_DATA         ,_param->_nb_spr_write,_param->_size_special_data);
+                
+        DELETE2_SIGNAL( in_INSERT_ROB_VAL         ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
+        DELETE2_SIGNAL(out_INSERT_ROB_ACK         ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
+        DELETE2_SIGNAL( in_INSERT_ROB_RD_USE      ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
+        DELETE2_SIGNAL( in_INSERT_ROB_RD_NUM_REG  ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],_param->_size_gpr_address);
+        DELETE2_SIGNAL( in_INSERT_ROB_RE_USE      ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
+        DELETE2_SIGNAL( in_INSERT_ROB_RE_NUM_REG  ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],_param->_size_spr_address);
+
 //     delete []  in_RETIRE_ROB_VAL               ;
 //     delete [] out_RETIRE_ROB_ACK               ;
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Execute_loop_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Execute_loop_allocation.cpp	(revision 111)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Execute_loop_allocation.cpp	(revision 112)
@@ -55,5 +55,5 @@
     // ~~~~~[ Interface "execute_loop_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC1_INTERFACE("execute_loop_in", IN, EAST, "Operation's Input", _param->_nb_read_unit);
+       ALLOC1_INTERFACE_BEGIN("execute_loop_in", IN, EAST, "Operation's Input", _param->_nb_read_unit);
 
        ALLOC1_VALACK_IN ( in_EXECUTE_LOOP_IN_VAL,VAL);
@@ -66,5 +66,4 @@
        ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type);         
        ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr);
-       if (_param->_have_port_load_queue_ptr)
        ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr);
        ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1);
@@ -80,8 +79,10 @@
        ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1);
        ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);
+
+       ALLOC1_INTERFACE_END(param->_nb_read_unit);
      }
     // ~~~~~[ Interface "execute_loop_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC1_INTERFACE("execute_loop_out",OUT, EAST, "Operation's Output", _param->_nb_write_unit);
+       ALLOC1_INTERFACE_BEGIN("execute_loop_out",OUT, EAST, "Operation's Output", _param->_nb_write_unit);
 
        ALLOC1_VALACK_OUT(out_EXECUTE_LOOP_OUT_VAL,VAL);
@@ -98,8 +99,10 @@
        ALLOC1_SIGNAL_OUT(out_EXECUTE_LOOP_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
        ALLOC1_SIGNAL_OUT(out_EXECUTE_LOOP_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data);
+
+       ALLOC1_INTERFACE_END(_param->_nb_write_unit);
      }
     // ~~~~~[ Interface "dcache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC2_INTERFACE("dcache_req",OUT, NORTH, "Data cache port : request", _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
+       ALLOC2_INTERFACE_BEGIN("dcache_req",OUT, NORTH, "Data cache port : request", _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
        
        _ALLOC2_VALACK_OUT(out_DCACHE_REQ_VAL,VAL, _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
@@ -110,8 +113,11 @@
        _ALLOC2_SIGNAL_OUT(out_DCACHE_REQ_TYPE      ,"type"      ,Tdcache_type_t   ,_param->_size_dcache_type          , _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
        _ALLOC2_SIGNAL_OUT(out_DCACHE_REQ_WDATA     ,"wdata"     ,Tdcache_data_t   ,_param->_size_general_data         , _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
+
+       ALLOC2_INTERFACE_END(_param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
      }
+
     // ~~~~~[ Interface "dcache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC2_INTERFACE("dcache_rsp",IN, NORTH, "Data cache port : respons", _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
+       ALLOC2_INTERFACE_BEGIN("dcache_rsp",IN, NORTH, "Data cache port : respons", _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
 
        _ALLOC2_VALACK_IN ( in_DCACHE_RSP_VAL,VAL, _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
@@ -121,8 +127,11 @@
        _ALLOC2_SIGNAL_IN ( in_DCACHE_RSP_RDATA     ,"rdata"     ,Tdcache_data_t ,_param->_size_general_data         , _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
        _ALLOC2_SIGNAL_IN ( in_DCACHE_RSP_ERROR     ,"error"     ,Tdcache_error_t,_param->_size_dcache_error         , _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
+
+       ALLOC2_INTERFACE_END(_param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
      }
+
     // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      {
-       ALLOC2_INTERFACE("insert_rob",IN, EAST, "Rename's stage : insert a new instruction in the Re Order Buffer",_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+       ALLOC2_INTERFACE_BEGIN("insert_rob",IN, EAST, "Rename's stage : insert a new instruction in the Re Order Buffer",_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
        
        _ALLOC2_VALACK_IN ( in_INSERT_ROB_VAL,VAL,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
@@ -133,5 +142,8 @@
        _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RE_USE    ,"re_use"    ,Tcontrol_t        ,1                             ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
        _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RE_NUM_REG,"re_num_reg",Tspecial_address_t,_param->_size_special_register,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+
+       ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
      }
+
 //     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //      {
