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
